add Nudm_UEContextManagement Service operations

src/api/AMF3GppAccessRegistrationInfoRetrievalApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "AMF3GppAccessRegistrationInfoRetrievalApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+AMF3GppAccessRegistrationInfoRetrievalApi::AMF3GppAccessRegistrationInfoRetrievalApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void AMF3GppAccessRegistrationInfoRetrievalApi::init() {
+    setupRoutes();
+}
+
+void AMF3GppAccessRegistrationInfoRetrievalApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Get(*router, base + "/:ueId/registrations/amf-3gpp-access", Routes::bind(&AMF3GppAccessRegistrationInfoRetrievalApi::get3_gpp_registration_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&AMF3GppAccessRegistrationInfoRetrievalApi::amf3_gpp_access_registration_info_retrieval_api_default_handler, this));
+}
+
+void AMF3GppAccessRegistrationInfoRetrievalApi::get3_gpp_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    
+    // Getting the query params
+    auto supportedFeaturesQuery = request.query().get("supported-features");
+    Pistache::Optional<std::string> supportedFeatures;
+    if(!supportedFeaturesQuery.isEmpty()){
+        std::string valueQuery_instance;
+        if(fromStringValue(supportedFeaturesQuery.get(), valueQuery_instance)){
+            supportedFeatures = Pistache::Some(valueQuery_instance);
+        }
+    }
+    
+    try {
+      this->get3_gpp_registration(ueId, supportedFeatures, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void AMF3GppAccessRegistrationInfoRetrievalApi::amf3_gpp_access_registration_info_retrieval_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/AMF3GppAccessRegistrationInfoRetrievalApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * AMF3GppAccessRegistrationInfoRetrievalApi.h
+ *
+ * 
+ */
+
+#ifndef AMF3GppAccessRegistrationInfoRetrievalApi_H_
+#define AMF3GppAccessRegistrationInfoRetrievalApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "Amf3GppAccessRegistration.h"
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  AMF3GppAccessRegistrationInfoRetrievalApi {
+public:
+    AMF3GppAccessRegistrationInfoRetrievalApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~AMF3GppAccessRegistrationInfoRetrievalApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void get3_gpp_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void amf3_gpp_access_registration_info_retrieval_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// retrieve the AMF registration for 3GPP access information
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="supportedFeatures"> (optional, default to &quot;&quot;)</param>
+    virtual void get3_gpp_registration(const std::string &ueId, const Pistache::Optional<std::string> &supportedFeatures, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* AMF3GppAccessRegistrationInfoRetrievalApi_H_ */
+

src/api/AMFNon3GPPAccessRegistrationInfoRetrievalApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "AMFNon3GPPAccessRegistrationInfoRetrievalApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+AMFNon3GPPAccessRegistrationInfoRetrievalApi::AMFNon3GPPAccessRegistrationInfoRetrievalApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void AMFNon3GPPAccessRegistrationInfoRetrievalApi::init() {
+    setupRoutes();
+}
+
+void AMFNon3GPPAccessRegistrationInfoRetrievalApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Get(*router, base + "/:ueId/registrations/amf-non-3gpp-access", Routes::bind(&AMFNon3GPPAccessRegistrationInfoRetrievalApi::get_non3_gpp_registration_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&AMFNon3GPPAccessRegistrationInfoRetrievalApi::amf_non3_gpp_access_registration_info_retrieval_api_default_handler, this));
+}
+
+void AMFNon3GPPAccessRegistrationInfoRetrievalApi::get_non3_gpp_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    
+    // Getting the query params
+    auto supportedFeaturesQuery = request.query().get("supported-features");
+    Pistache::Optional<std::string> supportedFeatures;
+    if(!supportedFeaturesQuery.isEmpty()){
+        std::string valueQuery_instance;
+        if(fromStringValue(supportedFeaturesQuery.get(), valueQuery_instance)){
+            supportedFeatures = Pistache::Some(valueQuery_instance);
+        }
+    }
+    
+    try {
+      this->get_non3_gpp_registration(ueId, supportedFeatures, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void AMFNon3GPPAccessRegistrationInfoRetrievalApi::amf_non3_gpp_access_registration_info_retrieval_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/AMFNon3GPPAccessRegistrationInfoRetrievalApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * AMFNon3GPPAccessRegistrationInfoRetrievalApi.h
+ *
+ * 
+ */
+
+#ifndef AMFNon3GPPAccessRegistrationInfoRetrievalApi_H_
+#define AMFNon3GPPAccessRegistrationInfoRetrievalApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "AmfNon3GppAccessRegistration.h"
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  AMFNon3GPPAccessRegistrationInfoRetrievalApi {
+public:
+    AMFNon3GPPAccessRegistrationInfoRetrievalApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~AMFNon3GPPAccessRegistrationInfoRetrievalApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void get_non3_gpp_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void amf_non3_gpp_access_registration_info_retrieval_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// retrieve the AMF registration for non-3GPP access information
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="supportedFeatures"> (optional, default to &quot;&quot;)</param>
+    virtual void get_non3_gpp_registration(const std::string &ueId, const Pistache::Optional<std::string> &supportedFeatures, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* AMFNon3GPPAccessRegistrationInfoRetrievalApi_H_ */
+

src/api/AMFRegistrationFor3GPPAccessApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "AMFRegistrationFor3GPPAccessApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+AMFRegistrationFor3GPPAccessApi::AMFRegistrationFor3GPPAccessApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void AMFRegistrationFor3GPPAccessApi::init() {
+    setupRoutes();
+}
+
+void AMFRegistrationFor3GPPAccessApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Put(*router, base + "/:ueId/registrations/amf-3gpp-access", Routes::bind(&AMFRegistrationFor3GPPAccessApi::3_gpp_registration_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&AMFRegistrationFor3GPPAccessApi::amf_registration_for3_gpp_access_api_default_handler, this));
+}
+
+void AMFRegistrationFor3GPPAccessApi::3_gpp_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    
+    // Getting the body param
+    
+    Amf3GppAccessRegistration amf3GppAccessRegistration;
+    
+    try {
+      nlohmann::json::parse(request.body()).get_to(amf3GppAccessRegistration);
+      this->3_gpp_registration(ueId, amf3GppAccessRegistration, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void AMFRegistrationFor3GPPAccessApi::amf_registration_for3_gpp_access_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/AMFRegistrationFor3GPPAccessApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * AMFRegistrationFor3GPPAccessApi.h
+ *
+ * 
+ */
+
+#ifndef AMFRegistrationFor3GPPAccessApi_H_
+#define AMFRegistrationFor3GPPAccessApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "Amf3GppAccessRegistration.h"
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  AMFRegistrationFor3GPPAccessApi {
+public:
+    AMFRegistrationFor3GPPAccessApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~AMFRegistrationFor3GPPAccessApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void 3_gpp_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void amf_registration_for3_gpp_access_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// register as AMF for 3GPP access
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="amf3GppAccessRegistration"></param>
+    virtual void 3_gpp_registration(const std::string &ueId, const Amf3GppAccessRegistration &amf3GppAccessRegistration, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* AMFRegistrationFor3GPPAccessApi_H_ */
+

src/api/AMFRegistrationForNon3GPPAccessApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "AMFRegistrationForNon3GPPAccessApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+AMFRegistrationForNon3GPPAccessApi::AMFRegistrationForNon3GPPAccessApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void AMFRegistrationForNon3GPPAccessApi::init() {
+    setupRoutes();
+}
+
+void AMFRegistrationForNon3GPPAccessApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Put(*router, base + "/:ueId/registrations/amf-non-3gpp-access", Routes::bind(&AMFRegistrationForNon3GPPAccessApi::non3_gpp_registration_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&AMFRegistrationForNon3GPPAccessApi::amf_registration_for_non3_gpp_access_api_default_handler, this));
+}
+
+void AMFRegistrationForNon3GPPAccessApi::non3_gpp_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    
+    // Getting the body param
+    
+    AmfNon3GppAccessRegistration amfNon3GppAccessRegistration;
+    
+    try {
+      nlohmann::json::parse(request.body()).get_to(amfNon3GppAccessRegistration);
+      this->non3_gpp_registration(ueId, amfNon3GppAccessRegistration, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void AMFRegistrationForNon3GPPAccessApi::amf_registration_for_non3_gpp_access_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/AMFRegistrationForNon3GPPAccessApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * AMFRegistrationForNon3GPPAccessApi.h
+ *
+ * 
+ */
+
+#ifndef AMFRegistrationForNon3GPPAccessApi_H_
+#define AMFRegistrationForNon3GPPAccessApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "AmfNon3GppAccessRegistration.h"
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  AMFRegistrationForNon3GPPAccessApi {
+public:
+    AMFRegistrationForNon3GPPAccessApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~AMFRegistrationForNon3GPPAccessApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void non3_gpp_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void amf_registration_for_non3_gpp_access_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// register as AMF for non-3GPP access
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="amfNon3GppAccessRegistration"></param>
+    virtual void non3_gpp_registration(const std::string &ueId, const AmfNon3GppAccessRegistration &amfNon3GppAccessRegistration, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* AMFRegistrationForNon3GPPAccessApi_H_ */
+

src/api/IPSMGWDeregistrationApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "IPSMGWDeregistrationApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+IPSMGWDeregistrationApi::IPSMGWDeregistrationApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void IPSMGWDeregistrationApi::init() {
+    setupRoutes();
+}
+
+void IPSMGWDeregistrationApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Delete(*router, base + "/:ueId/registrations/ip-sm-gw", Routes::bind(&IPSMGWDeregistrationApi::ip_sm_gw_deregistration_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&IPSMGWDeregistrationApi::ipsmgw_deregistration_api_default_handler, this));
+}
+
+void IPSMGWDeregistrationApi::ip_sm_gw_deregistration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    
+    try {
+      this->ip_sm_gw_deregistration(ueId, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void IPSMGWDeregistrationApi::ipsmgw_deregistration_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/IPSMGWDeregistrationApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * IPSMGWDeregistrationApi.h
+ *
+ * 
+ */
+
+#ifndef IPSMGWDeregistrationApi_H_
+#define IPSMGWDeregistrationApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  IPSMGWDeregistrationApi {
+public:
+    IPSMGWDeregistrationApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~IPSMGWDeregistrationApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void ip_sm_gw_deregistration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void ipsmgw_deregistration_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// Delete the IP-SM-GW registration
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    virtual void ip_sm_gw_deregistration(const std::string &ueId, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* IPSMGWDeregistrationApi_H_ */
+

src/api/IPSMGWRegistrationApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "IPSMGWRegistrationApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+IPSMGWRegistrationApi::IPSMGWRegistrationApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void IPSMGWRegistrationApi::init() {
+    setupRoutes();
+}
+
+void IPSMGWRegistrationApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Put(*router, base + "/:ueId/registrations/ip-sm-gw", Routes::bind(&IPSMGWRegistrationApi::ip_sm_gw_registration_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&IPSMGWRegistrationApi::ipsmgw_registration_api_default_handler, this));
+}
+
+void IPSMGWRegistrationApi::ip_sm_gw_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    
+    // Getting the body param
+    
+    IpSmGwRegistration ipSmGwRegistration;
+    
+    try {
+      nlohmann::json::parse(request.body()).get_to(ipSmGwRegistration);
+      this->ip_sm_gw_registration(ueId, ipSmGwRegistration, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void IPSMGWRegistrationApi::ipsmgw_registration_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/IPSMGWRegistrationApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * IPSMGWRegistrationApi.h
+ *
+ * 
+ */
+
+#ifndef IPSMGWRegistrationApi_H_
+#define IPSMGWRegistrationApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "IpSmGwRegistration.h"
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  IPSMGWRegistrationApi {
+public:
+    IPSMGWRegistrationApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~IPSMGWRegistrationApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void ip_sm_gw_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void ipsmgw_registration_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// Register an IP-SM-GW
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="ipSmGwRegistration"></param>
+    virtual void ip_sm_gw_registration(const std::string &ueId, const IpSmGwRegistration &ipSmGwRegistration, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* IPSMGWRegistrationApi_H_ */
+

src/api/IPSMGWRegistrationInfoRetrievalApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "IPSMGWRegistrationInfoRetrievalApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+IPSMGWRegistrationInfoRetrievalApi::IPSMGWRegistrationInfoRetrievalApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void IPSMGWRegistrationInfoRetrievalApi::init() {
+    setupRoutes();
+}
+
+void IPSMGWRegistrationInfoRetrievalApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Get(*router, base + "/:ueId/registrations/ip-sm-gw", Routes::bind(&IPSMGWRegistrationInfoRetrievalApi::get_ip_sm_gw_registration_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&IPSMGWRegistrationInfoRetrievalApi::ipsmgw_registration_info_retrieval_api_default_handler, this));
+}
+
+void IPSMGWRegistrationInfoRetrievalApi::get_ip_sm_gw_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    
+    try {
+      this->get_ip_sm_gw_registration(ueId, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void IPSMGWRegistrationInfoRetrievalApi::ipsmgw_registration_info_retrieval_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/IPSMGWRegistrationInfoRetrievalApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * IPSMGWRegistrationInfoRetrievalApi.h
+ *
+ * 
+ */
+
+#ifndef IPSMGWRegistrationInfoRetrievalApi_H_
+#define IPSMGWRegistrationInfoRetrievalApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "IpSmGwRegistration.h"
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  IPSMGWRegistrationInfoRetrievalApi {
+public:
+    IPSMGWRegistrationInfoRetrievalApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~IPSMGWRegistrationInfoRetrievalApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void get_ip_sm_gw_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void ipsmgw_registration_info_retrieval_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// Retrieve the IP-SM-GW registration information
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    virtual void get_ip_sm_gw_registration(const std::string &ueId, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* IPSMGWRegistrationInfoRetrievalApi_H_ */
+

src/api/PEIUpdateApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "PEIUpdateApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+PEIUpdateApi::PEIUpdateApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void PEIUpdateApi::init() {
+    setupRoutes();
+}
+
+void PEIUpdateApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Post(*router, base + "/:ueId/registrations/amf-3gpp-access/pei-update", Routes::bind(&PEIUpdateApi::pei_update_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&PEIUpdateApi::pei_update_api_default_handler, this));
+}
+
+void PEIUpdateApi::pei_update_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    
+    // Getting the body param
+    
+    PeiUpdateInfo peiUpdateInfo;
+    
+    try {
+      nlohmann::json::parse(request.body()).get_to(peiUpdateInfo);
+      this->pei_update(ueId, peiUpdateInfo, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void PEIUpdateApi::pei_update_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/PEIUpdateApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * PEIUpdateApi.h
+ *
+ * 
+ */
+
+#ifndef PEIUpdateApi_H_
+#define PEIUpdateApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "PeiUpdateInfo.h"
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  PEIUpdateApi {
+public:
+    PEIUpdateApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~PEIUpdateApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void pei_update_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void pei_update_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// Updates the PEI in the 3GPP access registration context
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="peiUpdateInfo"></param>
+    virtual void pei_update(const std::string &ueId, const PeiUpdateInfo &peiUpdateInfo, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* PEIUpdateApi_H_ */
+

src/api/ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi::ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi::init() {
+    setupRoutes();
+}
+
+void ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Patch(*router, base + "/:ueId/registrations/amf-3gpp-access", Routes::bind(&ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi::update3_gpp_registration_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi::parameter_update_in_the_amf_registration_for3_gpp_access_api_default_handler, this));
+}
+
+void ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi::update3_gpp_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    
+    // Getting the body param
+    
+    Amf3GppAccessRegistrationModification amf3GppAccessRegistrationModification;
+    
+    // Getting the query params
+    auto supportedFeaturesQuery = request.query().get("supported-features");
+    Pistache::Optional<std::string> supportedFeatures;
+    if(!supportedFeaturesQuery.isEmpty()){
+        std::string valueQuery_instance;
+        if(fromStringValue(supportedFeaturesQuery.get(), valueQuery_instance)){
+            supportedFeatures = Pistache::Some(valueQuery_instance);
+        }
+    }
+    
+    try {
+      nlohmann::json::parse(request.body()).get_to(amf3GppAccessRegistrationModification);
+      this->update3_gpp_registration(ueId, amf3GppAccessRegistrationModification, supportedFeatures, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi::parameter_update_in_the_amf_registration_for3_gpp_access_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi.h
+ *
+ * 
+ */
+
+#ifndef ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi_H_
+#define ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "Amf3GppAccessRegistrationModification.h"
+#include "PatchResult.h"
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi {
+public:
+    ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void update3_gpp_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void parameter_update_in_the_amf_registration_for3_gpp_access_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// Update a parameter in the AMF registration for 3GPP access
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="amf3GppAccessRegistrationModification"></param>
+    /// <param name="supportedFeatures">Features required to be supported by the target NF (optional, default to &quot;&quot;)</param>
+    virtual void update3_gpp_registration(const std::string &ueId, const Amf3GppAccessRegistrationModification &amf3GppAccessRegistrationModification, const Pistache::Optional<std::string> &supportedFeatures, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi_H_ */
+

src/api/ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi::ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi::init() {
+    setupRoutes();
+}
+
+void ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Patch(*router, base + "/:ueId/registrations/amf-non-3gpp-access", Routes::bind(&ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi::update_non3_gpp_registration_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi::parameter_update_in_the_amf_registration_for_non3_gpp_access_api_default_handler, this));
+}
+
+void ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi::update_non3_gpp_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    
+    // Getting the body param
+    
+    AmfNon3GppAccessRegistrationModification amfNon3GppAccessRegistrationModification;
+    
+    // Getting the query params
+    auto supportedFeaturesQuery = request.query().get("supported-features");
+    Pistache::Optional<std::string> supportedFeatures;
+    if(!supportedFeaturesQuery.isEmpty()){
+        std::string valueQuery_instance;
+        if(fromStringValue(supportedFeaturesQuery.get(), valueQuery_instance)){
+            supportedFeatures = Pistache::Some(valueQuery_instance);
+        }
+    }
+    
+    try {
+      nlohmann::json::parse(request.body()).get_to(amfNon3GppAccessRegistrationModification);
+      this->update_non3_gpp_registration(ueId, amfNon3GppAccessRegistrationModification, supportedFeatures, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi::parameter_update_in_the_amf_registration_for_non3_gpp_access_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi.h
+ *
+ * 
+ */
+
+#ifndef ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi_H_
+#define ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "AmfNon3GppAccessRegistrationModification.h"
+#include "PatchResult.h"
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi {
+public:
+    ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void update_non3_gpp_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void parameter_update_in_the_amf_registration_for_non3_gpp_access_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// update a parameter in the AMF registration for non-3GPP access
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="amfNon3GppAccessRegistrationModification"></param>
+    /// <param name="supportedFeatures">Features required to be supported by the target NF (optional, default to &quot;&quot;)</param>
+    virtual void update_non3_gpp_registration(const std::string &ueId, const AmfNon3GppAccessRegistrationModification &amfNon3GppAccessRegistrationModification, const Pistache::Optional<std::string> &supportedFeatures, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi_H_ */
+

src/api/RetrieveSMFRegistrationApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "RetrieveSMFRegistrationApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+RetrieveSMFRegistrationApi::RetrieveSMFRegistrationApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void RetrieveSMFRegistrationApi::init() {
+    setupRoutes();
+}
+
+void RetrieveSMFRegistrationApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Get(*router, base + "/:ueId/registrations/smf-registrations/:pduSessionId", Routes::bind(&RetrieveSMFRegistrationApi::retrieve_smf_registration_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&RetrieveSMFRegistrationApi::retrieve_smf_registration_api_default_handler, this));
+}
+
+void RetrieveSMFRegistrationApi::retrieve_smf_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    auto pduSessionId = request.param(":pduSessionId").as<int32_t>();
+    
+    try {
+      this->retrieve_smf_registration(ueId, pduSessionId, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void RetrieveSMFRegistrationApi::retrieve_smf_registration_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/RetrieveSMFRegistrationApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * RetrieveSMFRegistrationApi.h
+ *
+ * 
+ */
+
+#ifndef RetrieveSMFRegistrationApi_H_
+#define RetrieveSMFRegistrationApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "ProblemDetails.h"
+#include "SmfRegistration.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  RetrieveSMFRegistrationApi {
+public:
+    RetrieveSMFRegistrationApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~RetrieveSMFRegistrationApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void retrieve_smf_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void retrieve_smf_registration_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// get an SMF registration
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="pduSessionId">Identifier of the PDU session</param>
+    virtual void retrieve_smf_registration(const std::string &ueId, const int32_t &pduSessionId, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* RetrieveSMFRegistrationApi_H_ */
+

src/api/SMFDeregistrationApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "SMFDeregistrationApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+SMFDeregistrationApi::SMFDeregistrationApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void SMFDeregistrationApi::init() {
+    setupRoutes();
+}
+
+void SMFDeregistrationApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Delete(*router, base + "/:ueId/registrations/smf-registrations/:pduSessionId", Routes::bind(&SMFDeregistrationApi::smf_deregistration_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&SMFDeregistrationApi::smf_deregistration_api_default_handler, this));
+}
+
+void SMFDeregistrationApi::smf_deregistration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    auto pduSessionId = request.param(":pduSessionId").as<int32_t>();
+    
+    // Getting the query params
+    auto smfSetIdQuery = request.query().get("smf-set-id");
+    Pistache::Optional<std::string> smfSetId;
+    if(!smfSetIdQuery.isEmpty()){
+        std::string valueQuery_instance;
+        if(fromStringValue(smfSetIdQuery.get(), valueQuery_instance)){
+            smfSetId = Pistache::Some(valueQuery_instance);
+        }
+    }
+    
+    try {
+      this->smf_deregistration(ueId, pduSessionId, smfSetId, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void SMFDeregistrationApi::smf_deregistration_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/SMFDeregistrationApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * SMFDeregistrationApi.h
+ *
+ * 
+ */
+
+#ifndef SMFDeregistrationApi_H_
+#define SMFDeregistrationApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  SMFDeregistrationApi {
+public:
+    SMFDeregistrationApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~SMFDeregistrationApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void smf_deregistration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void smf_deregistration_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// delete an SMF registration
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="pduSessionId">Identifier of the PDU session</param>
+    /// <param name="smfSetId"> (optional, default to &quot;&quot;)</param>
+    virtual void smf_deregistration(const std::string &ueId, const int32_t &pduSessionId, const Pistache::Optional<std::string> &smfSetId, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* SMFDeregistrationApi_H_ */
+

src/api/SMFSmfRegistrationApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "SMFSmfRegistrationApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+SMFSmfRegistrationApi::SMFSmfRegistrationApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void SMFSmfRegistrationApi::init() {
+    setupRoutes();
+}
+
+void SMFSmfRegistrationApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Get(*router, base + "/:ueId/registrations/smf-registrations", Routes::bind(&SMFSmfRegistrationApi::get_smf_registration_handler, this));
+    Routes::Put(*router, base + "/:ueId/registrations/smf-registrations/:pduSessionId", Routes::bind(&SMFSmfRegistrationApi::registration_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&SMFSmfRegistrationApi::smf_smf_registration_api_default_handler, this));
+}
+
+void SMFSmfRegistrationApi::get_smf_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    
+    // Getting the query params
+    auto singleNssaiQuery = request.query().get("single-nssai");
+    Pistache::Optional<Snssai> singleNssai;
+    if(!singleNssaiQuery.isEmpty()){
+        Snssai valueQuery_instance;
+        if(fromStringValue(singleNssaiQuery.get(), valueQuery_instance)){
+            singleNssai = Pistache::Some(valueQuery_instance);
+        }
+    }
+    auto dnnQuery = request.query().get("dnn");
+    Pistache::Optional<std::string> dnn;
+    if(!dnnQuery.isEmpty()){
+        std::string valueQuery_instance;
+        if(fromStringValue(dnnQuery.get(), valueQuery_instance)){
+            dnn = Pistache::Some(valueQuery_instance);
+        }
+    }
+    auto supportedFeaturesQuery = request.query().get("supported-features");
+    Pistache::Optional<std::string> supportedFeatures;
+    if(!supportedFeaturesQuery.isEmpty()){
+        std::string valueQuery_instance;
+        if(fromStringValue(supportedFeaturesQuery.get(), valueQuery_instance)){
+            supportedFeatures = Pistache::Some(valueQuery_instance);
+        }
+    }
+    
+    try {
+      this->get_smf_registration(ueId, singleNssai, dnn, supportedFeatures, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+void SMFSmfRegistrationApi::registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    auto pduSessionId = request.param(":pduSessionId").as<int32_t>();
+    
+    // Getting the body param
+    
+    SmfRegistration smfRegistration;
+    
+    try {
+      nlohmann::json::parse(request.body()).get_to(smfRegistration);
+      this->registration(ueId, pduSessionId, smfRegistration, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void SMFSmfRegistrationApi::smf_smf_registration_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/SMFSmfRegistrationApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * SMFSmfRegistrationApi.h
+ *
+ * 
+ */
+
+#ifndef SMFSmfRegistrationApi_H_
+#define SMFSmfRegistrationApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "ProblemDetails.h"
+#include "SmfRegistration.h"
+#include "SmfRegistrationInfo.h"
+#include "Snssai.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  SMFSmfRegistrationApi {
+public:
+    SMFSmfRegistrationApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~SMFSmfRegistrationApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void get_smf_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void smf_smf_registration_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// retrieve the SMF registration information
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="singleNssai"> (optional, default to Snssai())</param>
+    /// <param name="dnn"> (optional, default to &quot;&quot;)</param>
+    /// <param name="supportedFeatures"> (optional, default to &quot;&quot;)</param>
+    virtual void get_smf_registration(const std::string &ueId, const Pistache::Optional<Snssai> &singleNssai, const Pistache::Optional<std::string> &dnn, const Pistache::Optional<std::string> &supportedFeatures, Pistache::Http::ResponseWriter &response) = 0;
+
+    /// <summary>
+    /// register as SMF
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="pduSessionId">Identifier of the PDU session</param>
+    /// <param name="smfRegistration"></param>
+    virtual void registration(const std::string &ueId, const int32_t &pduSessionId, const SmfRegistration &smfRegistration, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* SMFSmfRegistrationApi_H_ */
+

src/api/SMSF3GPPAccessRegistrationInfoRetrievalApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "SMSF3GPPAccessRegistrationInfoRetrievalApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+SMSF3GPPAccessRegistrationInfoRetrievalApi::SMSF3GPPAccessRegistrationInfoRetrievalApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void SMSF3GPPAccessRegistrationInfoRetrievalApi::init() {
+    setupRoutes();
+}
+
+void SMSF3GPPAccessRegistrationInfoRetrievalApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Get(*router, base + "/:ueId/registrations/smsf-3gpp-access", Routes::bind(&SMSF3GPPAccessRegistrationInfoRetrievalApi::get3_gpp_smsf_registration_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&SMSF3GPPAccessRegistrationInfoRetrievalApi::smsf3_gpp_access_registration_info_retrieval_api_default_handler, this));
+}
+
+void SMSF3GPPAccessRegistrationInfoRetrievalApi::get3_gpp_smsf_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    
+    // Getting the query params
+    auto supportedFeaturesQuery = request.query().get("supported-features");
+    Pistache::Optional<std::string> supportedFeatures;
+    if(!supportedFeaturesQuery.isEmpty()){
+        std::string valueQuery_instance;
+        if(fromStringValue(supportedFeaturesQuery.get(), valueQuery_instance)){
+            supportedFeatures = Pistache::Some(valueQuery_instance);
+        }
+    }
+    
+    try {
+      this->get3_gpp_smsf_registration(ueId, supportedFeatures, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void SMSF3GPPAccessRegistrationInfoRetrievalApi::smsf3_gpp_access_registration_info_retrieval_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/SMSF3GPPAccessRegistrationInfoRetrievalApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * SMSF3GPPAccessRegistrationInfoRetrievalApi.h
+ *
+ * 
+ */
+
+#ifndef SMSF3GPPAccessRegistrationInfoRetrievalApi_H_
+#define SMSF3GPPAccessRegistrationInfoRetrievalApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "ProblemDetails.h"
+#include "SmsfRegistration.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  SMSF3GPPAccessRegistrationInfoRetrievalApi {
+public:
+    SMSF3GPPAccessRegistrationInfoRetrievalApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~SMSF3GPPAccessRegistrationInfoRetrievalApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void get3_gpp_smsf_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void smsf3_gpp_access_registration_info_retrieval_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// retrieve the SMSF registration for 3GPP access information
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="supportedFeatures"> (optional, default to &quot;&quot;)</param>
+    virtual void get3_gpp_smsf_registration(const std::string &ueId, const Pistache::Optional<std::string> &supportedFeatures, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* SMSF3GPPAccessRegistrationInfoRetrievalApi_H_ */
+

src/api/SMSFDeregistrationFor3GPPAccessApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "SMSFDeregistrationFor3GPPAccessApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+SMSFDeregistrationFor3GPPAccessApi::SMSFDeregistrationFor3GPPAccessApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void SMSFDeregistrationFor3GPPAccessApi::init() {
+    setupRoutes();
+}
+
+void SMSFDeregistrationFor3GPPAccessApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Delete(*router, base + "/:ueId/registrations/smsf-3gpp-access", Routes::bind(&SMSFDeregistrationFor3GPPAccessApi::3_gpp_smsf_deregistration_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&SMSFDeregistrationFor3GPPAccessApi::smsf_deregistration_for3_gpp_access_api_default_handler, this));
+}
+
+void SMSFDeregistrationFor3GPPAccessApi::3_gpp_smsf_deregistration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    
+    // Getting the query params
+    auto smsfSetIdQuery = request.query().get("smsf-set-id");
+    Pistache::Optional<std::string> smsfSetId;
+    if(!smsfSetIdQuery.isEmpty()){
+        std::string valueQuery_instance;
+        if(fromStringValue(smsfSetIdQuery.get(), valueQuery_instance)){
+            smsfSetId = Pistache::Some(valueQuery_instance);
+        }
+    }
+    
+    try {
+      this->3_gpp_smsf_deregistration(ueId, smsfSetId, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void SMSFDeregistrationFor3GPPAccessApi::smsf_deregistration_for3_gpp_access_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/SMSFDeregistrationFor3GPPAccessApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * SMSFDeregistrationFor3GPPAccessApi.h
+ *
+ * 
+ */
+
+#ifndef SMSFDeregistrationFor3GPPAccessApi_H_
+#define SMSFDeregistrationFor3GPPAccessApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  SMSFDeregistrationFor3GPPAccessApi {
+public:
+    SMSFDeregistrationFor3GPPAccessApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~SMSFDeregistrationFor3GPPAccessApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void 3_gpp_smsf_deregistration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void smsf_deregistration_for3_gpp_access_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// delete the SMSF registration for 3GPP access
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="smsfSetId"> (optional, default to &quot;&quot;)</param>
+    virtual void 3_gpp_smsf_deregistration(const std::string &ueId, const Pistache::Optional<std::string> &smsfSetId, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* SMSFDeregistrationFor3GPPAccessApi_H_ */
+

src/api/SMSFDeregistrationForNon3GPPAccessApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "SMSFDeregistrationForNon3GPPAccessApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+SMSFDeregistrationForNon3GPPAccessApi::SMSFDeregistrationForNon3GPPAccessApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void SMSFDeregistrationForNon3GPPAccessApi::init() {
+    setupRoutes();
+}
+
+void SMSFDeregistrationForNon3GPPAccessApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Delete(*router, base + "/:ueId/registrations/smsf-non-3gpp-access", Routes::bind(&SMSFDeregistrationForNon3GPPAccessApi::non3_gpp_smsf_deregistration_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&SMSFDeregistrationForNon3GPPAccessApi::smsf_deregistration_for_non3_gpp_access_api_default_handler, this));
+}
+
+void SMSFDeregistrationForNon3GPPAccessApi::non3_gpp_smsf_deregistration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    
+    // Getting the query params
+    auto smsfSetIdQuery = request.query().get("smsf-set-id");
+    Pistache::Optional<std::string> smsfSetId;
+    if(!smsfSetIdQuery.isEmpty()){
+        std::string valueQuery_instance;
+        if(fromStringValue(smsfSetIdQuery.get(), valueQuery_instance)){
+            smsfSetId = Pistache::Some(valueQuery_instance);
+        }
+    }
+    
+    try {
+      this->non3_gpp_smsf_deregistration(ueId, smsfSetId, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void SMSFDeregistrationForNon3GPPAccessApi::smsf_deregistration_for_non3_gpp_access_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/SMSFDeregistrationForNon3GPPAccessApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * SMSFDeregistrationForNon3GPPAccessApi.h
+ *
+ * 
+ */
+
+#ifndef SMSFDeregistrationForNon3GPPAccessApi_H_
+#define SMSFDeregistrationForNon3GPPAccessApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  SMSFDeregistrationForNon3GPPAccessApi {
+public:
+    SMSFDeregistrationForNon3GPPAccessApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~SMSFDeregistrationForNon3GPPAccessApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void non3_gpp_smsf_deregistration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void smsf_deregistration_for_non3_gpp_access_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// delete SMSF registration for non 3GPP access
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="smsfSetId"> (optional, default to &quot;&quot;)</param>
+    virtual void non3_gpp_smsf_deregistration(const std::string &ueId, const Pistache::Optional<std::string> &smsfSetId, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* SMSFDeregistrationForNon3GPPAccessApi_H_ */
+

src/api/SMSFNon3GPPAccessRegistrationInfoRetrievalApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "SMSFNon3GPPAccessRegistrationInfoRetrievalApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+SMSFNon3GPPAccessRegistrationInfoRetrievalApi::SMSFNon3GPPAccessRegistrationInfoRetrievalApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void SMSFNon3GPPAccessRegistrationInfoRetrievalApi::init() {
+    setupRoutes();
+}
+
+void SMSFNon3GPPAccessRegistrationInfoRetrievalApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Get(*router, base + "/:ueId/registrations/smsf-non-3gpp-access", Routes::bind(&SMSFNon3GPPAccessRegistrationInfoRetrievalApi::get_non3_gpp_smsf_registration_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&SMSFNon3GPPAccessRegistrationInfoRetrievalApi::smsf_non3_gpp_access_registration_info_retrieval_api_default_handler, this));
+}
+
+void SMSFNon3GPPAccessRegistrationInfoRetrievalApi::get_non3_gpp_smsf_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    
+    // Getting the query params
+    auto supportedFeaturesQuery = request.query().get("supported-features");
+    Pistache::Optional<std::string> supportedFeatures;
+    if(!supportedFeaturesQuery.isEmpty()){
+        std::string valueQuery_instance;
+        if(fromStringValue(supportedFeaturesQuery.get(), valueQuery_instance)){
+            supportedFeatures = Pistache::Some(valueQuery_instance);
+        }
+    }
+    
+    try {
+      this->get_non3_gpp_smsf_registration(ueId, supportedFeatures, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void SMSFNon3GPPAccessRegistrationInfoRetrievalApi::smsf_non3_gpp_access_registration_info_retrieval_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/SMSFNon3GPPAccessRegistrationInfoRetrievalApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * SMSFNon3GPPAccessRegistrationInfoRetrievalApi.h
+ *
+ * 
+ */
+
+#ifndef SMSFNon3GPPAccessRegistrationInfoRetrievalApi_H_
+#define SMSFNon3GPPAccessRegistrationInfoRetrievalApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "ProblemDetails.h"
+#include "SmsfRegistration.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  SMSFNon3GPPAccessRegistrationInfoRetrievalApi {
+public:
+    SMSFNon3GPPAccessRegistrationInfoRetrievalApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~SMSFNon3GPPAccessRegistrationInfoRetrievalApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void get_non3_gpp_smsf_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void smsf_non3_gpp_access_registration_info_retrieval_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// retrieve the SMSF registration for non-3GPP access information
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="supportedFeatures"> (optional, default to &quot;&quot;)</param>
+    virtual void get_non3_gpp_smsf_registration(const std::string &ueId, const Pistache::Optional<std::string> &supportedFeatures, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* SMSFNon3GPPAccessRegistrationInfoRetrievalApi_H_ */
+

src/api/SMSFRegistrationFor3GPPAccessApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "SMSFRegistrationFor3GPPAccessApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+SMSFRegistrationFor3GPPAccessApi::SMSFRegistrationFor3GPPAccessApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void SMSFRegistrationFor3GPPAccessApi::init() {
+    setupRoutes();
+}
+
+void SMSFRegistrationFor3GPPAccessApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Put(*router, base + "/:ueId/registrations/smsf-3gpp-access", Routes::bind(&SMSFRegistrationFor3GPPAccessApi::3_gpp_smsf_registration_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&SMSFRegistrationFor3GPPAccessApi::smsf_registration_for3_gpp_access_api_default_handler, this));
+}
+
+void SMSFRegistrationFor3GPPAccessApi::3_gpp_smsf_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    
+    // Getting the body param
+    
+    SmsfRegistration smsfRegistration;
+    
+    try {
+      nlohmann::json::parse(request.body()).get_to(smsfRegistration);
+      this->3_gpp_smsf_registration(ueId, smsfRegistration, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void SMSFRegistrationFor3GPPAccessApi::smsf_registration_for3_gpp_access_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/SMSFRegistrationFor3GPPAccessApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * SMSFRegistrationFor3GPPAccessApi.h
+ *
+ * 
+ */
+
+#ifndef SMSFRegistrationFor3GPPAccessApi_H_
+#define SMSFRegistrationFor3GPPAccessApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "ProblemDetails.h"
+#include "SmsfRegistration.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  SMSFRegistrationFor3GPPAccessApi {
+public:
+    SMSFRegistrationFor3GPPAccessApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~SMSFRegistrationFor3GPPAccessApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void 3_gpp_smsf_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void smsf_registration_for3_gpp_access_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// register as SMSF for 3GPP access
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="smsfRegistration"></param>
+    virtual void 3_gpp_smsf_registration(const std::string &ueId, const SmsfRegistration &smsfRegistration, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* SMSFRegistrationFor3GPPAccessApi_H_ */
+

src/api/SMSFRegistrationForNon3GPPAccessApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "SMSFRegistrationForNon3GPPAccessApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+SMSFRegistrationForNon3GPPAccessApi::SMSFRegistrationForNon3GPPAccessApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void SMSFRegistrationForNon3GPPAccessApi::init() {
+    setupRoutes();
+}
+
+void SMSFRegistrationForNon3GPPAccessApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Put(*router, base + "/:ueId/registrations/smsf-non-3gpp-access", Routes::bind(&SMSFRegistrationForNon3GPPAccessApi::non3_gpp_smsf_registration_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&SMSFRegistrationForNon3GPPAccessApi::smsf_registration_for_non3_gpp_access_api_default_handler, this));
+}
+
+void SMSFRegistrationForNon3GPPAccessApi::non3_gpp_smsf_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    
+    // Getting the body param
+    
+    SmsfRegistration smsfRegistration;
+    
+    try {
+      nlohmann::json::parse(request.body()).get_to(smsfRegistration);
+      this->non3_gpp_smsf_registration(ueId, smsfRegistration, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void SMSFRegistrationForNon3GPPAccessApi::smsf_registration_for_non3_gpp_access_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/SMSFRegistrationForNon3GPPAccessApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * SMSFRegistrationForNon3GPPAccessApi.h
+ *
+ * 
+ */
+
+#ifndef SMSFRegistrationForNon3GPPAccessApi_H_
+#define SMSFRegistrationForNon3GPPAccessApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "ProblemDetails.h"
+#include "SmsfRegistration.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  SMSFRegistrationForNon3GPPAccessApi {
+public:
+    SMSFRegistrationForNon3GPPAccessApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~SMSFRegistrationForNon3GPPAccessApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void non3_gpp_smsf_registration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void smsf_registration_for_non3_gpp_access_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// register as SMSF for non-3GPP access
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="smsfRegistration"></param>
+    virtual void non3_gpp_smsf_registration(const std::string &ueId, const SmsfRegistration &smsfRegistration, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* SMSFRegistrationForNon3GPPAccessApi_H_ */
+

src/api/TriggerAMFFor3GPPAccessDeregistrationApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "TriggerAMFFor3GPPAccessDeregistrationApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+TriggerAMFFor3GPPAccessDeregistrationApi::TriggerAMFFor3GPPAccessDeregistrationApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void TriggerAMFFor3GPPAccessDeregistrationApi::init() {
+    setupRoutes();
+}
+
+void TriggerAMFFor3GPPAccessDeregistrationApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Post(*router, base + "/:ueId/registrations/amf-3gpp-access/dereg-amf", Routes::bind(&TriggerAMFFor3GPPAccessDeregistrationApi::dereg_amf_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&TriggerAMFFor3GPPAccessDeregistrationApi::trigger_amf_for3_gpp_access_deregistration_api_default_handler, this));
+}
+
+void TriggerAMFFor3GPPAccessDeregistrationApi::dereg_amf_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    
+    // Getting the body param
+    
+    AmfDeregInfo amfDeregInfo;
+    
+    try {
+      nlohmann::json::parse(request.body()).get_to(amfDeregInfo);
+      this->dereg_amf(ueId, amfDeregInfo, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void TriggerAMFFor3GPPAccessDeregistrationApi::trigger_amf_for3_gpp_access_deregistration_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/TriggerAMFFor3GPPAccessDeregistrationApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * TriggerAMFFor3GPPAccessDeregistrationApi.h
+ *
+ * 
+ */
+
+#ifndef TriggerAMFFor3GPPAccessDeregistrationApi_H_
+#define TriggerAMFFor3GPPAccessDeregistrationApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "AmfDeregInfo.h"
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  TriggerAMFFor3GPPAccessDeregistrationApi {
+public:
+    TriggerAMFFor3GPPAccessDeregistrationApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~TriggerAMFFor3GPPAccessDeregistrationApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void dereg_amf_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void trigger_amf_for3_gpp_access_deregistration_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// trigger AMF for 3GPP access deregistration
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="amfDeregInfo"></param>
+    virtual void dereg_amf(const std::string &ueId, const AmfDeregInfo &amfDeregInfo, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* TriggerAMFFor3GPPAccessDeregistrationApi_H_ */
+

src/api/TriggerPCSCFRestorationApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "TriggerPCSCFRestorationApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+TriggerPCSCFRestorationApi::TriggerPCSCFRestorationApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void TriggerPCSCFRestorationApi::init() {
+    setupRoutes();
+}
+
+void TriggerPCSCFRestorationApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Post(*router, base + "/restore-pcscf", Routes::bind(&TriggerPCSCFRestorationApi::trigger_pcscf_restoration_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&TriggerPCSCFRestorationApi::trigger_pcscf_restoration_api_default_handler, this));
+}
+
+void TriggerPCSCFRestorationApi::trigger_pcscf_restoration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+
+    // Getting the body param
+    
+    TriggerRequest triggerRequest;
+    
+    try {
+      nlohmann::json::parse(request.body()).get_to(triggerRequest);
+      this->trigger_pcscf_restoration(triggerRequest, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void TriggerPCSCFRestorationApi::trigger_pcscf_restoration_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/TriggerPCSCFRestorationApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * TriggerPCSCFRestorationApi.h
+ *
+ * 
+ */
+
+#ifndef TriggerPCSCFRestorationApi_H_
+#define TriggerPCSCFRestorationApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "ProblemDetails.h"
+#include "TriggerRequest.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  TriggerPCSCFRestorationApi {
+public:
+    TriggerPCSCFRestorationApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~TriggerPCSCFRestorationApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void trigger_pcscf_restoration_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void trigger_pcscf_restoration_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// Trigger the Restoration of the P-CSCF
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="triggerRequest"></param>
+    virtual void trigger_pcscf_restoration(const TriggerRequest &triggerRequest, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* TriggerPCSCFRestorationApi_H_ */
+

src/api/UECMRegistrationInfoRetrievalApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "UECMRegistrationInfoRetrievalApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+UECMRegistrationInfoRetrievalApi::UECMRegistrationInfoRetrievalApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void UECMRegistrationInfoRetrievalApi::init() {
+    setupRoutes();
+}
+
+void UECMRegistrationInfoRetrievalApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Get(*router, base + "/:ueId/registrations", Routes::bind(&UECMRegistrationInfoRetrievalApi::get_registrations_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&UECMRegistrationInfoRetrievalApi::uecm_registration_info_retrieval_api_default_handler, this));
+}
+
+void UECMRegistrationInfoRetrievalApi::get_registrations_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    
+    // Getting the query params
+    auto supportedFeaturesQuery = request.query().get("supported-features");
+    Pistache::Optional<std::string> supportedFeatures;
+    if(!supportedFeaturesQuery.isEmpty()){
+        std::string valueQuery_instance;
+        if(fromStringValue(supportedFeaturesQuery.get(), valueQuery_instance)){
+            supportedFeatures = Pistache::Some(valueQuery_instance);
+        }
+    }
+    auto registrationDatasetNamesQuery = request.query().get("registration-dataset-names");
+    Pistache::Optional<std::vector<RegistrationDataSetName>> registrationDatasetNames;
+    if(!registrationDatasetNamesQuery.isEmpty()){
+        std::vector<RegistrationDataSetName> valueQuery_instance;
+        if(fromStringValue(registrationDatasetNamesQuery.get(), valueQuery_instance)){
+            registrationDatasetNames = Pistache::Some(valueQuery_instance);
+        }
+    }
+    auto singleNssaiQuery = request.query().get("single-nssai");
+    Pistache::Optional<Snssai> singleNssai;
+    if(!singleNssaiQuery.isEmpty()){
+        Snssai valueQuery_instance;
+        if(fromStringValue(singleNssaiQuery.get(), valueQuery_instance)){
+            singleNssai = Pistache::Some(valueQuery_instance);
+        }
+    }
+    auto dnnQuery = request.query().get("dnn");
+    Pistache::Optional<std::string> dnn;
+    if(!dnnQuery.isEmpty()){
+        std::string valueQuery_instance;
+        if(fromStringValue(dnnQuery.get(), valueQuery_instance)){
+            dnn = Pistache::Some(valueQuery_instance);
+        }
+    }
+    
+    try {
+      this->get_registrations(ueId, registrationDatasetNames, supportedFeatures, singleNssai, dnn, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void UECMRegistrationInfoRetrievalApi::uecm_registration_info_retrieval_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/UECMRegistrationInfoRetrievalApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * UECMRegistrationInfoRetrievalApi.h
+ *
+ * 
+ */
+
+#ifndef UECMRegistrationInfoRetrievalApi_H_
+#define UECMRegistrationInfoRetrievalApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "ProblemDetails.h"
+#include "RegistrationDataSetName.h"
+#include "RegistrationDataSets.h"
+#include "Set.h"
+#include "Snssai.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  UECMRegistrationInfoRetrievalApi {
+public:
+    UECMRegistrationInfoRetrievalApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~UECMRegistrationInfoRetrievalApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void get_registrations_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void uecm_registration_info_retrieval_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// retrieve UE registration data sets
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="registrationDatasetNames">List of UECM registration dataset names</param>
+    /// <param name="supportedFeatures"> (optional, default to &quot;&quot;)</param>
+    /// <param name="singleNssai"> (optional, default to Snssai())</param>
+    /// <param name="dnn"> (optional, default to &quot;&quot;)</param>
+    virtual void get_registrations(const std::string &ueId, const Pistache::Optional<Set<RegistrationDataSetName>> &registrationDatasetNames, const Pistache::Optional<std::string> &supportedFeatures, const Pistache::Optional<Snssai> &singleNssai, const Pistache::Optional<std::string> &dnn, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* UECMRegistrationInfoRetrievalApi_H_ */
+

src/api/UELocationInformationRetrievalApi.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "UELocationInformationRetrievalApi.h"
+#include "Helpers.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::helpers;
+using namespace org::openapitools::server::model;
+
+UELocationInformationRetrievalApi::UELocationInformationRetrievalApi(std::shared_ptr<Pistache::Rest::Router> rtr) { 
+    router = rtr;
+}
+
+void UELocationInformationRetrievalApi::init() {
+    setupRoutes();
+}
+
+void UELocationInformationRetrievalApi::setupRoutes() {
+    using namespace Pistache::Rest;
+
+    Routes::Get(*router, base + "/:ueId/registrations/location", Routes::bind(&UELocationInformationRetrievalApi::get_location_info_handler, this));
+
+    // Default handler, called when a route is not found
+    router->addCustomHandler(Routes::bind(&UELocationInformationRetrievalApi::ue_location_information_retrieval_api_default_handler, this));
+}
+
+void UELocationInformationRetrievalApi::get_location_info_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) {
+    // Getting the path params
+    auto ueId = request.param(":ueId").as<std::string>();
+    
+    // Getting the query params
+    auto supportedFeaturesQuery = request.query().get("supported-features");
+    Pistache::Optional<std::string> supportedFeatures;
+    if(!supportedFeaturesQuery.isEmpty()){
+        std::string valueQuery_instance;
+        if(fromStringValue(supportedFeaturesQuery.get(), valueQuery_instance)){
+            supportedFeatures = Pistache::Some(valueQuery_instance);
+        }
+    }
+    
+    try {
+      this->get_location_info(ueId, supportedFeatures, response);
+    } catch (nlohmann::detail::exception &e) {
+        //send a 400 error
+        response.send(Pistache::Http::Code::Bad_Request, e.what());
+        return;
+    } catch (Pistache::Http::HttpError &e) {
+        response.send(static_cast<Pistache::Http::Code>(e.code()), e.what());
+        return;
+    } catch (std::exception &e) {
+        //send a 500 error
+        response.send(Pistache::Http::Code::Internal_Server_Error, e.what());
+        return;
+    }
+
+}
+
+void UELocationInformationRetrievalApi::ue_location_information_retrieval_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) {
+    response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist");
+}
+
+}
+}
+}
+}
+

src/api/UELocationInformationRetrievalApi.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+/*
+ * UELocationInformationRetrievalApi.h
+ *
+ * 
+ */
+
+#ifndef UELocationInformationRetrievalApi_H_
+#define UELocationInformationRetrievalApi_H_
+
+
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <pistache/http_headers.h>
+#include <pistache/optional.h>
+
+
+#include "LocationInfo.h"
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class  UELocationInformationRetrievalApi {
+public:
+    UELocationInformationRetrievalApi(std::shared_ptr<Pistache::Rest::Router>);
+    virtual ~UELocationInformationRetrievalApi() {}
+    void init();
+
+    const std::string base = "/nudm-uecm/v1";
+
+private:
+    void setupRoutes();
+
+    void get_location_info_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+    void ue_location_information_retrieval_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response);
+
+    std::shared_ptr<Pistache::Rest::Router> router;
+
+    /// <summary>
+    /// retrieve the target UE&#39;s location information
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// </remarks>
+    /// <param name="ueId">Identifier of the UE</param>
+    /// <param name="supportedFeatures"> (optional, default to &quot;&quot;)</param>
+    virtual void get_location_info(const std::string &ueId, const Pistache::Optional<std::string> &supportedFeatures, Pistache::Http::ResponseWriter &response) = 0;
+
+};
+
+}
+}
+}
+}
+
+#endif /* UELocationInformationRetrievalApi_H_ */
+

src/impl/AMF3GppAccessRegistrationInfoRetrievalApiImpl.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "AMF3GppAccessRegistrationInfoRetrievalApiImpl.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+AMF3GppAccessRegistrationInfoRetrievalApiImpl::AMF3GppAccessRegistrationInfoRetrievalApiImpl(std::shared_ptr<Pistache::Rest::Router> rtr)
+    : AMF3GppAccessRegistrationInfoRetrievalApi(rtr)
+    { }
+
+void AMF3GppAccessRegistrationInfoRetrievalApiImpl::get3_gpp_registration(const std::string &ueId, const Pistache::Optional<std::string> &supportedFeatures, Pistache::Http::ResponseWriter &response) {
+    response.send(Pistache::Http::Code::Ok, "Do some magic\n");
+}
+
+}
+}
+}
+}
+

src/impl/AMF3GppAccessRegistrationInfoRetrievalApiImpl.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+/*
+* AMF3GppAccessRegistrationInfoRetrievalApiImpl.h
+*
+* 
+*/
+
+#ifndef AMF3_GPP_ACCESS_REGISTRATION_INFO_RETRIEVAL_API_IMPL_H_
+#define AMF3_GPP_ACCESS_REGISTRATION_INFO_RETRIEVAL_API_IMPL_H_
+
+
+#include <pistache/endpoint.h>
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <memory>
+
+#include <AMF3GppAccessRegistrationInfoRetrievalApi.h>
+
+#include <pistache/optional.h>
+
+#include "Amf3GppAccessRegistration.h"
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class AMF3GppAccessRegistrationInfoRetrievalApiImpl : public org::openapitools::server::api::AMF3GppAccessRegistrationInfoRetrievalApi {
+public:
+    AMF3GppAccessRegistrationInfoRetrievalApiImpl(std::shared_ptr<Pistache::Rest::Router>);
+    ~AMF3GppAccessRegistrationInfoRetrievalApiImpl() {}
+
+    void get3_gpp_registration(const std::string &ueId, const Pistache::Optional<std::string> &supportedFeatures, Pistache::Http::ResponseWriter &response);
+
+};
+
+}
+}
+}
+}
+
+
+
+#endif
\ No newline at end of file

src/impl/AMFNon3GPPAccessRegistrationInfoRetrievalApiImpl.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "AMFNon3GPPAccessRegistrationInfoRetrievalApiImpl.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+AMFNon3GPPAccessRegistrationInfoRetrievalApiImpl::AMFNon3GPPAccessRegistrationInfoRetrievalApiImpl(std::shared_ptr<Pistache::Rest::Router> rtr)
+    : AMFNon3GPPAccessRegistrationInfoRetrievalApi(rtr)
+    { }
+
+void AMFNon3GPPAccessRegistrationInfoRetrievalApiImpl::get_non3_gpp_registration(const std::string &ueId, const Pistache::Optional<std::string> &supportedFeatures, Pistache::Http::ResponseWriter &response) {
+    response.send(Pistache::Http::Code::Ok, "Do some magic\n");
+}
+
+}
+}
+}
+}
+

src/impl/AMFNon3GPPAccessRegistrationInfoRetrievalApiImpl.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+/*
+* AMFNon3GPPAccessRegistrationInfoRetrievalApiImpl.h
+*
+* 
+*/
+
+#ifndef AMF_NON3_GPP_ACCESS_REGISTRATION_INFO_RETRIEVAL_API_IMPL_H_
+#define AMF_NON3_GPP_ACCESS_REGISTRATION_INFO_RETRIEVAL_API_IMPL_H_
+
+
+#include <pistache/endpoint.h>
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <memory>
+
+#include <AMFNon3GPPAccessRegistrationInfoRetrievalApi.h>
+
+#include <pistache/optional.h>
+
+#include "AmfNon3GppAccessRegistration.h"
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class AMFNon3GPPAccessRegistrationInfoRetrievalApiImpl : public org::openapitools::server::api::AMFNon3GPPAccessRegistrationInfoRetrievalApi {
+public:
+    AMFNon3GPPAccessRegistrationInfoRetrievalApiImpl(std::shared_ptr<Pistache::Rest::Router>);
+    ~AMFNon3GPPAccessRegistrationInfoRetrievalApiImpl() {}
+
+    void get_non3_gpp_registration(const std::string &ueId, const Pistache::Optional<std::string> &supportedFeatures, Pistache::Http::ResponseWriter &response);
+
+};
+
+}
+}
+}
+}
+
+
+
+#endif
\ No newline at end of file

src/impl/AMFRegistrationFor3GPPAccessApiImpl.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "AMFRegistrationFor3GPPAccessApiImpl.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+AMFRegistrationFor3GPPAccessApiImpl::AMFRegistrationFor3GPPAccessApiImpl(std::shared_ptr<Pistache::Rest::Router> rtr)
+    : AMFRegistrationFor3GPPAccessApi(rtr)
+    { }
+
+void AMFRegistrationFor3GPPAccessApiImpl::3_gpp_registration(const std::string &ueId, const Amf3GppAccessRegistration &amf3GppAccessRegistration, Pistache::Http::ResponseWriter &response) {
+    response.send(Pistache::Http::Code::Ok, "Do some magic\n");
+}
+
+}
+}
+}
+}
+

src/impl/AMFRegistrationFor3GPPAccessApiImpl.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+/*
+* AMFRegistrationFor3GPPAccessApiImpl.h
+*
+* 
+*/
+
+#ifndef AMF_REGISTRATION_FOR3_GPP_ACCESS_API_IMPL_H_
+#define AMF_REGISTRATION_FOR3_GPP_ACCESS_API_IMPL_H_
+
+
+#include <pistache/endpoint.h>
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <memory>
+
+#include <AMFRegistrationFor3GPPAccessApi.h>
+
+#include <pistache/optional.h>
+
+#include "Amf3GppAccessRegistration.h"
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class AMFRegistrationFor3GPPAccessApiImpl : public org::openapitools::server::api::AMFRegistrationFor3GPPAccessApi {
+public:
+    AMFRegistrationFor3GPPAccessApiImpl(std::shared_ptr<Pistache::Rest::Router>);
+    ~AMFRegistrationFor3GPPAccessApiImpl() {}
+
+    void 3_gpp_registration(const std::string &ueId, const Amf3GppAccessRegistration &amf3GppAccessRegistration, Pistache::Http::ResponseWriter &response);
+
+};
+
+}
+}
+}
+}
+
+
+
+#endif
\ No newline at end of file

src/impl/AMFRegistrationForNon3GPPAccessApiImpl.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "AMFRegistrationForNon3GPPAccessApiImpl.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+AMFRegistrationForNon3GPPAccessApiImpl::AMFRegistrationForNon3GPPAccessApiImpl(std::shared_ptr<Pistache::Rest::Router> rtr)
+    : AMFRegistrationForNon3GPPAccessApi(rtr)
+    { }
+
+void AMFRegistrationForNon3GPPAccessApiImpl::non3_gpp_registration(const std::string &ueId, const AmfNon3GppAccessRegistration &amfNon3GppAccessRegistration, Pistache::Http::ResponseWriter &response) {
+    response.send(Pistache::Http::Code::Ok, "Do some magic\n");
+}
+
+}
+}
+}
+}
+

src/impl/AMFRegistrationForNon3GPPAccessApiImpl.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+/*
+* AMFRegistrationForNon3GPPAccessApiImpl.h
+*
+* 
+*/
+
+#ifndef AMF_REGISTRATION_FOR_NON3_GPP_ACCESS_API_IMPL_H_
+#define AMF_REGISTRATION_FOR_NON3_GPP_ACCESS_API_IMPL_H_
+
+
+#include <pistache/endpoint.h>
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <memory>
+
+#include <AMFRegistrationForNon3GPPAccessApi.h>
+
+#include <pistache/optional.h>
+
+#include "AmfNon3GppAccessRegistration.h"
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class AMFRegistrationForNon3GPPAccessApiImpl : public org::openapitools::server::api::AMFRegistrationForNon3GPPAccessApi {
+public:
+    AMFRegistrationForNon3GPPAccessApiImpl(std::shared_ptr<Pistache::Rest::Router>);
+    ~AMFRegistrationForNon3GPPAccessApiImpl() {}
+
+    void non3_gpp_registration(const std::string &ueId, const AmfNon3GppAccessRegistration &amfNon3GppAccessRegistration, Pistache::Http::ResponseWriter &response);
+
+};
+
+}
+}
+}
+}
+
+
+
+#endif
\ No newline at end of file

src/impl/IPSMGWDeregistrationApiImpl.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "IPSMGWDeregistrationApiImpl.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+IPSMGWDeregistrationApiImpl::IPSMGWDeregistrationApiImpl(std::shared_ptr<Pistache::Rest::Router> rtr)
+    : IPSMGWDeregistrationApi(rtr)
+    { }
+
+void IPSMGWDeregistrationApiImpl::ip_sm_gw_deregistration(const std::string &ueId, Pistache::Http::ResponseWriter &response) {
+    response.send(Pistache::Http::Code::Ok, "Do some magic\n");
+}
+
+}
+}
+}
+}
+

src/impl/IPSMGWDeregistrationApiImpl.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+/*
+* IPSMGWDeregistrationApiImpl.h
+*
+* 
+*/
+
+#ifndef IPSMGW_DEREGISTRATION_API_IMPL_H_
+#define IPSMGW_DEREGISTRATION_API_IMPL_H_
+
+
+#include <pistache/endpoint.h>
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <memory>
+
+#include <IPSMGWDeregistrationApi.h>
+
+#include <pistache/optional.h>
+
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class IPSMGWDeregistrationApiImpl : public org::openapitools::server::api::IPSMGWDeregistrationApi {
+public:
+    IPSMGWDeregistrationApiImpl(std::shared_ptr<Pistache::Rest::Router>);
+    ~IPSMGWDeregistrationApiImpl() {}
+
+    void ip_sm_gw_deregistration(const std::string &ueId, Pistache::Http::ResponseWriter &response);
+
+};
+
+}
+}
+}
+}
+
+
+
+#endif
\ No newline at end of file

src/impl/IPSMGWRegistrationApiImpl.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "IPSMGWRegistrationApiImpl.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+IPSMGWRegistrationApiImpl::IPSMGWRegistrationApiImpl(std::shared_ptr<Pistache::Rest::Router> rtr)
+    : IPSMGWRegistrationApi(rtr)
+    { }
+
+void IPSMGWRegistrationApiImpl::ip_sm_gw_registration(const std::string &ueId, const IpSmGwRegistration &ipSmGwRegistration, Pistache::Http::ResponseWriter &response) {
+    response.send(Pistache::Http::Code::Ok, "Do some magic\n");
+}
+
+}
+}
+}
+}
+

src/impl/IPSMGWRegistrationApiImpl.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+/*
+* IPSMGWRegistrationApiImpl.h
+*
+* 
+*/
+
+#ifndef IPSMGW_REGISTRATION_API_IMPL_H_
+#define IPSMGW_REGISTRATION_API_IMPL_H_
+
+
+#include <pistache/endpoint.h>
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <memory>
+
+#include <IPSMGWRegistrationApi.h>
+
+#include <pistache/optional.h>
+
+#include "IpSmGwRegistration.h"
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class IPSMGWRegistrationApiImpl : public org::openapitools::server::api::IPSMGWRegistrationApi {
+public:
+    IPSMGWRegistrationApiImpl(std::shared_ptr<Pistache::Rest::Router>);
+    ~IPSMGWRegistrationApiImpl() {}
+
+    void ip_sm_gw_registration(const std::string &ueId, const IpSmGwRegistration &ipSmGwRegistration, Pistache::Http::ResponseWriter &response);
+
+};
+
+}
+}
+}
+}
+
+
+
+#endif
\ No newline at end of file

src/impl/IPSMGWRegistrationInfoRetrievalApiImpl.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "IPSMGWRegistrationInfoRetrievalApiImpl.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+IPSMGWRegistrationInfoRetrievalApiImpl::IPSMGWRegistrationInfoRetrievalApiImpl(std::shared_ptr<Pistache::Rest::Router> rtr)
+    : IPSMGWRegistrationInfoRetrievalApi(rtr)
+    { }
+
+void IPSMGWRegistrationInfoRetrievalApiImpl::get_ip_sm_gw_registration(const std::string &ueId, Pistache::Http::ResponseWriter &response) {
+    response.send(Pistache::Http::Code::Ok, "Do some magic\n");
+}
+
+}
+}
+}
+}
+

src/impl/IPSMGWRegistrationInfoRetrievalApiImpl.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+/*
+* IPSMGWRegistrationInfoRetrievalApiImpl.h
+*
+* 
+*/
+
+#ifndef IPSMGW_REGISTRATION_INFO_RETRIEVAL_API_IMPL_H_
+#define IPSMGW_REGISTRATION_INFO_RETRIEVAL_API_IMPL_H_
+
+
+#include <pistache/endpoint.h>
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <memory>
+
+#include <IPSMGWRegistrationInfoRetrievalApi.h>
+
+#include <pistache/optional.h>
+
+#include "IpSmGwRegistration.h"
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class IPSMGWRegistrationInfoRetrievalApiImpl : public org::openapitools::server::api::IPSMGWRegistrationInfoRetrievalApi {
+public:
+    IPSMGWRegistrationInfoRetrievalApiImpl(std::shared_ptr<Pistache::Rest::Router>);
+    ~IPSMGWRegistrationInfoRetrievalApiImpl() {}
+
+    void get_ip_sm_gw_registration(const std::string &ueId, Pistache::Http::ResponseWriter &response);
+
+};
+
+}
+}
+}
+}
+
+
+
+#endif
\ No newline at end of file

src/impl/PEIUpdateApiImpl.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "PEIUpdateApiImpl.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+PEIUpdateApiImpl::PEIUpdateApiImpl(std::shared_ptr<Pistache::Rest::Router> rtr)
+    : PEIUpdateApi(rtr)
+    { }
+
+void PEIUpdateApiImpl::pei_update(const std::string &ueId, const PeiUpdateInfo &peiUpdateInfo, Pistache::Http::ResponseWriter &response) {
+    response.send(Pistache::Http::Code::Ok, "Do some magic\n");
+}
+
+}
+}
+}
+}
+

src/impl/PEIUpdateApiImpl.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+/*
+* PEIUpdateApiImpl.h
+*
+* 
+*/
+
+#ifndef PEI_UPDATE_API_IMPL_H_
+#define PEI_UPDATE_API_IMPL_H_
+
+
+#include <pistache/endpoint.h>
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <memory>
+
+#include <PEIUpdateApi.h>
+
+#include <pistache/optional.h>
+
+#include "PeiUpdateInfo.h"
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class PEIUpdateApiImpl : public org::openapitools::server::api::PEIUpdateApi {
+public:
+    PEIUpdateApiImpl(std::shared_ptr<Pistache::Rest::Router>);
+    ~PEIUpdateApiImpl() {}
+
+    void pei_update(const std::string &ueId, const PeiUpdateInfo &peiUpdateInfo, Pistache::Http::ResponseWriter &response);
+
+};
+
+}
+}
+}
+}
+
+
+
+#endif
\ No newline at end of file

src/impl/ParameterUpdateInTheAMFRegistrationFor3GPPAccessApiImpl.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "ParameterUpdateInTheAMFRegistrationFor3GPPAccessApiImpl.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+ParameterUpdateInTheAMFRegistrationFor3GPPAccessApiImpl::ParameterUpdateInTheAMFRegistrationFor3GPPAccessApiImpl(std::shared_ptr<Pistache::Rest::Router> rtr)
+    : ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi(rtr)
+    { }
+
+void ParameterUpdateInTheAMFRegistrationFor3GPPAccessApiImpl::update3_gpp_registration(const std::string &ueId, const Amf3GppAccessRegistrationModification &amf3GppAccessRegistrationModification, const Pistache::Optional<std::string> &supportedFeatures, Pistache::Http::ResponseWriter &response) {
+    response.send(Pistache::Http::Code::Ok, "Do some magic\n");
+}
+
+}
+}
+}
+}
+

src/impl/ParameterUpdateInTheAMFRegistrationFor3GPPAccessApiImpl.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+/*
+* ParameterUpdateInTheAMFRegistrationFor3GPPAccessApiImpl.h
+*
+* 
+*/
+
+#ifndef PARAMETER_UPDATE_IN_THE_AMF_REGISTRATION_FOR3_GPP_ACCESS_API_IMPL_H_
+#define PARAMETER_UPDATE_IN_THE_AMF_REGISTRATION_FOR3_GPP_ACCESS_API_IMPL_H_
+
+
+#include <pistache/endpoint.h>
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <memory>
+
+#include <ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi.h>
+
+#include <pistache/optional.h>
+
+#include "Amf3GppAccessRegistrationModification.h"
+#include "PatchResult.h"
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class ParameterUpdateInTheAMFRegistrationFor3GPPAccessApiImpl : public org::openapitools::server::api::ParameterUpdateInTheAMFRegistrationFor3GPPAccessApi {
+public:
+    ParameterUpdateInTheAMFRegistrationFor3GPPAccessApiImpl(std::shared_ptr<Pistache::Rest::Router>);
+    ~ParameterUpdateInTheAMFRegistrationFor3GPPAccessApiImpl() {}
+
+    void update3_gpp_registration(const std::string &ueId, const Amf3GppAccessRegistrationModification &amf3GppAccessRegistrationModification, const Pistache::Optional<std::string> &supportedFeatures, Pistache::Http::ResponseWriter &response);
+
+};
+
+}
+}
+}
+}
+
+
+
+#endif
\ No newline at end of file

src/impl/ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApiImpl.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApiImpl.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApiImpl::ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApiImpl(std::shared_ptr<Pistache::Rest::Router> rtr)
+    : ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi(rtr)
+    { }
+
+void ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApiImpl::update_non3_gpp_registration(const std::string &ueId, const AmfNon3GppAccessRegistrationModification &amfNon3GppAccessRegistrationModification, const Pistache::Optional<std::string> &supportedFeatures, Pistache::Http::ResponseWriter &response) {
+    response.send(Pistache::Http::Code::Ok, "Do some magic\n");
+}
+
+}
+}
+}
+}
+

src/impl/ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApiImpl.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+/*
+* ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApiImpl.h
+*
+* 
+*/
+
+#ifndef PARAMETER_UPDATE_IN_THE_AMF_REGISTRATION_FOR_NON3_GPP_ACCESS_API_IMPL_H_
+#define PARAMETER_UPDATE_IN_THE_AMF_REGISTRATION_FOR_NON3_GPP_ACCESS_API_IMPL_H_
+
+
+#include <pistache/endpoint.h>
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <memory>
+
+#include <ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi.h>
+
+#include <pistache/optional.h>
+
+#include "AmfNon3GppAccessRegistrationModification.h"
+#include "PatchResult.h"
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApiImpl : public org::openapitools::server::api::ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApi {
+public:
+    ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApiImpl(std::shared_ptr<Pistache::Rest::Router>);
+    ~ParameterUpdateInTheAMFRegistrationForNon3GPPAccessApiImpl() {}
+
+    void update_non3_gpp_registration(const std::string &ueId, const AmfNon3GppAccessRegistrationModification &amfNon3GppAccessRegistrationModification, const Pistache::Optional<std::string> &supportedFeatures, Pistache::Http::ResponseWriter &response);
+
+};
+
+}
+}
+}
+}
+
+
+
+#endif
\ No newline at end of file

src/impl/RetrieveSMFRegistrationApiImpl.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "RetrieveSMFRegistrationApiImpl.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+RetrieveSMFRegistrationApiImpl::RetrieveSMFRegistrationApiImpl(std::shared_ptr<Pistache::Rest::Router> rtr)
+    : RetrieveSMFRegistrationApi(rtr)
+    { }
+
+void RetrieveSMFRegistrationApiImpl::retrieve_smf_registration(const std::string &ueId, const int32_t &pduSessionId, Pistache::Http::ResponseWriter &response) {
+    response.send(Pistache::Http::Code::Ok, "Do some magic\n");
+}
+
+}
+}
+}
+}
+

src/impl/RetrieveSMFRegistrationApiImpl.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+/*
+* RetrieveSMFRegistrationApiImpl.h
+*
+* 
+*/
+
+#ifndef RETRIEVE_SMF_REGISTRATION_API_IMPL_H_
+#define RETRIEVE_SMF_REGISTRATION_API_IMPL_H_
+
+
+#include <pistache/endpoint.h>
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <memory>
+
+#include <RetrieveSMFRegistrationApi.h>
+
+#include <pistache/optional.h>
+
+#include "ProblemDetails.h"
+#include "SmfRegistration.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class RetrieveSMFRegistrationApiImpl : public org::openapitools::server::api::RetrieveSMFRegistrationApi {
+public:
+    RetrieveSMFRegistrationApiImpl(std::shared_ptr<Pistache::Rest::Router>);
+    ~RetrieveSMFRegistrationApiImpl() {}
+
+    void retrieve_smf_registration(const std::string &ueId, const int32_t &pduSessionId, Pistache::Http::ResponseWriter &response);
+
+};
+
+}
+}
+}
+}
+
+
+
+#endif
\ No newline at end of file

src/impl/SMFDeregistrationApiImpl.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "SMFDeregistrationApiImpl.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+SMFDeregistrationApiImpl::SMFDeregistrationApiImpl(std::shared_ptr<Pistache::Rest::Router> rtr)
+    : SMFDeregistrationApi(rtr)
+    { }
+
+void SMFDeregistrationApiImpl::smf_deregistration(const std::string &ueId, const int32_t &pduSessionId, const Pistache::Optional<std::string> &smfSetId, Pistache::Http::ResponseWriter &response) {
+    response.send(Pistache::Http::Code::Ok, "Do some magic\n");
+}
+
+}
+}
+}
+}
+

src/impl/SMFDeregistrationApiImpl.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+/*
+* SMFDeregistrationApiImpl.h
+*
+* 
+*/
+
+#ifndef SMF_DEREGISTRATION_API_IMPL_H_
+#define SMF_DEREGISTRATION_API_IMPL_H_
+
+
+#include <pistache/endpoint.h>
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <memory>
+
+#include <SMFDeregistrationApi.h>
+
+#include <pistache/optional.h>
+
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class SMFDeregistrationApiImpl : public org::openapitools::server::api::SMFDeregistrationApi {
+public:
+    SMFDeregistrationApiImpl(std::shared_ptr<Pistache::Rest::Router>);
+    ~SMFDeregistrationApiImpl() {}
+
+    void smf_deregistration(const std::string &ueId, const int32_t &pduSessionId, const Pistache::Optional<std::string> &smfSetId, Pistache::Http::ResponseWriter &response);
+
+};
+
+}
+}
+}
+}
+
+
+
+#endif
\ No newline at end of file

src/impl/SMFSmfRegistrationApiImpl.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "SMFSmfRegistrationApiImpl.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+SMFSmfRegistrationApiImpl::SMFSmfRegistrationApiImpl(std::shared_ptr<Pistache::Rest::Router> rtr)
+    : SMFSmfRegistrationApi(rtr)
+    { }
+
+void SMFSmfRegistrationApiImpl::get_smf_registration(const std::string &ueId, const Pistache::Optional<Snssai> &singleNssai, const Pistache::Optional<std::string> &dnn, const Pistache::Optional<std::string> &supportedFeatures, Pistache::Http::ResponseWriter &response) {
+    response.send(Pistache::Http::Code::Ok, "Do some magic\n");
+}
+void SMFSmfRegistrationApiImpl::registration(const std::string &ueId, const int32_t &pduSessionId, const SmfRegistration &smfRegistration, Pistache::Http::ResponseWriter &response) {
+    response.send(Pistache::Http::Code::Ok, "Do some magic\n");
+}
+
+}
+}
+}
+}
+

src/impl/SMFSmfRegistrationApiImpl.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+/*
+* SMFSmfRegistrationApiImpl.h
+*
+* 
+*/
+
+#ifndef SMF_SMF_REGISTRATION_API_IMPL_H_
+#define SMF_SMF_REGISTRATION_API_IMPL_H_
+
+
+#include <pistache/endpoint.h>
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <memory>
+
+#include <SMFSmfRegistrationApi.h>
+
+#include <pistache/optional.h>
+
+#include "ProblemDetails.h"
+#include "SmfRegistration.h"
+#include "SmfRegistrationInfo.h"
+#include "Snssai.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class SMFSmfRegistrationApiImpl : public org::openapitools::server::api::SMFSmfRegistrationApi {
+public:
+    SMFSmfRegistrationApiImpl(std::shared_ptr<Pistache::Rest::Router>);
+    ~SMFSmfRegistrationApiImpl() {}
+
+    void get_smf_registration(const std::string &ueId, const Pistache::Optional<Snssai> &singleNssai, const Pistache::Optional<std::string> &dnn, const Pistache::Optional<std::string> &supportedFeatures, Pistache::Http::ResponseWriter &response);
+    void registration(const std::string &ueId, const int32_t &pduSessionId, const SmfRegistration &smfRegistration, Pistache::Http::ResponseWriter &response);
+
+};
+
+}
+}
+}
+}
+
+
+
+#endif
\ No newline at end of file

src/impl/SMSF3GPPAccessRegistrationInfoRetrievalApiImpl.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "SMSF3GPPAccessRegistrationInfoRetrievalApiImpl.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+SMSF3GPPAccessRegistrationInfoRetrievalApiImpl::SMSF3GPPAccessRegistrationInfoRetrievalApiImpl(std::shared_ptr<Pistache::Rest::Router> rtr)
+    : SMSF3GPPAccessRegistrationInfoRetrievalApi(rtr)
+    { }
+
+void SMSF3GPPAccessRegistrationInfoRetrievalApiImpl::get3_gpp_smsf_registration(const std::string &ueId, const Pistache::Optional<std::string> &supportedFeatures, Pistache::Http::ResponseWriter &response) {
+    response.send(Pistache::Http::Code::Ok, "Do some magic\n");
+}
+
+}
+}
+}
+}
+

src/impl/SMSF3GPPAccessRegistrationInfoRetrievalApiImpl.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+/*
+* SMSF3GPPAccessRegistrationInfoRetrievalApiImpl.h
+*
+* 
+*/
+
+#ifndef SMSF3_GPP_ACCESS_REGISTRATION_INFO_RETRIEVAL_API_IMPL_H_
+#define SMSF3_GPP_ACCESS_REGISTRATION_INFO_RETRIEVAL_API_IMPL_H_
+
+
+#include <pistache/endpoint.h>
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <memory>
+
+#include <SMSF3GPPAccessRegistrationInfoRetrievalApi.h>
+
+#include <pistache/optional.h>
+
+#include "ProblemDetails.h"
+#include "SmsfRegistration.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class SMSF3GPPAccessRegistrationInfoRetrievalApiImpl : public org::openapitools::server::api::SMSF3GPPAccessRegistrationInfoRetrievalApi {
+public:
+    SMSF3GPPAccessRegistrationInfoRetrievalApiImpl(std::shared_ptr<Pistache::Rest::Router>);
+    ~SMSF3GPPAccessRegistrationInfoRetrievalApiImpl() {}
+
+    void get3_gpp_smsf_registration(const std::string &ueId, const Pistache::Optional<std::string> &supportedFeatures, Pistache::Http::ResponseWriter &response);
+
+};
+
+}
+}
+}
+}
+
+
+
+#endif
\ No newline at end of file

src/impl/SMSFDeregistrationFor3GPPAccessApiImpl.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "SMSFDeregistrationFor3GPPAccessApiImpl.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+SMSFDeregistrationFor3GPPAccessApiImpl::SMSFDeregistrationFor3GPPAccessApiImpl(std::shared_ptr<Pistache::Rest::Router> rtr)
+    : SMSFDeregistrationFor3GPPAccessApi(rtr)
+    { }
+
+void SMSFDeregistrationFor3GPPAccessApiImpl::3_gpp_smsf_deregistration(const std::string &ueId, const Pistache::Optional<std::string> &smsfSetId, Pistache::Http::ResponseWriter &response) {
+    response.send(Pistache::Http::Code::Ok, "Do some magic\n");
+}
+
+}
+}
+}
+}
+

src/impl/SMSFDeregistrationFor3GPPAccessApiImpl.h

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+/*
+* SMSFDeregistrationFor3GPPAccessApiImpl.h
+*
+* 
+*/
+
+#ifndef SMSF_DEREGISTRATION_FOR3_GPP_ACCESS_API_IMPL_H_
+#define SMSF_DEREGISTRATION_FOR3_GPP_ACCESS_API_IMPL_H_
+
+
+#include <pistache/endpoint.h>
+#include <pistache/http.h>
+#include <pistache/router.h>
+#include <memory>
+
+#include <SMSFDeregistrationFor3GPPAccessApi.h>
+
+#include <pistache/optional.h>
+
+#include "ProblemDetails.h"
+#include <string>
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+class SMSFDeregistrationFor3GPPAccessApiImpl : public org::openapitools::server::api::SMSFDeregistrationFor3GPPAccessApi {
+public:
+    SMSFDeregistrationFor3GPPAccessApiImpl(std::shared_ptr<Pistache::Rest::Router>);
+    ~SMSFDeregistrationFor3GPPAccessApiImpl() {}
+
+    void 3_gpp_smsf_deregistration(const std::string &ueId, const Pistache::Optional<std::string> &smsfSetId, Pistache::Http::ResponseWriter &response);
+
+};
+
+}
+}
+}
+}
+
+
+
+#endif
\ No newline at end of file

src/impl/SMSFDeregistrationForNon3GPPAccessApiImpl.cpp

+/**
+* Nudm_UECM
+* Nudm Context Management Service. � 2020, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved. 
+*
+* The version of the OpenAPI document: 1.1.2
+* 
+*
+* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+* https://openapi-generator.tech
+* Do not edit the class manually.
+*/
+
+#include "SMSFDeregistrationForNon3GPPAccessApiImpl.h"
+
+namespace org {
+namespace openapitools {
+namespace server {
+namespace api {
+
+using namespace org::openapitools::server::model;
+
+SMSFDeregistrationForNon3GPPAccessApiImpl::SMSFDeregistrationForNon3GPPAccessApiImpl(std::shared_ptr<Pistache::Rest::Router> rtr)
+    : SMSFDeregistrationForNon3GPPAccessApi(rtr)
+    { }
+
+void SMSFDeregistrationForNon3GPPAccessApiImpl::non3_gpp_smsf_deregistration(const std::string &ueId, const Pistache::Optional<std::string> &smsfSetId, Pistache::Http::ResponseWriter &response) {
+    response.send(Pistache::Http::Code::Ok, "Do some magic\n");
+}
+
+}
+}
+}
+}
+