Add DleteNacosInstance.

CHANGELOG

@@ -1,3 +1,8 @@
+2022-02-21 Version: 1.36.1060
+- Add DleteNacosInstance.
+- Change CreateCluster parameter.
+- Change UpdateNacosInstance errorCode.
+
 2022-02-18 Version: 1.36.1059
 - Iot_20180120 build sdk.
 

VERSION

@@ -1 +1 @@
-1.36.1059
+1.36.1060

mse/CMakeLists.txt

@@ -29,6 +29,8 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/AddGatewayResult.h
 	include/alibabacloud/mse/model/AddGatewayDomainRequest.h
 	include/alibabacloud/mse/model/AddGatewayDomainResult.h
+	include/alibabacloud/mse/model/AddGatewayRouteRequest.h
+	include/alibabacloud/mse/model/AddGatewayRouteResult.h
 	include/alibabacloud/mse/model/AddGatewayServiceVersionRequest.h
 	include/alibabacloud/mse/model/AddGatewayServiceVersionResult.h
 	include/alibabacloud/mse/model/AddGatewaySlbRequest.h
@@ -39,6 +41,10 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/AddSSLCertResult.h
 	include/alibabacloud/mse/model/AddServiceSourceRequest.h
 	include/alibabacloud/mse/model/AddServiceSourceResult.h
+	include/alibabacloud/mse/model/ApplyGatewayRouteRequest.h
+	include/alibabacloud/mse/model/ApplyGatewayRouteResult.h
+	include/alibabacloud/mse/model/ApplyTagPoliciesRequest.h
+	include/alibabacloud/mse/model/ApplyTagPoliciesResult.h
 	include/alibabacloud/mse/model/CloneNacosConfigRequest.h
 	include/alibabacloud/mse/model/CloneNacosConfigResult.h
 	include/alibabacloud/mse/model/CreateAlarmRuleRequest.h
@@ -55,6 +61,10 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/CreateNacosInstanceResult.h
 	include/alibabacloud/mse/model/CreateNacosServiceRequest.h
 	include/alibabacloud/mse/model/CreateNacosServiceResult.h
+	include/alibabacloud/mse/model/CreateOrUpdateSwimmingLaneRequest.h
+	include/alibabacloud/mse/model/CreateOrUpdateSwimmingLaneResult.h
+	include/alibabacloud/mse/model/CreateOrUpdateSwimmingLaneGroupRequest.h
+	include/alibabacloud/mse/model/CreateOrUpdateSwimmingLaneGroupResult.h
 	include/alibabacloud/mse/model/CreateZnodeRequest.h
 	include/alibabacloud/mse/model/CreateZnodeResult.h
 	include/alibabacloud/mse/model/DeleteAlarmRuleRequest.h
@@ -69,6 +79,8 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/DeleteGatewayResult.h
 	include/alibabacloud/mse/model/DeleteGatewayDomainRequest.h
 	include/alibabacloud/mse/model/DeleteGatewayDomainResult.h
+	include/alibabacloud/mse/model/DeleteGatewayRouteRequest.h
+	include/alibabacloud/mse/model/DeleteGatewayRouteResult.h
 	include/alibabacloud/mse/model/DeleteGatewayServiceVersionRequest.h
 	include/alibabacloud/mse/model/DeleteGatewayServiceVersionResult.h
 	include/alibabacloud/mse/model/DeleteGatewaySlbRequest.h
@@ -77,10 +89,16 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/DeleteNacosConfigResult.h
 	include/alibabacloud/mse/model/DeleteNacosConfigsRequest.h
 	include/alibabacloud/mse/model/DeleteNacosConfigsResult.h
+	include/alibabacloud/mse/model/DeleteNacosInstanceRequest.h
+	include/alibabacloud/mse/model/DeleteNacosInstanceResult.h
 	include/alibabacloud/mse/model/DeleteNacosServiceRequest.h
 	include/alibabacloud/mse/model/DeleteNacosServiceResult.h
 	include/alibabacloud/mse/model/DeleteServiceSourceRequest.h
 	include/alibabacloud/mse/model/DeleteServiceSourceResult.h
+	include/alibabacloud/mse/model/DeleteSwimmingLaneRequest.h
+	include/alibabacloud/mse/model/DeleteSwimmingLaneResult.h
+	include/alibabacloud/mse/model/DeleteSwimmingLaneGroupRequest.h
+	include/alibabacloud/mse/model/DeleteSwimmingLaneGroupResult.h
 	include/alibabacloud/mse/model/DeleteZnodeRequest.h
 	include/alibabacloud/mse/model/DeleteZnodeResult.h
 	include/alibabacloud/mse/model/ExportNacosConfigRequest.h
@@ -95,6 +113,8 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/GetGatewayDomainDetailResult.h
 	include/alibabacloud/mse/model/GetGatewayOptionRequest.h
 	include/alibabacloud/mse/model/GetGatewayOptionResult.h
+	include/alibabacloud/mse/model/GetGatewayRouteDetailRequest.h
+	include/alibabacloud/mse/model/GetGatewayRouteDetailResult.h
 	include/alibabacloud/mse/model/GetGatewayServiceDetailRequest.h
 	include/alibabacloud/mse/model/GetGatewayServiceDetailResult.h
 	include/alibabacloud/mse/model/GetGovernanceKubernetesClusterRequest.h
@@ -117,6 +137,10 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/GetNacosHistoryConfigResult.h
 	include/alibabacloud/mse/model/GetOverviewRequest.h
 	include/alibabacloud/mse/model/GetOverviewResult.h
+	include/alibabacloud/mse/model/GetServiceListRequest.h
+	include/alibabacloud/mse/model/GetServiceListResult.h
+	include/alibabacloud/mse/model/GetTagsBySwimmingLaneGroupIdRequest.h
+	include/alibabacloud/mse/model/GetTagsBySwimmingLaneGroupIdResult.h
 	include/alibabacloud/mse/model/ImportNacosConfigRequest.h
 	include/alibabacloud/mse/model/ImportNacosConfigResult.h
 	include/alibabacloud/mse/model/ImportServicesRequest.h
@@ -135,6 +159,10 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/ListAnsServiceClustersResult.h
 	include/alibabacloud/mse/model/ListAnsServicesRequest.h
 	include/alibabacloud/mse/model/ListAnsServicesResult.h
+	include/alibabacloud/mse/model/ListAppBySwimmingLaneGroupTagRequest.h
+	include/alibabacloud/mse/model/ListAppBySwimmingLaneGroupTagResult.h
+	include/alibabacloud/mse/model/ListApplicationsWithTagRulesRequest.h
+	include/alibabacloud/mse/model/ListApplicationsWithTagRulesResult.h
 	include/alibabacloud/mse/model/ListClusterConnectionTypesRequest.h
 	include/alibabacloud/mse/model/ListClusterConnectionTypesResult.h
 	include/alibabacloud/mse/model/ListClusterTypesRequest.h
@@ -153,6 +181,8 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/ListGatewayResult.h
 	include/alibabacloud/mse/model/ListGatewayDomainRequest.h
 	include/alibabacloud/mse/model/ListGatewayDomainResult.h
+	include/alibabacloud/mse/model/ListGatewayRouteRequest.h
+	include/alibabacloud/mse/model/ListGatewayRouteResult.h
 	include/alibabacloud/mse/model/ListGatewayServiceRequest.h
 	include/alibabacloud/mse/model/ListGatewayServiceResult.h
 	include/alibabacloud/mse/model/ListGatewaySlbRequest.h
@@ -173,8 +203,14 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/ListZnodeChildrenResult.h
 	include/alibabacloud/mse/model/ModifyGovernanceKubernetesClusterRequest.h
 	include/alibabacloud/mse/model/ModifyGovernanceKubernetesClusterResult.h
+	include/alibabacloud/mse/model/OfflineGatewayRouteRequest.h
+	include/alibabacloud/mse/model/OfflineGatewayRouteResult.h
 	include/alibabacloud/mse/model/PullServicesRequest.h
 	include/alibabacloud/mse/model/PullServicesResult.h
+	include/alibabacloud/mse/model/QueryAllSwimmingLaneRequest.h
+	include/alibabacloud/mse/model/QueryAllSwimmingLaneResult.h
+	include/alibabacloud/mse/model/QueryAllSwimmingLaneGroupRequest.h
+	include/alibabacloud/mse/model/QueryAllSwimmingLaneGroupResult.h
 	include/alibabacloud/mse/model/QueryBusinessLocationsRequest.h
 	include/alibabacloud/mse/model/QueryBusinessLocationsResult.h
 	include/alibabacloud/mse/model/QueryClusterDetailRequest.h
@@ -195,6 +231,8 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/QueryMonitorResult.h
 	include/alibabacloud/mse/model/QuerySlbSpecRequest.h
 	include/alibabacloud/mse/model/QuerySlbSpecResult.h
+	include/alibabacloud/mse/model/QuerySwimmingLaneByIdRequest.h
+	include/alibabacloud/mse/model/QuerySwimmingLaneByIdResult.h
 	include/alibabacloud/mse/model/QueryZnodeDetailRequest.h
 	include/alibabacloud/mse/model/QueryZnodeDetailResult.h
 	include/alibabacloud/mse/model/RestartClusterRequest.h
@@ -221,8 +259,18 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/UpdateGatewayNameResult.h
 	include/alibabacloud/mse/model/UpdateGatewayOptionRequest.h
 	include/alibabacloud/mse/model/UpdateGatewayOptionResult.h
+	include/alibabacloud/mse/model/UpdateGatewayRouteRequest.h
+	include/alibabacloud/mse/model/UpdateGatewayRouteResult.h
+	include/alibabacloud/mse/model/UpdateGatewayRouteCORSRequest.h
+	include/alibabacloud/mse/model/UpdateGatewayRouteCORSResult.h
 	include/alibabacloud/mse/model/UpdateGatewayRouteHTTPRewriteRequest.h
 	include/alibabacloud/mse/model/UpdateGatewayRouteHTTPRewriteResult.h
+	include/alibabacloud/mse/model/UpdateGatewayRouteHeaderOpRequest.h
+	include/alibabacloud/mse/model/UpdateGatewayRouteHeaderOpResult.h
+	include/alibabacloud/mse/model/UpdateGatewayRouteRetryRequest.h
+	include/alibabacloud/mse/model/UpdateGatewayRouteRetryResult.h
+	include/alibabacloud/mse/model/UpdateGatewayRouteTimeoutRequest.h
+	include/alibabacloud/mse/model/UpdateGatewayRouteTimeoutResult.h
 	include/alibabacloud/mse/model/UpdateGatewayServiceVersionRequest.h
 	include/alibabacloud/mse/model/UpdateGatewayServiceVersionResult.h
 	include/alibabacloud/mse/model/UpdateImageRequest.h
@@ -252,6 +300,8 @@ set(mse_src
 	src/model/AddGatewayResult.cc
 	src/model/AddGatewayDomainRequest.cc
 	src/model/AddGatewayDomainResult.cc
+	src/model/AddGatewayRouteRequest.cc
+	src/model/AddGatewayRouteResult.cc
 	src/model/AddGatewayServiceVersionRequest.cc
 	src/model/AddGatewayServiceVersionResult.cc
 	src/model/AddGatewaySlbRequest.cc
@@ -262,6 +312,10 @@ set(mse_src
 	src/model/AddSSLCertResult.cc
 	src/model/AddServiceSourceRequest.cc
 	src/model/AddServiceSourceResult.cc
+	src/model/ApplyGatewayRouteRequest.cc
+	src/model/ApplyGatewayRouteResult.cc
+	src/model/ApplyTagPoliciesRequest.cc
+	src/model/ApplyTagPoliciesResult.cc
 	src/model/CloneNacosConfigRequest.cc
 	src/model/CloneNacosConfigResult.cc
 	src/model/CreateAlarmRuleRequest.cc
@@ -278,6 +332,10 @@ set(mse_src
 	src/model/CreateNacosInstanceResult.cc
 	src/model/CreateNacosServiceRequest.cc
 	src/model/CreateNacosServiceResult.cc
+	src/model/CreateOrUpdateSwimmingLaneRequest.cc
+	src/model/CreateOrUpdateSwimmingLaneResult.cc
+	src/model/CreateOrUpdateSwimmingLaneGroupRequest.cc
+	src/model/CreateOrUpdateSwimmingLaneGroupResult.cc
 	src/model/CreateZnodeRequest.cc
 	src/model/CreateZnodeResult.cc
 	src/model/DeleteAlarmRuleRequest.cc
@@ -292,6 +350,8 @@ set(mse_src
 	src/model/DeleteGatewayResult.cc
 	src/model/DeleteGatewayDomainRequest.cc
 	src/model/DeleteGatewayDomainResult.cc
+	src/model/DeleteGatewayRouteRequest.cc
+	src/model/DeleteGatewayRouteResult.cc
 	src/model/DeleteGatewayServiceVersionRequest.cc
 	src/model/DeleteGatewayServiceVersionResult.cc
 	src/model/DeleteGatewaySlbRequest.cc
@@ -300,10 +360,16 @@ set(mse_src
 	src/model/DeleteNacosConfigResult.cc
 	src/model/DeleteNacosConfigsRequest.cc
 	src/model/DeleteNacosConfigsResult.cc
+	src/model/DeleteNacosInstanceRequest.cc
+	src/model/DeleteNacosInstanceResult.cc
 	src/model/DeleteNacosServiceRequest.cc
 	src/model/DeleteNacosServiceResult.cc
 	src/model/DeleteServiceSourceRequest.cc
 	src/model/DeleteServiceSourceResult.cc
+	src/model/DeleteSwimmingLaneRequest.cc
+	src/model/DeleteSwimmingLaneResult.cc
+	src/model/DeleteSwimmingLaneGroupRequest.cc
+	src/model/DeleteSwimmingLaneGroupResult.cc
 	src/model/DeleteZnodeRequest.cc
 	src/model/DeleteZnodeResult.cc
 	src/model/ExportNacosConfigRequest.cc
@@ -318,6 +384,8 @@ set(mse_src
 	src/model/GetGatewayDomainDetailResult.cc
 	src/model/GetGatewayOptionRequest.cc
 	src/model/GetGatewayOptionResult.cc
+	src/model/GetGatewayRouteDetailRequest.cc
+	src/model/GetGatewayRouteDetailResult.cc
 	src/model/GetGatewayServiceDetailRequest.cc
 	src/model/GetGatewayServiceDetailResult.cc
 	src/model/GetGovernanceKubernetesClusterRequest.cc
@@ -340,6 +408,10 @@ set(mse_src
 	src/model/GetNacosHistoryConfigResult.cc
 	src/model/GetOverviewRequest.cc
 	src/model/GetOverviewResult.cc
+	src/model/GetServiceListRequest.cc
+	src/model/GetServiceListResult.cc
+	src/model/GetTagsBySwimmingLaneGroupIdRequest.cc
+	src/model/GetTagsBySwimmingLaneGroupIdResult.cc
 	src/model/ImportNacosConfigRequest.cc
 	src/model/ImportNacosConfigResult.cc
 	src/model/ImportServicesRequest.cc
@@ -358,6 +430,10 @@ set(mse_src
 	src/model/ListAnsServiceClustersResult.cc
 	src/model/ListAnsServicesRequest.cc
 	src/model/ListAnsServicesResult.cc
+	src/model/ListAppBySwimmingLaneGroupTagRequest.cc
+	src/model/ListAppBySwimmingLaneGroupTagResult.cc
+	src/model/ListApplicationsWithTagRulesRequest.cc
+	src/model/ListApplicationsWithTagRulesResult.cc
 	src/model/ListClusterConnectionTypesRequest.cc
 	src/model/ListClusterConnectionTypesResult.cc
 	src/model/ListClusterTypesRequest.cc
@@ -376,6 +452,8 @@ set(mse_src
 	src/model/ListGatewayResult.cc
 	src/model/ListGatewayDomainRequest.cc
 	src/model/ListGatewayDomainResult.cc
+	src/model/ListGatewayRouteRequest.cc
+	src/model/ListGatewayRouteResult.cc
 	src/model/ListGatewayServiceRequest.cc
 	src/model/ListGatewayServiceResult.cc
 	src/model/ListGatewaySlbRequest.cc
@@ -396,8 +474,14 @@ set(mse_src
 	src/model/ListZnodeChildrenResult.cc
 	src/model/ModifyGovernanceKubernetesClusterRequest.cc
 	src/model/ModifyGovernanceKubernetesClusterResult.cc
+	src/model/OfflineGatewayRouteRequest.cc
+	src/model/OfflineGatewayRouteResult.cc
 	src/model/PullServicesRequest.cc
 	src/model/PullServicesResult.cc
+	src/model/QueryAllSwimmingLaneRequest.cc
+	src/model/QueryAllSwimmingLaneResult.cc
+	src/model/QueryAllSwimmingLaneGroupRequest.cc
+	src/model/QueryAllSwimmingLaneGroupResult.cc
 	src/model/QueryBusinessLocationsRequest.cc
 	src/model/QueryBusinessLocationsResult.cc
 	src/model/QueryClusterDetailRequest.cc
@@ -418,6 +502,8 @@ set(mse_src
 	src/model/QueryMonitorResult.cc
 	src/model/QuerySlbSpecRequest.cc
 	src/model/QuerySlbSpecResult.cc
+	src/model/QuerySwimmingLaneByIdRequest.cc
+	src/model/QuerySwimmingLaneByIdResult.cc
 	src/model/QueryZnodeDetailRequest.cc
 	src/model/QueryZnodeDetailResult.cc
 	src/model/RestartClusterRequest.cc
@@ -444,8 +530,18 @@ set(mse_src
 	src/model/UpdateGatewayNameResult.cc
 	src/model/UpdateGatewayOptionRequest.cc
 	src/model/UpdateGatewayOptionResult.cc
+	src/model/UpdateGatewayRouteRequest.cc
+	src/model/UpdateGatewayRouteResult.cc
+	src/model/UpdateGatewayRouteCORSRequest.cc
+	src/model/UpdateGatewayRouteCORSResult.cc
 	src/model/UpdateGatewayRouteHTTPRewriteRequest.cc
 	src/model/UpdateGatewayRouteHTTPRewriteResult.cc
+	src/model/UpdateGatewayRouteHeaderOpRequest.cc
+	src/model/UpdateGatewayRouteHeaderOpResult.cc
+	src/model/UpdateGatewayRouteRetryRequest.cc
+	src/model/UpdateGatewayRouteRetryResult.cc
+	src/model/UpdateGatewayRouteTimeoutRequest.cc
+	src/model/UpdateGatewayRouteTimeoutResult.cc
 	src/model/UpdateGatewayServiceVersionRequest.cc
 	src/model/UpdateGatewayServiceVersionResult.cc
 	src/model/UpdateImageRequest.cc

mse/include/alibabacloud/mse/MseClient.h

@@ -30,6 +30,8 @@
 #include "model/AddGatewayResult.h"
 #include "model/AddGatewayDomainRequest.h"
 #include "model/AddGatewayDomainResult.h"
+#include "model/AddGatewayRouteRequest.h"
+#include "model/AddGatewayRouteResult.h"
 #include "model/AddGatewayServiceVersionRequest.h"
 #include "model/AddGatewayServiceVersionResult.h"
 #include "model/AddGatewaySlbRequest.h"
@@ -40,6 +42,10 @@
 #include "model/AddSSLCertResult.h"
 #include "model/AddServiceSourceRequest.h"
 #include "model/AddServiceSourceResult.h"
+#include "model/ApplyGatewayRouteRequest.h"
+#include "model/ApplyGatewayRouteResult.h"
+#include "model/ApplyTagPoliciesRequest.h"
+#include "model/ApplyTagPoliciesResult.h"
 #include "model/CloneNacosConfigRequest.h"
 #include "model/CloneNacosConfigResult.h"
 #include "model/CreateAlarmRuleRequest.h"
@@ -56,6 +62,10 @@
 #include "model/CreateNacosInstanceResult.h"
 #include "model/CreateNacosServiceRequest.h"
 #include "model/CreateNacosServiceResult.h"
+#include "model/CreateOrUpdateSwimmingLaneRequest.h"
+#include "model/CreateOrUpdateSwimmingLaneResult.h"
+#include "model/CreateOrUpdateSwimmingLaneGroupRequest.h"
+#include "model/CreateOrUpdateSwimmingLaneGroupResult.h"
 #include "model/CreateZnodeRequest.h"
 #include "model/CreateZnodeResult.h"
 #include "model/DeleteAlarmRuleRequest.h"
@@ -70,6 +80,8 @@
 #include "model/DeleteGatewayResult.h"
 #include "model/DeleteGatewayDomainRequest.h"
 #include "model/DeleteGatewayDomainResult.h"
+#include "model/DeleteGatewayRouteRequest.h"
+#include "model/DeleteGatewayRouteResult.h"
 #include "model/DeleteGatewayServiceVersionRequest.h"
 #include "model/DeleteGatewayServiceVersionResult.h"
 #include "model/DeleteGatewaySlbRequest.h"
@@ -78,10 +90,16 @@
 #include "model/DeleteNacosConfigResult.h"
 #include "model/DeleteNacosConfigsRequest.h"
 #include "model/DeleteNacosConfigsResult.h"
+#include "model/DeleteNacosInstanceRequest.h"
+#include "model/DeleteNacosInstanceResult.h"
 #include "model/DeleteNacosServiceRequest.h"
 #include "model/DeleteNacosServiceResult.h"
 #include "model/DeleteServiceSourceRequest.h"
 #include "model/DeleteServiceSourceResult.h"
+#include "model/DeleteSwimmingLaneRequest.h"
+#include "model/DeleteSwimmingLaneResult.h"
+#include "model/DeleteSwimmingLaneGroupRequest.h"
+#include "model/DeleteSwimmingLaneGroupResult.h"
 #include "model/DeleteZnodeRequest.h"
 #include "model/DeleteZnodeResult.h"
 #include "model/ExportNacosConfigRequest.h"
@@ -96,6 +114,8 @@
 #include "model/GetGatewayDomainDetailResult.h"
 #include "model/GetGatewayOptionRequest.h"
 #include "model/GetGatewayOptionResult.h"
+#include "model/GetGatewayRouteDetailRequest.h"
+#include "model/GetGatewayRouteDetailResult.h"
 #include "model/GetGatewayServiceDetailRequest.h"
 #include "model/GetGatewayServiceDetailResult.h"
 #include "model/GetGovernanceKubernetesClusterRequest.h"
@@ -118,6 +138,10 @@
 #include "model/GetNacosHistoryConfigResult.h"
 #include "model/GetOverviewRequest.h"
 #include "model/GetOverviewResult.h"
+#include "model/GetServiceListRequest.h"
+#include "model/GetServiceListResult.h"
+#include "model/GetTagsBySwimmingLaneGroupIdRequest.h"
+#include "model/GetTagsBySwimmingLaneGroupIdResult.h"
 #include "model/ImportNacosConfigRequest.h"
 #include "model/ImportNacosConfigResult.h"
 #include "model/ImportServicesRequest.h"
@@ -136,6 +160,10 @@
 #include "model/ListAnsServiceClustersResult.h"
 #include "model/ListAnsServicesRequest.h"
 #include "model/ListAnsServicesResult.h"
+#include "model/ListAppBySwimmingLaneGroupTagRequest.h"
+#include "model/ListAppBySwimmingLaneGroupTagResult.h"
+#include "model/ListApplicationsWithTagRulesRequest.h"
+#include "model/ListApplicationsWithTagRulesResult.h"
 #include "model/ListClusterConnectionTypesRequest.h"
 #include "model/ListClusterConnectionTypesResult.h"
 #include "model/ListClusterTypesRequest.h"
@@ -154,6 +182,8 @@
 #include "model/ListGatewayResult.h"
 #include "model/ListGatewayDomainRequest.h"
 #include "model/ListGatewayDomainResult.h"
+#include "model/ListGatewayRouteRequest.h"
+#include "model/ListGatewayRouteResult.h"
 #include "model/ListGatewayServiceRequest.h"
 #include "model/ListGatewayServiceResult.h"
 #include "model/ListGatewaySlbRequest.h"
@@ -174,8 +204,14 @@
 #include "model/ListZnodeChildrenResult.h"
 #include "model/ModifyGovernanceKubernetesClusterRequest.h"
 #include "model/ModifyGovernanceKubernetesClusterResult.h"
+#include "model/OfflineGatewayRouteRequest.h"
+#include "model/OfflineGatewayRouteResult.h"
 #include "model/PullServicesRequest.h"
 #include "model/PullServicesResult.h"
+#include "model/QueryAllSwimmingLaneRequest.h"
+#include "model/QueryAllSwimmingLaneResult.h"
+#include "model/QueryAllSwimmingLaneGroupRequest.h"
+#include "model/QueryAllSwimmingLaneGroupResult.h"
 #include "model/QueryBusinessLocationsRequest.h"
 #include "model/QueryBusinessLocationsResult.h"
 #include "model/QueryClusterDetailRequest.h"
@@ -196,6 +232,8 @@
 #include "model/QueryMonitorResult.h"
 #include "model/QuerySlbSpecRequest.h"
 #include "model/QuerySlbSpecResult.h"
+#include "model/QuerySwimmingLaneByIdRequest.h"
+#include "model/QuerySwimmingLaneByIdResult.h"
 #include "model/QueryZnodeDetailRequest.h"
 #include "model/QueryZnodeDetailResult.h"
 #include "model/RestartClusterRequest.h"
@@ -222,8 +260,18 @@
 #include "model/UpdateGatewayNameResult.h"
 #include "model/UpdateGatewayOptionRequest.h"
 #include "model/UpdateGatewayOptionResult.h"
+#include "model/UpdateGatewayRouteRequest.h"
+#include "model/UpdateGatewayRouteResult.h"
+#include "model/UpdateGatewayRouteCORSRequest.h"
+#include "model/UpdateGatewayRouteCORSResult.h"
 #include "model/UpdateGatewayRouteHTTPRewriteRequest.h"
 #include "model/UpdateGatewayRouteHTTPRewriteResult.h"
+#include "model/UpdateGatewayRouteHeaderOpRequest.h"
+#include "model/UpdateGatewayRouteHeaderOpResult.h"
+#include "model/UpdateGatewayRouteRetryRequest.h"
+#include "model/UpdateGatewayRouteRetryResult.h"
+#include "model/UpdateGatewayRouteTimeoutRequest.h"
+#include "model/UpdateGatewayRouteTimeoutResult.h"
 #include "model/UpdateGatewayServiceVersionRequest.h"
 #include "model/UpdateGatewayServiceVersionResult.h"
 #include "model/UpdateImageRequest.h"
@@ -263,6 +311,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::AddGatewayDomainResult> AddGatewayDomainOutcome;
 			typedef std::future<AddGatewayDomainOutcome> AddGatewayDomainOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::AddGatewayDomainRequest&, const AddGatewayDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddGatewayDomainAsyncHandler;
+			typedef Outcome<Error, Model::AddGatewayRouteResult> AddGatewayRouteOutcome;
+			typedef std::future<AddGatewayRouteOutcome> AddGatewayRouteOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::AddGatewayRouteRequest&, const AddGatewayRouteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddGatewayRouteAsyncHandler;
 			typedef Outcome<Error, Model::AddGatewayServiceVersionResult> AddGatewayServiceVersionOutcome;
 			typedef std::future<AddGatewayServiceVersionOutcome> AddGatewayServiceVersionOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::AddGatewayServiceVersionRequest&, const AddGatewayServiceVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddGatewayServiceVersionAsyncHandler;
@@ -278,6 +329,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::AddServiceSourceResult> AddServiceSourceOutcome;
 			typedef std::future<AddServiceSourceOutcome> AddServiceSourceOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::AddServiceSourceRequest&, const AddServiceSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddServiceSourceAsyncHandler;
+			typedef Outcome<Error, Model::ApplyGatewayRouteResult> ApplyGatewayRouteOutcome;
+			typedef std::future<ApplyGatewayRouteOutcome> ApplyGatewayRouteOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::ApplyGatewayRouteRequest&, const ApplyGatewayRouteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ApplyGatewayRouteAsyncHandler;
+			typedef Outcome<Error, Model::ApplyTagPoliciesResult> ApplyTagPoliciesOutcome;
+			typedef std::future<ApplyTagPoliciesOutcome> ApplyTagPoliciesOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::ApplyTagPoliciesRequest&, const ApplyTagPoliciesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ApplyTagPoliciesAsyncHandler;
 			typedef Outcome<Error, Model::CloneNacosConfigResult> CloneNacosConfigOutcome;
 			typedef std::future<CloneNacosConfigOutcome> CloneNacosConfigOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::CloneNacosConfigRequest&, const CloneNacosConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CloneNacosConfigAsyncHandler;
@@ -302,6 +359,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateNacosServiceResult> CreateNacosServiceOutcome;
 			typedef std::future<CreateNacosServiceOutcome> CreateNacosServiceOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::CreateNacosServiceRequest&, const CreateNacosServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateNacosServiceAsyncHandler;
+			typedef Outcome<Error, Model::CreateOrUpdateSwimmingLaneResult> CreateOrUpdateSwimmingLaneOutcome;
+			typedef std::future<CreateOrUpdateSwimmingLaneOutcome> CreateOrUpdateSwimmingLaneOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::CreateOrUpdateSwimmingLaneRequest&, const CreateOrUpdateSwimmingLaneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateOrUpdateSwimmingLaneAsyncHandler;
+			typedef Outcome<Error, Model::CreateOrUpdateSwimmingLaneGroupResult> CreateOrUpdateSwimmingLaneGroupOutcome;
+			typedef std::future<CreateOrUpdateSwimmingLaneGroupOutcome> CreateOrUpdateSwimmingLaneGroupOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::CreateOrUpdateSwimmingLaneGroupRequest&, const CreateOrUpdateSwimmingLaneGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateOrUpdateSwimmingLaneGroupAsyncHandler;
 			typedef Outcome<Error, Model::CreateZnodeResult> CreateZnodeOutcome;
 			typedef std::future<CreateZnodeOutcome> CreateZnodeOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::CreateZnodeRequest&, const CreateZnodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateZnodeAsyncHandler;
@@ -323,6 +386,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteGatewayDomainResult> DeleteGatewayDomainOutcome;
 			typedef std::future<DeleteGatewayDomainOutcome> DeleteGatewayDomainOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::DeleteGatewayDomainRequest&, const DeleteGatewayDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayDomainAsyncHandler;
+			typedef Outcome<Error, Model::DeleteGatewayRouteResult> DeleteGatewayRouteOutcome;
+			typedef std::future<DeleteGatewayRouteOutcome> DeleteGatewayRouteOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::DeleteGatewayRouteRequest&, const DeleteGatewayRouteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayRouteAsyncHandler;
 			typedef Outcome<Error, Model::DeleteGatewayServiceVersionResult> DeleteGatewayServiceVersionOutcome;
 			typedef std::future<DeleteGatewayServiceVersionOutcome> DeleteGatewayServiceVersionOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::DeleteGatewayServiceVersionRequest&, const DeleteGatewayServiceVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayServiceVersionAsyncHandler;
@@ -335,12 +401,21 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteNacosConfigsResult> DeleteNacosConfigsOutcome;
 			typedef std::future<DeleteNacosConfigsOutcome> DeleteNacosConfigsOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::DeleteNacosConfigsRequest&, const DeleteNacosConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteNacosConfigsAsyncHandler;
+			typedef Outcome<Error, Model::DeleteNacosInstanceResult> DeleteNacosInstanceOutcome;
+			typedef std::future<DeleteNacosInstanceOutcome> DeleteNacosInstanceOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::DeleteNacosInstanceRequest&, const DeleteNacosInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteNacosInstanceAsyncHandler;
 			typedef Outcome<Error, Model::DeleteNacosServiceResult> DeleteNacosServiceOutcome;
 			typedef std::future<DeleteNacosServiceOutcome> DeleteNacosServiceOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::DeleteNacosServiceRequest&, const DeleteNacosServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteNacosServiceAsyncHandler;
 			typedef Outcome<Error, Model::DeleteServiceSourceResult> DeleteServiceSourceOutcome;
 			typedef std::future<DeleteServiceSourceOutcome> DeleteServiceSourceOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::DeleteServiceSourceRequest&, const DeleteServiceSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteServiceSourceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteSwimmingLaneResult> DeleteSwimmingLaneOutcome;
+			typedef std::future<DeleteSwimmingLaneOutcome> DeleteSwimmingLaneOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::DeleteSwimmingLaneRequest&, const DeleteSwimmingLaneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSwimmingLaneAsyncHandler;
+			typedef Outcome<Error, Model::DeleteSwimmingLaneGroupResult> DeleteSwimmingLaneGroupOutcome;
+			typedef std::future<DeleteSwimmingLaneGroupOutcome> DeleteSwimmingLaneGroupOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::DeleteSwimmingLaneGroupRequest&, const DeleteSwimmingLaneGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSwimmingLaneGroupAsyncHandler;
 			typedef Outcome<Error, Model::DeleteZnodeResult> DeleteZnodeOutcome;
 			typedef std::future<DeleteZnodeOutcome> DeleteZnodeOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::DeleteZnodeRequest&, const DeleteZnodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteZnodeAsyncHandler;
@@ -362,6 +437,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetGatewayOptionResult> GetGatewayOptionOutcome;
 			typedef std::future<GetGatewayOptionOutcome> GetGatewayOptionOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::GetGatewayOptionRequest&, const GetGatewayOptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetGatewayOptionAsyncHandler;
+			typedef Outcome<Error, Model::GetGatewayRouteDetailResult> GetGatewayRouteDetailOutcome;
+			typedef std::future<GetGatewayRouteDetailOutcome> GetGatewayRouteDetailOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::GetGatewayRouteDetailRequest&, const GetGatewayRouteDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetGatewayRouteDetailAsyncHandler;
 			typedef Outcome<Error, Model::GetGatewayServiceDetailResult> GetGatewayServiceDetailOutcome;
 			typedef std::future<GetGatewayServiceDetailOutcome> GetGatewayServiceDetailOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::GetGatewayServiceDetailRequest&, const GetGatewayServiceDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetGatewayServiceDetailAsyncHandler;
@@ -395,6 +473,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetOverviewResult> GetOverviewOutcome;
 			typedef std::future<GetOverviewOutcome> GetOverviewOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::GetOverviewRequest&, const GetOverviewOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetOverviewAsyncHandler;
+			typedef Outcome<Error, Model::GetServiceListResult> GetServiceListOutcome;
+			typedef std::future<GetServiceListOutcome> GetServiceListOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::GetServiceListRequest&, const GetServiceListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetServiceListAsyncHandler;
+			typedef Outcome<Error, Model::GetTagsBySwimmingLaneGroupIdResult> GetTagsBySwimmingLaneGroupIdOutcome;
+			typedef std::future<GetTagsBySwimmingLaneGroupIdOutcome> GetTagsBySwimmingLaneGroupIdOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::GetTagsBySwimmingLaneGroupIdRequest&, const GetTagsBySwimmingLaneGroupIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTagsBySwimmingLaneGroupIdAsyncHandler;
 			typedef Outcome<Error, Model::ImportNacosConfigResult> ImportNacosConfigOutcome;
 			typedef std::future<ImportNacosConfigOutcome> ImportNacosConfigOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ImportNacosConfigRequest&, const ImportNacosConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImportNacosConfigAsyncHandler;
@@ -422,6 +506,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListAnsServicesResult> ListAnsServicesOutcome;
 			typedef std::future<ListAnsServicesOutcome> ListAnsServicesOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ListAnsServicesRequest&, const ListAnsServicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAnsServicesAsyncHandler;
+			typedef Outcome<Error, Model::ListAppBySwimmingLaneGroupTagResult> ListAppBySwimmingLaneGroupTagOutcome;
+			typedef std::future<ListAppBySwimmingLaneGroupTagOutcome> ListAppBySwimmingLaneGroupTagOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::ListAppBySwimmingLaneGroupTagRequest&, const ListAppBySwimmingLaneGroupTagOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAppBySwimmingLaneGroupTagAsyncHandler;
+			typedef Outcome<Error, Model::ListApplicationsWithTagRulesResult> ListApplicationsWithTagRulesOutcome;
+			typedef std::future<ListApplicationsWithTagRulesOutcome> ListApplicationsWithTagRulesOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::ListApplicationsWithTagRulesRequest&, const ListApplicationsWithTagRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListApplicationsWithTagRulesAsyncHandler;
 			typedef Outcome<Error, Model::ListClusterConnectionTypesResult> ListClusterConnectionTypesOutcome;
 			typedef std::future<ListClusterConnectionTypesOutcome> ListClusterConnectionTypesOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ListClusterConnectionTypesRequest&, const ListClusterConnectionTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListClusterConnectionTypesAsyncHandler;
@@ -449,6 +539,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListGatewayDomainResult> ListGatewayDomainOutcome;
 			typedef std::future<ListGatewayDomainOutcome> ListGatewayDomainOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ListGatewayDomainRequest&, const ListGatewayDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListGatewayDomainAsyncHandler;
+			typedef Outcome<Error, Model::ListGatewayRouteResult> ListGatewayRouteOutcome;
+			typedef std::future<ListGatewayRouteOutcome> ListGatewayRouteOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::ListGatewayRouteRequest&, const ListGatewayRouteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListGatewayRouteAsyncHandler;
 			typedef Outcome<Error, Model::ListGatewayServiceResult> ListGatewayServiceOutcome;
 			typedef std::future<ListGatewayServiceOutcome> ListGatewayServiceOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ListGatewayServiceRequest&, const ListGatewayServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListGatewayServiceAsyncHandler;
@@ -479,9 +572,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ModifyGovernanceKubernetesClusterResult> ModifyGovernanceKubernetesClusterOutcome;
 			typedef std::future<ModifyGovernanceKubernetesClusterOutcome> ModifyGovernanceKubernetesClusterOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ModifyGovernanceKubernetesClusterRequest&, const ModifyGovernanceKubernetesClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyGovernanceKubernetesClusterAsyncHandler;
+			typedef Outcome<Error, Model::OfflineGatewayRouteResult> OfflineGatewayRouteOutcome;
+			typedef std::future<OfflineGatewayRouteOutcome> OfflineGatewayRouteOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::OfflineGatewayRouteRequest&, const OfflineGatewayRouteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> OfflineGatewayRouteAsyncHandler;
 			typedef Outcome<Error, Model::PullServicesResult> PullServicesOutcome;
 			typedef std::future<PullServicesOutcome> PullServicesOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::PullServicesRequest&, const PullServicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PullServicesAsyncHandler;
+			typedef Outcome<Error, Model::QueryAllSwimmingLaneResult> QueryAllSwimmingLaneOutcome;
+			typedef std::future<QueryAllSwimmingLaneOutcome> QueryAllSwimmingLaneOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::QueryAllSwimmingLaneRequest&, const QueryAllSwimmingLaneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryAllSwimmingLaneAsyncHandler;
+			typedef Outcome<Error, Model::QueryAllSwimmingLaneGroupResult> QueryAllSwimmingLaneGroupOutcome;
+			typedef std::future<QueryAllSwimmingLaneGroupOutcome> QueryAllSwimmingLaneGroupOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::QueryAllSwimmingLaneGroupRequest&, const QueryAllSwimmingLaneGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryAllSwimmingLaneGroupAsyncHandler;
 			typedef Outcome<Error, Model::QueryBusinessLocationsResult> QueryBusinessLocationsOutcome;
 			typedef std::future<QueryBusinessLocationsOutcome> QueryBusinessLocationsOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::QueryBusinessLocationsRequest&, const QueryBusinessLocationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryBusinessLocationsAsyncHandler;
@@ -512,6 +614,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::QuerySlbSpecResult> QuerySlbSpecOutcome;
 			typedef std::future<QuerySlbSpecOutcome> QuerySlbSpecOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::QuerySlbSpecRequest&, const QuerySlbSpecOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QuerySlbSpecAsyncHandler;
+			typedef Outcome<Error, Model::QuerySwimmingLaneByIdResult> QuerySwimmingLaneByIdOutcome;
+			typedef std::future<QuerySwimmingLaneByIdOutcome> QuerySwimmingLaneByIdOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::QuerySwimmingLaneByIdRequest&, const QuerySwimmingLaneByIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QuerySwimmingLaneByIdAsyncHandler;
 			typedef Outcome<Error, Model::QueryZnodeDetailResult> QueryZnodeDetailOutcome;
 			typedef std::future<QueryZnodeDetailOutcome> QueryZnodeDetailOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::QueryZnodeDetailRequest&, const QueryZnodeDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryZnodeDetailAsyncHandler;
@@ -551,9 +656,24 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateGatewayOptionResult> UpdateGatewayOptionOutcome;
 			typedef std::future<UpdateGatewayOptionOutcome> UpdateGatewayOptionOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::UpdateGatewayOptionRequest&, const UpdateGatewayOptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayOptionAsyncHandler;
+			typedef Outcome<Error, Model::UpdateGatewayRouteResult> UpdateGatewayRouteOutcome;
+			typedef std::future<UpdateGatewayRouteOutcome> UpdateGatewayRouteOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::UpdateGatewayRouteRequest&, const UpdateGatewayRouteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayRouteAsyncHandler;
+			typedef Outcome<Error, Model::UpdateGatewayRouteCORSResult> UpdateGatewayRouteCORSOutcome;
+			typedef std::future<UpdateGatewayRouteCORSOutcome> UpdateGatewayRouteCORSOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::UpdateGatewayRouteCORSRequest&, const UpdateGatewayRouteCORSOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayRouteCORSAsyncHandler;
 			typedef Outcome<Error, Model::UpdateGatewayRouteHTTPRewriteResult> UpdateGatewayRouteHTTPRewriteOutcome;
 			typedef std::future<UpdateGatewayRouteHTTPRewriteOutcome> UpdateGatewayRouteHTTPRewriteOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::UpdateGatewayRouteHTTPRewriteRequest&, const UpdateGatewayRouteHTTPRewriteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayRouteHTTPRewriteAsyncHandler;
+			typedef Outcome<Error, Model::UpdateGatewayRouteHeaderOpResult> UpdateGatewayRouteHeaderOpOutcome;
+			typedef std::future<UpdateGatewayRouteHeaderOpOutcome> UpdateGatewayRouteHeaderOpOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::UpdateGatewayRouteHeaderOpRequest&, const UpdateGatewayRouteHeaderOpOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayRouteHeaderOpAsyncHandler;
+			typedef Outcome<Error, Model::UpdateGatewayRouteRetryResult> UpdateGatewayRouteRetryOutcome;
+			typedef std::future<UpdateGatewayRouteRetryOutcome> UpdateGatewayRouteRetryOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::UpdateGatewayRouteRetryRequest&, const UpdateGatewayRouteRetryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayRouteRetryAsyncHandler;
+			typedef Outcome<Error, Model::UpdateGatewayRouteTimeoutResult> UpdateGatewayRouteTimeoutOutcome;
+			typedef std::future<UpdateGatewayRouteTimeoutOutcome> UpdateGatewayRouteTimeoutOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::UpdateGatewayRouteTimeoutRequest&, const UpdateGatewayRouteTimeoutOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayRouteTimeoutAsyncHandler;
 			typedef Outcome<Error, Model::UpdateGatewayServiceVersionResult> UpdateGatewayServiceVersionOutcome;
 			typedef std::future<UpdateGatewayServiceVersionOutcome> UpdateGatewayServiceVersionOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::UpdateGatewayServiceVersionRequest&, const UpdateGatewayServiceVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayServiceVersionAsyncHandler;
@@ -598,6 +718,9 @@ namespace AlibabaCloud
 			AddGatewayDomainOutcome addGatewayDomain(const Model::AddGatewayDomainRequest &request)const;
 			void addGatewayDomainAsync(const Model::AddGatewayDomainRequest& request, const AddGatewayDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddGatewayDomainOutcomeCallable addGatewayDomainCallable(const Model::AddGatewayDomainRequest& request) const;
+			AddGatewayRouteOutcome addGatewayRoute(const Model::AddGatewayRouteRequest &request)const;
+			void addGatewayRouteAsync(const Model::AddGatewayRouteRequest& request, const AddGatewayRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddGatewayRouteOutcomeCallable addGatewayRouteCallable(const Model::AddGatewayRouteRequest& request) const;
 			AddGatewayServiceVersionOutcome addGatewayServiceVersion(const Model::AddGatewayServiceVersionRequest &request)const;
 			void addGatewayServiceVersionAsync(const Model::AddGatewayServiceVersionRequest& request, const AddGatewayServiceVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddGatewayServiceVersionOutcomeCallable addGatewayServiceVersionCallable(const Model::AddGatewayServiceVersionRequest& request) const;
@@ -613,6 +736,12 @@ namespace AlibabaCloud
 			AddServiceSourceOutcome addServiceSource(const Model::AddServiceSourceRequest &request)const;
 			void addServiceSourceAsync(const Model::AddServiceSourceRequest& request, const AddServiceSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddServiceSourceOutcomeCallable addServiceSourceCallable(const Model::AddServiceSourceRequest& request) const;
+			ApplyGatewayRouteOutcome applyGatewayRoute(const Model::ApplyGatewayRouteRequest &request)const;
+			void applyGatewayRouteAsync(const Model::ApplyGatewayRouteRequest& request, const ApplyGatewayRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ApplyGatewayRouteOutcomeCallable applyGatewayRouteCallable(const Model::ApplyGatewayRouteRequest& request) const;
+			ApplyTagPoliciesOutcome applyTagPolicies(const Model::ApplyTagPoliciesRequest &request)const;
+			void applyTagPoliciesAsync(const Model::ApplyTagPoliciesRequest& request, const ApplyTagPoliciesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ApplyTagPoliciesOutcomeCallable applyTagPoliciesCallable(const Model::ApplyTagPoliciesRequest& request) const;
 			CloneNacosConfigOutcome cloneNacosConfig(const Model::CloneNacosConfigRequest &request)const;
 			void cloneNacosConfigAsync(const Model::CloneNacosConfigRequest& request, const CloneNacosConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CloneNacosConfigOutcomeCallable cloneNacosConfigCallable(const Model::CloneNacosConfigRequest& request) const;
@@ -637,6 +766,12 @@ namespace AlibabaCloud
 			CreateNacosServiceOutcome createNacosService(const Model::CreateNacosServiceRequest &request)const;
 			void createNacosServiceAsync(const Model::CreateNacosServiceRequest& request, const CreateNacosServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateNacosServiceOutcomeCallable createNacosServiceCallable(const Model::CreateNacosServiceRequest& request) const;
+			CreateOrUpdateSwimmingLaneOutcome createOrUpdateSwimmingLane(const Model::CreateOrUpdateSwimmingLaneRequest &request)const;
+			void createOrUpdateSwimmingLaneAsync(const Model::CreateOrUpdateSwimmingLaneRequest& request, const CreateOrUpdateSwimmingLaneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateOrUpdateSwimmingLaneOutcomeCallable createOrUpdateSwimmingLaneCallable(const Model::CreateOrUpdateSwimmingLaneRequest& request) const;
+			CreateOrUpdateSwimmingLaneGroupOutcome createOrUpdateSwimmingLaneGroup(const Model::CreateOrUpdateSwimmingLaneGroupRequest &request)const;
+			void createOrUpdateSwimmingLaneGroupAsync(const Model::CreateOrUpdateSwimmingLaneGroupRequest& request, const CreateOrUpdateSwimmingLaneGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateOrUpdateSwimmingLaneGroupOutcomeCallable createOrUpdateSwimmingLaneGroupCallable(const Model::CreateOrUpdateSwimmingLaneGroupRequest& request) const;
 			CreateZnodeOutcome createZnode(const Model::CreateZnodeRequest &request)const;
 			void createZnodeAsync(const Model::CreateZnodeRequest& request, const CreateZnodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateZnodeOutcomeCallable createZnodeCallable(const Model::CreateZnodeRequest& request) const;
@@ -658,6 +793,9 @@ namespace AlibabaCloud
 			DeleteGatewayDomainOutcome deleteGatewayDomain(const Model::DeleteGatewayDomainRequest &request)const;
 			void deleteGatewayDomainAsync(const Model::DeleteGatewayDomainRequest& request, const DeleteGatewayDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteGatewayDomainOutcomeCallable deleteGatewayDomainCallable(const Model::DeleteGatewayDomainRequest& request) const;
+			DeleteGatewayRouteOutcome deleteGatewayRoute(const Model::DeleteGatewayRouteRequest &request)const;
+			void deleteGatewayRouteAsync(const Model::DeleteGatewayRouteRequest& request, const DeleteGatewayRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteGatewayRouteOutcomeCallable deleteGatewayRouteCallable(const Model::DeleteGatewayRouteRequest& request) const;
 			DeleteGatewayServiceVersionOutcome deleteGatewayServiceVersion(const Model::DeleteGatewayServiceVersionRequest &request)const;
 			void deleteGatewayServiceVersionAsync(const Model::DeleteGatewayServiceVersionRequest& request, const DeleteGatewayServiceVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteGatewayServiceVersionOutcomeCallable deleteGatewayServiceVersionCallable(const Model::DeleteGatewayServiceVersionRequest& request) const;
@@ -670,12 +808,21 @@ namespace AlibabaCloud
 			DeleteNacosConfigsOutcome deleteNacosConfigs(const Model::DeleteNacosConfigsRequest &request)const;
 			void deleteNacosConfigsAsync(const Model::DeleteNacosConfigsRequest& request, const DeleteNacosConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteNacosConfigsOutcomeCallable deleteNacosConfigsCallable(const Model::DeleteNacosConfigsRequest& request) const;
+			DeleteNacosInstanceOutcome deleteNacosInstance(const Model::DeleteNacosInstanceRequest &request)const;
+			void deleteNacosInstanceAsync(const Model::DeleteNacosInstanceRequest& request, const DeleteNacosInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteNacosInstanceOutcomeCallable deleteNacosInstanceCallable(const Model::DeleteNacosInstanceRequest& request) const;
 			DeleteNacosServiceOutcome deleteNacosService(const Model::DeleteNacosServiceRequest &request)const;
 			void deleteNacosServiceAsync(const Model::DeleteNacosServiceRequest& request, const DeleteNacosServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteNacosServiceOutcomeCallable deleteNacosServiceCallable(const Model::DeleteNacosServiceRequest& request) const;
 			DeleteServiceSourceOutcome deleteServiceSource(const Model::DeleteServiceSourceRequest &request)const;
 			void deleteServiceSourceAsync(const Model::DeleteServiceSourceRequest& request, const DeleteServiceSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteServiceSourceOutcomeCallable deleteServiceSourceCallable(const Model::DeleteServiceSourceRequest& request) const;
+			DeleteSwimmingLaneOutcome deleteSwimmingLane(const Model::DeleteSwimmingLaneRequest &request)const;
+			void deleteSwimmingLaneAsync(const Model::DeleteSwimmingLaneRequest& request, const DeleteSwimmingLaneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteSwimmingLaneOutcomeCallable deleteSwimmingLaneCallable(const Model::DeleteSwimmingLaneRequest& request) const;
+			DeleteSwimmingLaneGroupOutcome deleteSwimmingLaneGroup(const Model::DeleteSwimmingLaneGroupRequest &request)const;
+			void deleteSwimmingLaneGroupAsync(const Model::DeleteSwimmingLaneGroupRequest& request, const DeleteSwimmingLaneGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteSwimmingLaneGroupOutcomeCallable deleteSwimmingLaneGroupCallable(const Model::DeleteSwimmingLaneGroupRequest& request) const;
 			DeleteZnodeOutcome deleteZnode(const Model::DeleteZnodeRequest &request)const;
 			void deleteZnodeAsync(const Model::DeleteZnodeRequest& request, const DeleteZnodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteZnodeOutcomeCallable deleteZnodeCallable(const Model::DeleteZnodeRequest& request) const;
@@ -697,6 +844,9 @@ namespace AlibabaCloud
 			GetGatewayOptionOutcome getGatewayOption(const Model::GetGatewayOptionRequest &request)const;
 			void getGatewayOptionAsync(const Model::GetGatewayOptionRequest& request, const GetGatewayOptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetGatewayOptionOutcomeCallable getGatewayOptionCallable(const Model::GetGatewayOptionRequest& request) const;
+			GetGatewayRouteDetailOutcome getGatewayRouteDetail(const Model::GetGatewayRouteDetailRequest &request)const;
+			void getGatewayRouteDetailAsync(const Model::GetGatewayRouteDetailRequest& request, const GetGatewayRouteDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetGatewayRouteDetailOutcomeCallable getGatewayRouteDetailCallable(const Model::GetGatewayRouteDetailRequest& request) const;
 			GetGatewayServiceDetailOutcome getGatewayServiceDetail(const Model::GetGatewayServiceDetailRequest &request)const;
 			void getGatewayServiceDetailAsync(const Model::GetGatewayServiceDetailRequest& request, const GetGatewayServiceDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetGatewayServiceDetailOutcomeCallable getGatewayServiceDetailCallable(const Model::GetGatewayServiceDetailRequest& request) const;
@@ -730,6 +880,12 @@ namespace AlibabaCloud
 			GetOverviewOutcome getOverview(const Model::GetOverviewRequest &request)const;
 			void getOverviewAsync(const Model::GetOverviewRequest& request, const GetOverviewAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetOverviewOutcomeCallable getOverviewCallable(const Model::GetOverviewRequest& request) const;
+			GetServiceListOutcome getServiceList(const Model::GetServiceListRequest &request)const;
+			void getServiceListAsync(const Model::GetServiceListRequest& request, const GetServiceListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetServiceListOutcomeCallable getServiceListCallable(const Model::GetServiceListRequest& request) const;
+			GetTagsBySwimmingLaneGroupIdOutcome getTagsBySwimmingLaneGroupId(const Model::GetTagsBySwimmingLaneGroupIdRequest &request)const;
+			void getTagsBySwimmingLaneGroupIdAsync(const Model::GetTagsBySwimmingLaneGroupIdRequest& request, const GetTagsBySwimmingLaneGroupIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetTagsBySwimmingLaneGroupIdOutcomeCallable getTagsBySwimmingLaneGroupIdCallable(const Model::GetTagsBySwimmingLaneGroupIdRequest& request) const;
 			ImportNacosConfigOutcome importNacosConfig(const Model::ImportNacosConfigRequest &request)const;
 			void importNacosConfigAsync(const Model::ImportNacosConfigRequest& request, const ImportNacosConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ImportNacosConfigOutcomeCallable importNacosConfigCallable(const Model::ImportNacosConfigRequest& request) const;
@@ -757,6 +913,12 @@ namespace AlibabaCloud
 			ListAnsServicesOutcome listAnsServices(const Model::ListAnsServicesRequest &request)const;
 			void listAnsServicesAsync(const Model::ListAnsServicesRequest& request, const ListAnsServicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListAnsServicesOutcomeCallable listAnsServicesCallable(const Model::ListAnsServicesRequest& request) const;
+			ListAppBySwimmingLaneGroupTagOutcome listAppBySwimmingLaneGroupTag(const Model::ListAppBySwimmingLaneGroupTagRequest &request)const;
+			void listAppBySwimmingLaneGroupTagAsync(const Model::ListAppBySwimmingLaneGroupTagRequest& request, const ListAppBySwimmingLaneGroupTagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAppBySwimmingLaneGroupTagOutcomeCallable listAppBySwimmingLaneGroupTagCallable(const Model::ListAppBySwimmingLaneGroupTagRequest& request) const;
+			ListApplicationsWithTagRulesOutcome listApplicationsWithTagRules(const Model::ListApplicationsWithTagRulesRequest &request)const;
+			void listApplicationsWithTagRulesAsync(const Model::ListApplicationsWithTagRulesRequest& request, const ListApplicationsWithTagRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListApplicationsWithTagRulesOutcomeCallable listApplicationsWithTagRulesCallable(const Model::ListApplicationsWithTagRulesRequest& request) const;
 			ListClusterConnectionTypesOutcome listClusterConnectionTypes(const Model::ListClusterConnectionTypesRequest &request)const;
 			void listClusterConnectionTypesAsync(const Model::ListClusterConnectionTypesRequest& request, const ListClusterConnectionTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListClusterConnectionTypesOutcomeCallable listClusterConnectionTypesCallable(const Model::ListClusterConnectionTypesRequest& request) const;
@@ -784,6 +946,9 @@ namespace AlibabaCloud
 			ListGatewayDomainOutcome listGatewayDomain(const Model::ListGatewayDomainRequest &request)const;
 			void listGatewayDomainAsync(const Model::ListGatewayDomainRequest& request, const ListGatewayDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListGatewayDomainOutcomeCallable listGatewayDomainCallable(const Model::ListGatewayDomainRequest& request) const;
+			ListGatewayRouteOutcome listGatewayRoute(const Model::ListGatewayRouteRequest &request)const;
+			void listGatewayRouteAsync(const Model::ListGatewayRouteRequest& request, const ListGatewayRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListGatewayRouteOutcomeCallable listGatewayRouteCallable(const Model::ListGatewayRouteRequest& request) const;
 			ListGatewayServiceOutcome listGatewayService(const Model::ListGatewayServiceRequest &request)const;
 			void listGatewayServiceAsync(const Model::ListGatewayServiceRequest& request, const ListGatewayServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListGatewayServiceOutcomeCallable listGatewayServiceCallable(const Model::ListGatewayServiceRequest& request) const;
@@ -814,9 +979,18 @@ namespace AlibabaCloud
 			ModifyGovernanceKubernetesClusterOutcome modifyGovernanceKubernetesCluster(const Model::ModifyGovernanceKubernetesClusterRequest &request)const;
 			void modifyGovernanceKubernetesClusterAsync(const Model::ModifyGovernanceKubernetesClusterRequest& request, const ModifyGovernanceKubernetesClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyGovernanceKubernetesClusterOutcomeCallable modifyGovernanceKubernetesClusterCallable(const Model::ModifyGovernanceKubernetesClusterRequest& request) const;
+			OfflineGatewayRouteOutcome offlineGatewayRoute(const Model::OfflineGatewayRouteRequest &request)const;
+			void offlineGatewayRouteAsync(const Model::OfflineGatewayRouteRequest& request, const OfflineGatewayRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			OfflineGatewayRouteOutcomeCallable offlineGatewayRouteCallable(const Model::OfflineGatewayRouteRequest& request) const;
 			PullServicesOutcome pullServices(const Model::PullServicesRequest &request)const;
 			void pullServicesAsync(const Model::PullServicesRequest& request, const PullServicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			PullServicesOutcomeCallable pullServicesCallable(const Model::PullServicesRequest& request) const;
+			QueryAllSwimmingLaneOutcome queryAllSwimmingLane(const Model::QueryAllSwimmingLaneRequest &request)const;
+			void queryAllSwimmingLaneAsync(const Model::QueryAllSwimmingLaneRequest& request, const QueryAllSwimmingLaneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryAllSwimmingLaneOutcomeCallable queryAllSwimmingLaneCallable(const Model::QueryAllSwimmingLaneRequest& request) const;
+			QueryAllSwimmingLaneGroupOutcome queryAllSwimmingLaneGroup(const Model::QueryAllSwimmingLaneGroupRequest &request)const;
+			void queryAllSwimmingLaneGroupAsync(const Model::QueryAllSwimmingLaneGroupRequest& request, const QueryAllSwimmingLaneGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryAllSwimmingLaneGroupOutcomeCallable queryAllSwimmingLaneGroupCallable(const Model::QueryAllSwimmingLaneGroupRequest& request) const;
 			QueryBusinessLocationsOutcome queryBusinessLocations(const Model::QueryBusinessLocationsRequest &request)const;
 			void queryBusinessLocationsAsync(const Model::QueryBusinessLocationsRequest& request, const QueryBusinessLocationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryBusinessLocationsOutcomeCallable queryBusinessLocationsCallable(const Model::QueryBusinessLocationsRequest& request) const;
@@ -847,6 +1021,9 @@ namespace AlibabaCloud
 			QuerySlbSpecOutcome querySlbSpec(const Model::QuerySlbSpecRequest &request)const;
 			void querySlbSpecAsync(const Model::QuerySlbSpecRequest& request, const QuerySlbSpecAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QuerySlbSpecOutcomeCallable querySlbSpecCallable(const Model::QuerySlbSpecRequest& request) const;
+			QuerySwimmingLaneByIdOutcome querySwimmingLaneById(const Model::QuerySwimmingLaneByIdRequest &request)const;
+			void querySwimmingLaneByIdAsync(const Model::QuerySwimmingLaneByIdRequest& request, const QuerySwimmingLaneByIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QuerySwimmingLaneByIdOutcomeCallable querySwimmingLaneByIdCallable(const Model::QuerySwimmingLaneByIdRequest& request) const;
 			QueryZnodeDetailOutcome queryZnodeDetail(const Model::QueryZnodeDetailRequest &request)const;
 			void queryZnodeDetailAsync(const Model::QueryZnodeDetailRequest& request, const QueryZnodeDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryZnodeDetailOutcomeCallable queryZnodeDetailCallable(const Model::QueryZnodeDetailRequest& request) const;
@@ -886,9 +1063,24 @@ namespace AlibabaCloud
 			UpdateGatewayOptionOutcome updateGatewayOption(const Model::UpdateGatewayOptionRequest &request)const;
 			void updateGatewayOptionAsync(const Model::UpdateGatewayOptionRequest& request, const UpdateGatewayOptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateGatewayOptionOutcomeCallable updateGatewayOptionCallable(const Model::UpdateGatewayOptionRequest& request) const;
+			UpdateGatewayRouteOutcome updateGatewayRoute(const Model::UpdateGatewayRouteRequest &request)const;
+			void updateGatewayRouteAsync(const Model::UpdateGatewayRouteRequest& request, const UpdateGatewayRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateGatewayRouteOutcomeCallable updateGatewayRouteCallable(const Model::UpdateGatewayRouteRequest& request) const;
+			UpdateGatewayRouteCORSOutcome updateGatewayRouteCORS(const Model::UpdateGatewayRouteCORSRequest &request)const;
+			void updateGatewayRouteCORSAsync(const Model::UpdateGatewayRouteCORSRequest& request, const UpdateGatewayRouteCORSAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateGatewayRouteCORSOutcomeCallable updateGatewayRouteCORSCallable(const Model::UpdateGatewayRouteCORSRequest& request) const;
 			UpdateGatewayRouteHTTPRewriteOutcome updateGatewayRouteHTTPRewrite(const Model::UpdateGatewayRouteHTTPRewriteRequest &request)const;
 			void updateGatewayRouteHTTPRewriteAsync(const Model::UpdateGatewayRouteHTTPRewriteRequest& request, const UpdateGatewayRouteHTTPRewriteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateGatewayRouteHTTPRewriteOutcomeCallable updateGatewayRouteHTTPRewriteCallable(const Model::UpdateGatewayRouteHTTPRewriteRequest& request) const;
+			UpdateGatewayRouteHeaderOpOutcome updateGatewayRouteHeaderOp(const Model::UpdateGatewayRouteHeaderOpRequest &request)const;
+			void updateGatewayRouteHeaderOpAsync(const Model::UpdateGatewayRouteHeaderOpRequest& request, const UpdateGatewayRouteHeaderOpAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateGatewayRouteHeaderOpOutcomeCallable updateGatewayRouteHeaderOpCallable(const Model::UpdateGatewayRouteHeaderOpRequest& request) const;
+			UpdateGatewayRouteRetryOutcome updateGatewayRouteRetry(const Model::UpdateGatewayRouteRetryRequest &request)const;
+			void updateGatewayRouteRetryAsync(const Model::UpdateGatewayRouteRetryRequest& request, const UpdateGatewayRouteRetryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateGatewayRouteRetryOutcomeCallable updateGatewayRouteRetryCallable(const Model::UpdateGatewayRouteRetryRequest& request) const;
+			UpdateGatewayRouteTimeoutOutcome updateGatewayRouteTimeout(const Model::UpdateGatewayRouteTimeoutRequest &request)const;
+			void updateGatewayRouteTimeoutAsync(const Model::UpdateGatewayRouteTimeoutRequest& request, const UpdateGatewayRouteTimeoutAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateGatewayRouteTimeoutOutcomeCallable updateGatewayRouteTimeoutCallable(const Model::UpdateGatewayRouteTimeoutRequest& request) const;
 			UpdateGatewayServiceVersionOutcome updateGatewayServiceVersion(const Model::UpdateGatewayServiceVersionRequest &request)const;
 			void updateGatewayServiceVersionAsync(const Model::UpdateGatewayServiceVersionRequest& request, const UpdateGatewayServiceVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateGatewayServiceVersionOutcomeCallable updateGatewayServiceVersionCallable(const Model::UpdateGatewayServiceVersionRequest& request) const;

mse/include/alibabacloud/mse/model/AddGatewayRouteRequest.h

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_ADDGATEWAYROUTEREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_ADDGATEWAYROUTEREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT AddGatewayRouteRequest : public RpcServiceRequest {
+public:
+	struct Services {
+		std::string name;
+		std::string _namespace;
+		std::string sourceType;
+		long serviceId;
+		int percent;
+		std::string version;
+		std::string groupName;
+	};
+	struct Predicates {
+		struct PathPredicates {
+			std::string path;
+			bool ignoreCase;
+			std::string type;
+		};
+		PathPredicates pathPredicates;
+		std::string string;
+		std::vector<std::string> methodPredicates;
+		struct HeaderPredicatesItem {
+			std::string type;
+			std::string value;
+			std::string key;
+		};
+		HeaderPredicatesItem headerPredicatesItem;
+		std::vector<HeaderPredicatesItem> headerPredicates;
+		struct QueryPredicatesItem {
+			std::string type;
+			std::string value;
+			std::string key;
+		};
+		QueryPredicatesItem queryPredicatesItem;
+		std::vector<QueryPredicatesItem> queryPredicates;
+	};
+	struct RedirectJSON {
+		std::string path;
+		int code;
+		std::string host;
+	};
+	struct DirectResponseJSON {
+		long code;
+		std::string body;
+	};
+	AddGatewayRouteRequest();
+	~AddGatewayRouteRequest();
+	std::string getGatewayUniqueId() const;
+	void setGatewayUniqueId(const std::string &gatewayUniqueId);
+	std::string getDestinationType() const;
+	void setDestinationType(const std::string &destinationType);
+	std::string getDomainIdListJSON() const;
+	void setDomainIdListJSON(const std::string &domainIdListJSON);
+	long getDomainId() const;
+	void setDomainId(long domainId);
+	long getGatewayId() const;
+	void setGatewayId(long gatewayId);
+	int getRouteOrder() const;
+	void setRouteOrder(int routeOrder);
+	std::vector<Services> getServices() const;
+	void setServices(const std::vector<Services> &services);
+	Predicates getPredicates() const;
+	void setPredicates(const Predicates &predicates);
+	RedirectJSON getRedirectJSON() const;
+	void setRedirectJSON(const RedirectJSON &redirectJSON);
+	DirectResponseJSON getDirectResponseJSON() const;
+	void setDirectResponseJSON(const DirectResponseJSON &directResponseJSON);
+	std::string getName() const;
+	void setName(const std::string &name);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	std::string gatewayUniqueId_;
+	std::string destinationType_;
+	std::string domainIdListJSON_;
+	long domainId_;
+	long gatewayId_;
+	int routeOrder_;
+	std::vector<Services> services_;
+	Predicates predicates_;
+	RedirectJSON redirectJSON_;
+	DirectResponseJSON directResponseJSON_;
+	std::string name_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_ADDGATEWAYROUTEREQUEST_H_

mse/include/alibabacloud/mse/model/AddGatewayRouteResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_ADDGATEWAYROUTERESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_ADDGATEWAYROUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT AddGatewayRouteResult : public ServiceResult
+			{
+			public:
+
+
+				AddGatewayRouteResult();
+				explicit AddGatewayRouteResult(const std::string &payload);
+				~AddGatewayRouteResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				long getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				long data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_ADDGATEWAYROUTERESULT_H_

mse/include/alibabacloud/mse/model/ApplyGatewayRouteRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_APPLYGATEWAYROUTEREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_APPLYGATEWAYROUTEREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT ApplyGatewayRouteRequest : public RpcServiceRequest {
+public:
+	ApplyGatewayRouteRequest();
+	~ApplyGatewayRouteRequest();
+	std::string getGatewayUniqueId() const;
+	void setGatewayUniqueId(const std::string &gatewayUniqueId);
+	std::string getRouteId() const;
+	void setRouteId(const std::string &routeId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	std::string gatewayUniqueId_;
+	std::string routeId_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_APPLYGATEWAYROUTEREQUEST_H_

mse/include/alibabacloud/mse/model/ApplyGatewayRouteResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_APPLYGATEWAYROUTERESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_APPLYGATEWAYROUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT ApplyGatewayRouteResult : public ServiceResult
+			{
+			public:
+
+
+				ApplyGatewayRouteResult();
+				explicit ApplyGatewayRouteResult(const std::string &payload);
+				~ApplyGatewayRouteResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				bool getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				bool data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_APPLYGATEWAYROUTERESULT_H_

mse/include/alibabacloud/mse/model/ApplyTagPoliciesRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_APPLYTAGPOLICIESREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_APPLYTAGPOLICIESREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT ApplyTagPoliciesRequest : public RpcServiceRequest {
+public:
+	ApplyTagPoliciesRequest();
+	~ApplyTagPoliciesRequest();
+	std::string getRules() const;
+	void setRules(const std::string &rules);
+	std::string getSource() const;
+	void setSource(const std::string &source);
+	std::string getNamespaceId() const;
+	void setNamespaceId(const std::string &namespaceId);
+	bool getEnable() const;
+	void setEnable(bool enable);
+	std::string getAppId() const;
+	void setAppId(const std::string &appId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	std::string getRegion() const;
+	void setRegion(const std::string &region);
+
+private:
+	std::string rules_;
+	std::string source_;
+	std::string namespaceId_;
+	bool enable_;
+	std::string appId_;
+	std::string acceptLanguage_;
+	std::string region_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_APPLYTAGPOLICIESREQUEST_H_

mse/include/alibabacloud/mse/model/ApplyTagPoliciesResult.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_APPLYTAGPOLICIESRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_APPLYTAGPOLICIESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT ApplyTagPoliciesResult : public ServiceResult
+			{
+			public:
+				struct RouteRuleVO
+				{
+					int status;
+					bool carryData;
+					int rate;
+					bool enable;
+					bool remove;
+					std::string tag;
+					long id;
+					std::string rules;
+					int instanceNum;
+					std::string name;
+				};
+
+
+				ApplyTagPoliciesResult();
+				explicit ApplyTagPoliciesResult(const std::string &payload);
+				~ApplyTagPoliciesResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::vector<RouteRuleVO> getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::vector<RouteRuleVO> data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_APPLYTAGPOLICIESRESULT_H_

mse/include/alibabacloud/mse/model/CreateOrUpdateSwimmingLaneGroupRequest.h

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_CREATEORUPDATESWIMMINGLANEGROUPREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_CREATEORUPDATESWIMMINGLANEGROUPREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT CreateOrUpdateSwimmingLaneGroupRequest : public RpcServiceRequest {
+public:
+	CreateOrUpdateSwimmingLaneGroupRequest();
+	~CreateOrUpdateSwimmingLaneGroupRequest();
+	std::string getSource() const;
+	void setSource(const std::string &source);
+	std::string getGmtModified() const;
+	void setGmtModified(const std::string &gmtModified);
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	std::string getLicenseKey() const;
+	void setLicenseKey(const std::string &licenseKey);
+	std::string getAppIds() const;
+	void setAppIds(const std::string &appIds);
+	bool getEnable() const;
+	void setEnable(bool enable);
+	std::string getEntryApp() const;
+	void setEntryApp(const std::string &entryApp);
+	long getId() const;
+	void setId(long id);
+	std::string getGmtCreate() const;
+	void setGmtCreate(const std::string &gmtCreate);
+	std::string getName() const;
+	void setName(const std::string &name);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	std::string getRegion() const;
+	void setRegion(const std::string &region);
+	int getStatus() const;
+	void setStatus(int status);
+
+private:
+	std::string source_;
+	std::string gmtModified_;
+	std::string userId_;
+	std::string licenseKey_;
+	std::string appIds_;
+	bool enable_;
+	std::string entryApp_;
+	long id_;
+	std::string gmtCreate_;
+	std::string name_;
+	std::string acceptLanguage_;
+	std::string region_;
+	int status_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_CREATEORUPDATESWIMMINGLANEGROUPREQUEST_H_

mse/include/alibabacloud/mse/model/CreateOrUpdateSwimmingLaneGroupResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_CREATEORUPDATESWIMMINGLANEGROUPRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_CREATEORUPDATESWIMMINGLANEGROUPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT CreateOrUpdateSwimmingLaneGroupResult : public ServiceResult
+			{
+			public:
+
+
+				CreateOrUpdateSwimmingLaneGroupResult();
+				explicit CreateOrUpdateSwimmingLaneGroupResult(const std::string &payload);
+				~CreateOrUpdateSwimmingLaneGroupResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_CREATEORUPDATESWIMMINGLANEGROUPRESULT_H_

mse/include/alibabacloud/mse/model/CreateOrUpdateSwimmingLaneRequest.h

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_CREATEORUPDATESWIMMINGLANEREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_CREATEORUPDATESWIMMINGLANEREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT CreateOrUpdateSwimmingLaneRequest : public RpcServiceRequest {
+public:
+	struct EntryRules {
+		struct RestItems {
+			std::string datum;
+			int divisor;
+			int rate;
+			std::string name;
+			std::string type;
+			std::string cond;
+			int remainder;
+			std::string value;
+			std::string _operator;
+		};
+		std::vector<RestItems> restItems;
+		std::string path;
+		std::string condition;
+		bool enable;
+		int priority;
+	};
+	CreateOrUpdateSwimmingLaneRequest();
+	~CreateOrUpdateSwimmingLaneRequest();
+	std::string getSource() const;
+	void setSource(const std::string &source);
+	std::string getGmtModified() const;
+	void setGmtModified(const std::string &gmtModified);
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	std::string getLicenseKey() const;
+	void setLicenseKey(const std::string &licenseKey);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getEntryRule() const;
+	void setEntryRule(const std::string &entryRule);
+	bool getEnable() const;
+	void setEnable(bool enable);
+	long getId() const;
+	void setId(long id);
+	std::string getTag() const;
+	void setTag(const std::string &tag);
+	std::vector<EntryRules> getEntryRules() const;
+	void setEntryRules(const std::vector<EntryRules> &entryRules);
+	long getGroupId() const;
+	void setGroupId(long groupId);
+	std::string getGmtCreate() const;
+	void setGmtCreate(const std::string &gmtCreate);
+	bool getEnableRules() const;
+	void setEnableRules(bool enableRules);
+	std::string getName() const;
+	void setName(const std::string &name);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	int getStatus() const;
+	void setStatus(int status);
+
+private:
+	std::string source_;
+	std::string gmtModified_;
+	std::string userId_;
+	std::string licenseKey_;
+	std::string regionId_;
+	std::string entryRule_;
+	bool enable_;
+	long id_;
+	std::string tag_;
+	std::vector<EntryRules> entryRules_;
+	long groupId_;
+	std::string gmtCreate_;
+	bool enableRules_;
+	std::string name_;
+	std::string acceptLanguage_;
+	int status_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_CREATEORUPDATESWIMMINGLANEREQUEST_H_

mse/include/alibabacloud/mse/model/CreateOrUpdateSwimmingLaneResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_CREATEORUPDATESWIMMINGLANERESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_CREATEORUPDATESWIMMINGLANERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT CreateOrUpdateSwimmingLaneResult : public ServiceResult
+			{
+			public:
+
+
+				CreateOrUpdateSwimmingLaneResult();
+				explicit CreateOrUpdateSwimmingLaneResult(const std::string &payload);
+				~CreateOrUpdateSwimmingLaneResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_CREATEORUPDATESWIMMINGLANERESULT_H_

mse/include/alibabacloud/mse/model/DeleteGatewayRouteRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYROUTEREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYROUTEREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT DeleteGatewayRouteRequest : public RpcServiceRequest {
+public:
+	DeleteGatewayRouteRequest();
+	~DeleteGatewayRouteRequest();
+	std::string getGatewayUniqueId() const;
+	void setGatewayUniqueId(const std::string &gatewayUniqueId);
+	std::string getRouteId() const;
+	void setRouteId(const std::string &routeId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	std::string gatewayUniqueId_;
+	std::string routeId_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYROUTEREQUEST_H_

mse/include/alibabacloud/mse/model/DeleteGatewayRouteResult.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYROUTERESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYROUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT DeleteGatewayRouteResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					int status;
+					std::string gatewayUniqueId;
+					std::string gmtCreate;
+					int routeOrder;
+					std::string gmtModified;
+					long defaultServiceId;
+					long id;
+					long gatewayId;
+					std::string predicates;
+					std::string name;
+				};
+
+
+				DeleteGatewayRouteResult();
+				explicit DeleteGatewayRouteResult(const std::string &payload);
+				~DeleteGatewayRouteResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				Data getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				Data data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYROUTERESULT_H_

mse/include/alibabacloud/mse/model/DeleteNacosInstanceRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_DELETENACOSINSTANCEREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETENACOSINSTANCEREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT DeleteNacosInstanceRequest : public RpcServiceRequest {
+public:
+	DeleteNacosInstanceRequest();
+	~DeleteNacosInstanceRequest();
+	std::string getClusterName() const;
+	void setClusterName(const std::string &clusterName);
+	std::string getIp() const;
+	void setIp(const std::string &ip);
+	bool getEphemeral() const;
+	void setEphemeral(bool ephemeral);
+	std::string getGroupName() const;
+	void setGroupName(const std::string &groupName);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getNamespaceId() const;
+	void setNamespaceId(const std::string &namespaceId);
+	int getPort() const;
+	void setPort(int port);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	std::string getServiceName() const;
+	void setServiceName(const std::string &serviceName);
+
+private:
+	std::string clusterName_;
+	std::string ip_;
+	bool ephemeral_;
+	std::string groupName_;
+	std::string instanceId_;
+	std::string namespaceId_;
+	int port_;
+	std::string acceptLanguage_;
+	std::string serviceName_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETENACOSINSTANCEREQUEST_H_

mse/include/alibabacloud/mse/model/DeleteNacosInstanceResult.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_DELETENACOSINSTANCERESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETENACOSINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT DeleteNacosInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteNacosInstanceResult();
+				explicit DeleteNacosInstanceResult(const std::string &payload);
+				~DeleteNacosInstanceResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getData()const;
+				std::string getErrorCode()const;
+				std::string getDynamicMessage()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string data_;
+				std::string errorCode_;
+				std::string dynamicMessage_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETENACOSINSTANCERESULT_H_

mse/include/alibabacloud/mse/model/DeleteSwimmingLaneGroupRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_DELETESWIMMINGLANEGROUPREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETESWIMMINGLANEGROUPREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT DeleteSwimmingLaneGroupRequest : public RpcServiceRequest {
+public:
+	DeleteSwimmingLaneGroupRequest();
+	~DeleteSwimmingLaneGroupRequest();
+	long getGroupId() const;
+	void setGroupId(long groupId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	long groupId_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETESWIMMINGLANEGROUPREQUEST_H_

mse/include/alibabacloud/mse/model/DeleteSwimmingLaneGroupResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_DELETESWIMMINGLANEGROUPRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETESWIMMINGLANEGROUPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT DeleteSwimmingLaneGroupResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteSwimmingLaneGroupResult();
+				explicit DeleteSwimmingLaneGroupResult(const std::string &payload);
+				~DeleteSwimmingLaneGroupResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETESWIMMINGLANEGROUPRESULT_H_

mse/include/alibabacloud/mse/model/DeleteSwimmingLaneRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_DELETESWIMMINGLANEREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETESWIMMINGLANEREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT DeleteSwimmingLaneRequest : public RpcServiceRequest {
+public:
+	DeleteSwimmingLaneRequest();
+	~DeleteSwimmingLaneRequest();
+	long getLaneId() const;
+	void setLaneId(long laneId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	long laneId_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETESWIMMINGLANEREQUEST_H_

mse/include/alibabacloud/mse/model/DeleteSwimmingLaneResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_DELETESWIMMINGLANERESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETESWIMMINGLANERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT DeleteSwimmingLaneResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteSwimmingLaneResult();
+				explicit DeleteSwimmingLaneResult(const std::string &payload);
+				~DeleteSwimmingLaneResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETESWIMMINGLANERESULT_H_

mse/include/alibabacloud/mse/model/GetGatewayRouteDetailRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_GETGATEWAYROUTEDETAILREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_GETGATEWAYROUTEDETAILREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT GetGatewayRouteDetailRequest : public RpcServiceRequest {
+public:
+	GetGatewayRouteDetailRequest();
+	~GetGatewayRouteDetailRequest();
+	std::string getGatewayUniqueId() const;
+	void setGatewayUniqueId(const std::string &gatewayUniqueId);
+	long getRouteId() const;
+	void setRouteId(long routeId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	std::string gatewayUniqueId_;
+	long routeId_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_GETGATEWAYROUTEDETAILREQUEST_H_

mse/include/alibabacloud/mse/model/GetGatewayRouteDetailResult.h

@@ -0,0 +1,180 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_GETGATEWAYROUTEDETAILRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_GETGATEWAYROUTEDETAILRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT GetGatewayRouteDetailResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct RoutePredicates
+					{
+						struct PathPredicates
+						{
+							std::string path;
+							std::string type;
+							bool ignoreCase;
+						};
+						struct HeaderPredicatesItem
+						{
+							std::string type;
+							std::string value;
+							std::string key;
+						};
+						struct QueryPredicatesItem
+						{
+							std::string type;
+							std::string value;
+							std::string key;
+						};
+						std::vector<HeaderPredicatesItem> headerPredicates;
+						std::vector<std::string> methodPredicates;
+						std::vector<QueryPredicatesItem> queryPredicates;
+						PathPredicates pathPredicates;
+					};
+					struct HTTPRewrite
+					{
+						std::string status;
+						std::string path;
+						std::string pathType;
+						std::string pattern;
+						std::string substitution;
+						std::string host;
+					};
+					struct HeaderOp
+					{
+						struct HeaderOpItemsItem
+						{
+							std::string directionType;
+							std::string value;
+							std::string opType;
+							std::string key;
+						};
+						std::string status;
+						std::vector<HeaderOpItemsItem> headerOpItems;
+					};
+					struct DirectResponse
+					{
+						int code;
+						std::string body;
+					};
+					struct Cors
+					{
+						std::string status;
+						std::string allowOrigins;
+						bool allowCredentials;
+						std::string exposeHeaders;
+						long unitNum;
+						std::string allowHeaders;
+						std::string timeUnit;
+						std::string allowMethods;
+					};
+					struct Timeout
+					{
+						std::string status;
+						int unitNum;
+						std::string timeUnit;
+					};
+					struct Retry
+					{
+						std::string status;
+						std::vector<std::string> httpCodes;
+						int attempts;
+						std::vector<std::string> retryOn;
+					};
+					struct Redirect
+					{
+						std::string path;
+						std::string host;
+						int code;
+					};
+					struct RouteServicesItem
+					{
+						std::string groupName;
+						std::string serviceName;
+						int percent;
+						std::string version;
+						std::string sourceType;
+						std::string _namespace;
+						long serviceId;
+						std::string name;
+					};
+					std::string gmtModified;
+					std::string destinationType;
+					HeaderOp headerOp;
+					std::string name;
+					std::vector<std::string> domainIdList;
+					std::vector<std::string> domainNameList;
+					DirectResponse directResponse;
+					std::string defaultServiceName;
+					int status;
+					std::string domainName;
+					Timeout timeout;
+					long defaultServiceId;
+					RoutePredicates routePredicates;
+					Redirect redirect;
+					long gatewayId;
+					Cors cors;
+					std::string gatewayUniqueId;
+					std::string services;
+					std::string gmtCreate;
+					int routeOrder;
+					long domainId;
+					Retry retry;
+					long id;
+					HTTPRewrite hTTPRewrite;
+					std::string predicates;
+					std::vector<RouteServicesItem> routeServices;
+				};
+
+
+				GetGatewayRouteDetailResult();
+				explicit GetGatewayRouteDetailResult(const std::string &payload);
+				~GetGatewayRouteDetailResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				Data getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				Data data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_GETGATEWAYROUTEDETAILRESULT_H_

mse/include/alibabacloud/mse/model/GetServiceListRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_GETSERVICELISTREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_GETSERVICELISTREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT GetServiceListRequest : public RpcServiceRequest {
+public:
+	GetServiceListRequest();
+	~GetServiceListRequest();
+	std::string getServiceName() const;
+	void setServiceName(const std::string &serviceName);
+	std::string getIp() const;
+	void setIp(const std::string &ip);
+	std::string getServiceType() const;
+	void setServiceType(const std::string &serviceType);
+	std::string getAppId() const;
+	void setAppId(const std::string &appId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	std::string getRegion() const;
+	void setRegion(const std::string &region);
+
+private:
+	std::string serviceName_;
+	std::string ip_;
+	std::string serviceType_;
+	std::string appId_;
+	std::string acceptLanguage_;
+	std::string region_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_GETSERVICELISTREQUEST_H_

mse/include/alibabacloud/mse/model/GetServiceListResult.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_GETSERVICELISTRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_GETSERVICELISTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT GetServiceListResult : public ServiceResult
+			{
+			public:
+				struct MscServiceDetailResponse
+				{
+					struct Method
+					{
+						std::string methodController;
+						std::vector<std::string> paths;
+						std::vector<std::string> parameterTypes;
+						std::vector<std::string> requestMethods;
+						std::string returnType;
+						std::string name;
+					};
+					std::string group;
+					std::string registryType;
+					std::string version;
+					std::string serviceName;
+					std::string serviceType;
+					std::string edasAppName;
+					std::string metadata;
+					std::vector<MscServiceDetailResponse::Method> methods;
+					std::string springApplicationName;
+					std::string dubboApplicationName;
+				};
+
+
+				GetServiceListResult();
+				explicit GetServiceListResult(const std::string &payload);
+				~GetServiceListResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::vector<MscServiceDetailResponse> getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::vector<MscServiceDetailResponse> data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_GETSERVICELISTRESULT_H_

mse/include/alibabacloud/mse/model/GetTagsBySwimmingLaneGroupIdRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_GETTAGSBYSWIMMINGLANEGROUPIDREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_GETTAGSBYSWIMMINGLANEGROUPIDREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT GetTagsBySwimmingLaneGroupIdRequest : public RpcServiceRequest {
+public:
+	GetTagsBySwimmingLaneGroupIdRequest();
+	~GetTagsBySwimmingLaneGroupIdRequest();
+	long getGroupId() const;
+	void setGroupId(long groupId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	long groupId_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_GETTAGSBYSWIMMINGLANEGROUPIDREQUEST_H_

mse/include/alibabacloud/mse/model/GetTagsBySwimmingLaneGroupIdResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_GETTAGSBYSWIMMINGLANEGROUPIDRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_GETTAGSBYSWIMMINGLANEGROUPIDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT GetTagsBySwimmingLaneGroupIdResult : public ServiceResult
+			{
+			public:
+
+
+				GetTagsBySwimmingLaneGroupIdResult();
+				explicit GetTagsBySwimmingLaneGroupIdResult(const std::string &payload);
+				~GetTagsBySwimmingLaneGroupIdResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_GETTAGSBYSWIMMINGLANEGROUPIDRESULT_H_

mse/include/alibabacloud/mse/model/ListAppBySwimmingLaneGroupTagRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_LISTAPPBYSWIMMINGLANEGROUPTAGREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_LISTAPPBYSWIMMINGLANEGROUPTAGREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT ListAppBySwimmingLaneGroupTagRequest : public RpcServiceRequest {
+public:
+	ListAppBySwimmingLaneGroupTagRequest();
+	~ListAppBySwimmingLaneGroupTagRequest();
+	long getGroupId() const;
+	void setGroupId(long groupId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	std::string getTag() const;
+	void setTag(const std::string &tag);
+
+private:
+	long groupId_;
+	std::string acceptLanguage_;
+	std::string tag_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_LISTAPPBYSWIMMINGLANEGROUPTAGREQUEST_H_

mse/include/alibabacloud/mse/model/ListAppBySwimmingLaneGroupTagResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_LISTAPPBYSWIMMINGLANEGROUPTAGRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_LISTAPPBYSWIMMINGLANEGROUPTAGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT ListAppBySwimmingLaneGroupTagResult : public ServiceResult
+			{
+			public:
+
+
+				ListAppBySwimmingLaneGroupTagResult();
+				explicit ListAppBySwimmingLaneGroupTagResult(const std::string &payload);
+				~ListAppBySwimmingLaneGroupTagResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_LISTAPPBYSWIMMINGLANEGROUPTAGRESULT_H_

mse/include/alibabacloud/mse/model/ListApplicationsWithTagRulesRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_LISTAPPLICATIONSWITHTAGRULESREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_LISTAPPLICATIONSWITHTAGRULESREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT ListApplicationsWithTagRulesRequest : public RpcServiceRequest {
+public:
+	ListApplicationsWithTagRulesRequest();
+	~ListApplicationsWithTagRulesRequest();
+	std::string getSource() const;
+	void setSource(const std::string &source);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getAppName() const;
+	void setAppName(const std::string &appName);
+	std::string getAppId() const;
+	void setAppId(const std::string &appId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	std::string getRegion() const;
+	void setRegion(const std::string &region);
+
+private:
+	std::string source_;
+	int pageNumber_;
+	std::string appName_;
+	std::string appId_;
+	int pageSize_;
+	std::string acceptLanguage_;
+	std::string region_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_LISTAPPLICATIONSWITHTAGRULESREQUEST_H_

mse/include/alibabacloud/mse/model/ListApplicationsWithTagRulesResult.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_LISTAPPLICATIONSWITHTAGRULESRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_LISTAPPLICATIONSWITHTAGRULESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT ListApplicationsWithTagRulesResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct ApplicationList
+					{
+						struct RouteRule
+						{
+							int status;
+							bool carryData;
+							int rate;
+							long gmtModified;
+							bool enable;
+							bool remove;
+							std::string tag;
+							long id;
+							std::string rules;
+							int instanceNum;
+							std::string name;
+						};
+						std::string appId;
+						long routeStatus;
+						std::vector<ApplicationList::RouteRule> routeRules;
+						std::string appName;
+					};
+					int pageSize;
+					int pageNumber;
+					int totalSize;
+					std::vector<ApplicationList> result;
+				};
+
+
+				ListApplicationsWithTagRulesResult();
+				explicit ListApplicationsWithTagRulesResult(const std::string &payload);
+				~ListApplicationsWithTagRulesResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				Data getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				Data data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_LISTAPPLICATIONSWITHTAGRULESRESULT_H_

mse/include/alibabacloud/mse/model/ListGatewayRouteRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_LISTGATEWAYROUTEREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_LISTGATEWAYROUTEREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT ListGatewayRouteRequest : public RpcServiceRequest {
+public:
+	struct FilterParams {
+		long defaultServiceId;
+		int routeOrder;
+		std::string gatewayUniqueId;
+		std::string name;
+		long gatewayId;
+		long domainId;
+		int status;
+	};
+	ListGatewayRouteRequest();
+	~ListGatewayRouteRequest();
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getOrderItem() const;
+	void setOrderItem(const std::string &orderItem);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	bool getDescSort() const;
+	void setDescSort(bool descSort);
+	FilterParams getFilterParams() const;
+	void setFilterParams(const FilterParams &filterParams);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	int pageNumber_;
+	std::string orderItem_;
+	int pageSize_;
+	bool descSort_;
+	FilterParams filterParams_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_LISTGATEWAYROUTEREQUEST_H_

mse/include/alibabacloud/mse/model/ListGatewayRouteResult.h

@@ -0,0 +1,137 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_LISTGATEWAYROUTERESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_LISTGATEWAYROUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT ListGatewayRouteResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct Routes
+					{
+						struct RoutePredicates
+						{
+							struct PathPredicates
+							{
+								std::string path;
+								std::string type;
+								bool ignoreCase;
+							};
+							struct HeaderPredicatesItem
+							{
+								std::string type;
+								std::string value;
+								std::string key;
+							};
+							struct QueryPredicatesItem
+							{
+								std::string type;
+								std::string value;
+								std::string key;
+							};
+							std::vector<HeaderPredicatesItem> headerPredicates;
+							std::vector<std::string> methodPredicates;
+							std::vector<QueryPredicatesItem> queryPredicates;
+							PathPredicates pathPredicates;
+						};
+						struct DirectResponse
+						{
+							int code;
+							std::string body;
+						};
+						struct Redirect
+						{
+							std::string path;
+							std::string host;
+							int code;
+						};
+						struct RouteServicesItem
+						{
+							std::string groupName;
+							std::string serviceName;
+							int percent;
+							std::string version;
+							std::string sourceType;
+							std::string _namespace;
+							long serviceId;
+							std::string name;
+						};
+						int status;
+						std::string defaultServiceName;
+						std::string domainName;
+						std::string gmtModified;
+						long defaultServiceId;
+						RoutePredicates routePredicates;
+						Redirect redirect;
+						long gatewayId;
+						std::string destinationType;
+						std::string name;
+						std::string gatewayUniqueId;
+						std::string services;
+						std::vector<std::string> domainIdList;
+						std::string gmtCreate;
+						int routeOrder;
+						long domainId;
+						std::vector<std::string> domainNameList;
+						long id;
+						std::string predicates;
+						DirectResponse directResponse;
+						std::vector<Routes::RouteServicesItem> routeServices;
+					};
+					int pageSize;
+					int pageNumber;
+					long totalSize;
+					std::vector<Routes> result;
+				};
+
+
+				ListGatewayRouteResult();
+				explicit ListGatewayRouteResult(const std::string &payload);
+				~ListGatewayRouteResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				Data getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				Data data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_LISTGATEWAYROUTERESULT_H_

mse/include/alibabacloud/mse/model/OfflineGatewayRouteRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_OFFLINEGATEWAYROUTEREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_OFFLINEGATEWAYROUTEREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT OfflineGatewayRouteRequest : public RpcServiceRequest {
+public:
+	OfflineGatewayRouteRequest();
+	~OfflineGatewayRouteRequest();
+	std::string getGatewayUniqueId() const;
+	void setGatewayUniqueId(const std::string &gatewayUniqueId);
+	std::string getRouteId() const;
+	void setRouteId(const std::string &routeId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	std::string gatewayUniqueId_;
+	std::string routeId_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_OFFLINEGATEWAYROUTEREQUEST_H_

mse/include/alibabacloud/mse/model/OfflineGatewayRouteResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_OFFLINEGATEWAYROUTERESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_OFFLINEGATEWAYROUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT OfflineGatewayRouteResult : public ServiceResult
+			{
+			public:
+
+
+				OfflineGatewayRouteResult();
+				explicit OfflineGatewayRouteResult(const std::string &payload);
+				~OfflineGatewayRouteResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				bool getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				bool data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_OFFLINEGATEWAYROUTERESULT_H_

mse/include/alibabacloud/mse/model/QueryAllSwimmingLaneGroupRequest.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_QUERYALLSWIMMINGLANEGROUPREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_QUERYALLSWIMMINGLANEGROUPREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT QueryAllSwimmingLaneGroupRequest : public RpcServiceRequest {
+public:
+	QueryAllSwimmingLaneGroupRequest();
+	~QueryAllSwimmingLaneGroupRequest();
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_QUERYALLSWIMMINGLANEGROUPREQUEST_H_

mse/include/alibabacloud/mse/model/QueryAllSwimmingLaneGroupResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_QUERYALLSWIMMINGLANEGROUPRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_QUERYALLSWIMMINGLANEGROUPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT QueryAllSwimmingLaneGroupResult : public ServiceResult
+			{
+			public:
+
+
+				QueryAllSwimmingLaneGroupResult();
+				explicit QueryAllSwimmingLaneGroupResult(const std::string &payload);
+				~QueryAllSwimmingLaneGroupResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_QUERYALLSWIMMINGLANEGROUPRESULT_H_

mse/include/alibabacloud/mse/model/QueryAllSwimmingLaneRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_QUERYALLSWIMMINGLANEREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_QUERYALLSWIMMINGLANEREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT QueryAllSwimmingLaneRequest : public RpcServiceRequest {
+public:
+	QueryAllSwimmingLaneRequest();
+	~QueryAllSwimmingLaneRequest();
+	long getGroupId() const;
+	void setGroupId(long groupId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	long groupId_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_QUERYALLSWIMMINGLANEREQUEST_H_

mse/include/alibabacloud/mse/model/QueryAllSwimmingLaneResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_QUERYALLSWIMMINGLANERESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_QUERYALLSWIMMINGLANERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT QueryAllSwimmingLaneResult : public ServiceResult
+			{
+			public:
+
+
+				QueryAllSwimmingLaneResult();
+				explicit QueryAllSwimmingLaneResult(const std::string &payload);
+				~QueryAllSwimmingLaneResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_QUERYALLSWIMMINGLANERESULT_H_

mse/include/alibabacloud/mse/model/QuerySwimmingLaneByIdRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_QUERYSWIMMINGLANEBYIDREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_QUERYSWIMMINGLANEBYIDREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT QuerySwimmingLaneByIdRequest : public RpcServiceRequest {
+public:
+	QuerySwimmingLaneByIdRequest();
+	~QuerySwimmingLaneByIdRequest();
+	long getLaneId() const;
+	void setLaneId(long laneId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	long laneId_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_QUERYSWIMMINGLANEBYIDREQUEST_H_

mse/include/alibabacloud/mse/model/QuerySwimmingLaneByIdResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_QUERYSWIMMINGLANEBYIDRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_QUERYSWIMMINGLANEBYIDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT QuerySwimmingLaneByIdResult : public ServiceResult
+			{
+			public:
+
+
+				QuerySwimmingLaneByIdResult();
+				explicit QuerySwimmingLaneByIdResult(const std::string &payload);
+				~QuerySwimmingLaneByIdResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_QUERYSWIMMINGLANEBYIDRESULT_H_

mse/include/alibabacloud/mse/model/UpdateGatewayRouteCORSRequest.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTECORSREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTECORSREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT UpdateGatewayRouteCORSRequest : public RpcServiceRequest {
+public:
+	struct CorsJSON {
+		bool allowCredentials;
+		std::string allowOrigins;
+		std::string allowMethods;
+		std::string allowHeaders;
+		std::string exposeHeaders;
+		std::string timeUnit;
+		long unitNum;
+		std::string status;
+	};
+	UpdateGatewayRouteCORSRequest();
+	~UpdateGatewayRouteCORSRequest();
+	CorsJSON getCorsJSON() const;
+	void setCorsJSON(const CorsJSON &corsJSON);
+	std::string getGatewayUniqueId() const;
+	void setGatewayUniqueId(const std::string &gatewayUniqueId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	long getId() const;
+	void setId(long id);
+	long getGatewayId() const;
+	void setGatewayId(long gatewayId);
+
+private:
+	CorsJSON corsJSON_;
+	std::string gatewayUniqueId_;
+	std::string acceptLanguage_;
+	long id_;
+	long gatewayId_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTECORSREQUEST_H_

mse/include/alibabacloud/mse/model/UpdateGatewayRouteCORSResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTECORSRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTECORSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT UpdateGatewayRouteCORSResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateGatewayRouteCORSResult();
+				explicit UpdateGatewayRouteCORSResult(const std::string &payload);
+				~UpdateGatewayRouteCORSResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				long getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				long data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTECORSRESULT_H_

mse/include/alibabacloud/mse/model/UpdateGatewayRouteHeaderOpRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTEHEADEROPREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTEHEADEROPREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT UpdateGatewayRouteHeaderOpRequest : public RpcServiceRequest {
+public:
+	UpdateGatewayRouteHeaderOpRequest();
+	~UpdateGatewayRouteHeaderOpRequest();
+	std::string getGatewayUniqueId() const;
+	void setGatewayUniqueId(const std::string &gatewayUniqueId);
+	std::string getHeaderOpJSON() const;
+	void setHeaderOpJSON(const std::string &headerOpJSON);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	long getId() const;
+	void setId(long id);
+	long getGatewayId() const;
+	void setGatewayId(long gatewayId);
+
+private:
+	std::string gatewayUniqueId_;
+	std::string headerOpJSON_;
+	std::string acceptLanguage_;
+	long id_;
+	long gatewayId_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTEHEADEROPREQUEST_H_

mse/include/alibabacloud/mse/model/UpdateGatewayRouteHeaderOpResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTEHEADEROPRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTEHEADEROPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT UpdateGatewayRouteHeaderOpResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateGatewayRouteHeaderOpResult();
+				explicit UpdateGatewayRouteHeaderOpResult(const std::string &payload);
+				~UpdateGatewayRouteHeaderOpResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				long getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				long data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTEHEADEROPRESULT_H_

mse/include/alibabacloud/mse/model/UpdateGatewayRouteRequest.h

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTEREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTEREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT UpdateGatewayRouteRequest : public RpcServiceRequest {
+public:
+	struct Services {
+		std::string name;
+		std::string _namespace;
+		std::string sourceType;
+		long serviceId;
+		int percent;
+		std::string version;
+		std::string groupName;
+	};
+	struct Predicates {
+		struct PathPredicates {
+			std::string path;
+			bool ignoreCase;
+			std::string type;
+		};
+		PathPredicates pathPredicates;
+		std::string string;
+		std::vector<std::string> methodPredicates;
+		struct HeaderPredicatesItem {
+			std::string type;
+			std::string value;
+			std::string key;
+		};
+		HeaderPredicatesItem headerPredicatesItem;
+		std::vector<HeaderPredicatesItem> headerPredicates;
+		struct QueryPredicatesItem {
+			std::string type;
+			std::string value;
+			std::string key;
+		};
+		QueryPredicatesItem queryPredicatesItem;
+		std::vector<QueryPredicatesItem> queryPredicates;
+	};
+	struct RedirectJSON {
+		std::string path;
+		int code;
+		std::string host;
+	};
+	struct DirectResponseJSON {
+		long code;
+		std::string body;
+	};
+	UpdateGatewayRouteRequest();
+	~UpdateGatewayRouteRequest();
+	std::string getGatewayUniqueId() const;
+	void setGatewayUniqueId(const std::string &gatewayUniqueId);
+	std::string getDestinationType() const;
+	void setDestinationType(const std::string &destinationType);
+	std::string getDomainIdListJSON() const;
+	void setDomainIdListJSON(const std::string &domainIdListJSON);
+	long getId() const;
+	void setId(long id);
+	long getGatewayId() const;
+	void setGatewayId(long gatewayId);
+	int getRouteOrder() const;
+	void setRouteOrder(int routeOrder);
+	std::vector<Services> getServices() const;
+	void setServices(const std::vector<Services> &services);
+	Predicates getPredicates() const;
+	void setPredicates(const Predicates &predicates);
+	RedirectJSON getRedirectJSON() const;
+	void setRedirectJSON(const RedirectJSON &redirectJSON);
+	DirectResponseJSON getDirectResponseJSON() const;
+	void setDirectResponseJSON(const DirectResponseJSON &directResponseJSON);
+	std::string getName() const;
+	void setName(const std::string &name);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	std::string gatewayUniqueId_;
+	std::string destinationType_;
+	std::string domainIdListJSON_;
+	long id_;
+	long gatewayId_;
+	int routeOrder_;
+	std::vector<Services> services_;
+	Predicates predicates_;
+	RedirectJSON redirectJSON_;
+	DirectResponseJSON directResponseJSON_;
+	std::string name_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTEREQUEST_H_

mse/include/alibabacloud/mse/model/UpdateGatewayRouteResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTERESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT UpdateGatewayRouteResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateGatewayRouteResult();
+				explicit UpdateGatewayRouteResult(const std::string &payload);
+				~UpdateGatewayRouteResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				long getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				long data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTERESULT_H_

mse/include/alibabacloud/mse/model/UpdateGatewayRouteRetryRequest.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTERETRYREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTERETRYREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT UpdateGatewayRouteRetryRequest : public RpcServiceRequest {
+public:
+	struct RetryJSON {
+		std::string string;
+		std::vector<std::string> httpCodes;
+		int attempts;
+		std::string string;
+		std::vector<std::string> retryOn;
+		std::string status;
+	};
+	UpdateGatewayRouteRetryRequest();
+	~UpdateGatewayRouteRetryRequest();
+	std::string getGatewayUniqueId() const;
+	void setGatewayUniqueId(const std::string &gatewayUniqueId);
+	RetryJSON getRetryJSON() const;
+	void setRetryJSON(const RetryJSON &retryJSON);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	long getId() const;
+	void setId(long id);
+	long getGatewayId() const;
+	void setGatewayId(long gatewayId);
+
+private:
+	std::string gatewayUniqueId_;
+	RetryJSON retryJSON_;
+	std::string acceptLanguage_;
+	long id_;
+	long gatewayId_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTERETRYREQUEST_H_

mse/include/alibabacloud/mse/model/UpdateGatewayRouteRetryResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTERETRYRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTERETRYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT UpdateGatewayRouteRetryResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateGatewayRouteRetryResult();
+				explicit UpdateGatewayRouteRetryResult(const std::string &payload);
+				~UpdateGatewayRouteRetryResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				long getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				long data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTERETRYRESULT_H_

mse/include/alibabacloud/mse/model/UpdateGatewayRouteTimeoutRequest.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTETIMEOUTREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTETIMEOUTREQUEST_H_
+
+#include <alibabacloud/mse/MseExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mse {
+namespace Model {
+class ALIBABACLOUD_MSE_EXPORT UpdateGatewayRouteTimeoutRequest : public RpcServiceRequest {
+public:
+	struct TimeoutJSON {
+		std::string timeUnit;
+		int unitNum;
+		std::string status;
+	};
+	UpdateGatewayRouteTimeoutRequest();
+	~UpdateGatewayRouteTimeoutRequest();
+	TimeoutJSON getTimeoutJSON() const;
+	void setTimeoutJSON(const TimeoutJSON &timeoutJSON);
+	std::string getGatewayUniqueId() const;
+	void setGatewayUniqueId(const std::string &gatewayUniqueId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	long getId() const;
+	void setId(long id);
+	long getGatewayId() const;
+	void setGatewayId(long gatewayId);
+
+private:
+	TimeoutJSON timeoutJSON_;
+	std::string gatewayUniqueId_;
+	std::string acceptLanguage_;
+	long id_;
+	long gatewayId_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTETIMEOUTREQUEST_H_

mse/include/alibabacloud/mse/model/UpdateGatewayRouteTimeoutResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTETIMEOUTRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTETIMEOUTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mse/MseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mse
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSE_EXPORT UpdateGatewayRouteTimeoutResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateGatewayRouteTimeoutResult();
+				explicit UpdateGatewayRouteTimeoutResult(const std::string &payload);
+				~UpdateGatewayRouteTimeoutResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				long getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				long data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTETIMEOUTRESULT_H_

mse/src/MseClient.cc

@@ -195,6 +195,42 @@ MseClient::AddGatewayDomainOutcomeCallable MseClient::addGatewayDomainCallable(c
 	return task->get_future();
 }
 
+MseClient::AddGatewayRouteOutcome MseClient::addGatewayRoute(const AddGatewayRouteRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddGatewayRouteOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddGatewayRouteOutcome(AddGatewayRouteResult(outcome.result()));
+	else
+		return AddGatewayRouteOutcome(outcome.error());
+}
+
+void MseClient::addGatewayRouteAsync(const AddGatewayRouteRequest& request, const AddGatewayRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addGatewayRoute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::AddGatewayRouteOutcomeCallable MseClient::addGatewayRouteCallable(const AddGatewayRouteRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddGatewayRouteOutcome()>>(
+			[this, request]()
+			{
+			return this->addGatewayRoute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 MseClient::AddGatewayServiceVersionOutcome MseClient::addGatewayServiceVersion(const AddGatewayServiceVersionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -375,6 +411,78 @@ MseClient::AddServiceSourceOutcomeCallable MseClient::addServiceSourceCallable(c
 	return task->get_future();
 }
 
+MseClient::ApplyGatewayRouteOutcome MseClient::applyGatewayRoute(const ApplyGatewayRouteRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ApplyGatewayRouteOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ApplyGatewayRouteOutcome(ApplyGatewayRouteResult(outcome.result()));
+	else
+		return ApplyGatewayRouteOutcome(outcome.error());
+}
+
+void MseClient::applyGatewayRouteAsync(const ApplyGatewayRouteRequest& request, const ApplyGatewayRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, applyGatewayRoute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::ApplyGatewayRouteOutcomeCallable MseClient::applyGatewayRouteCallable(const ApplyGatewayRouteRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ApplyGatewayRouteOutcome()>>(
+			[this, request]()
+			{
+			return this->applyGatewayRoute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseClient::ApplyTagPoliciesOutcome MseClient::applyTagPolicies(const ApplyTagPoliciesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ApplyTagPoliciesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ApplyTagPoliciesOutcome(ApplyTagPoliciesResult(outcome.result()));
+	else
+		return ApplyTagPoliciesOutcome(outcome.error());
+}
+
+void MseClient::applyTagPoliciesAsync(const ApplyTagPoliciesRequest& request, const ApplyTagPoliciesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, applyTagPolicies(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::ApplyTagPoliciesOutcomeCallable MseClient::applyTagPoliciesCallable(const ApplyTagPoliciesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ApplyTagPoliciesOutcome()>>(
+			[this, request]()
+			{
+			return this->applyTagPolicies(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 MseClient::CloneNacosConfigOutcome MseClient::cloneNacosConfig(const CloneNacosConfigRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -663,6 +771,78 @@ MseClient::CreateNacosServiceOutcomeCallable MseClient::createNacosServiceCallab
 	return task->get_future();
 }
 
+MseClient::CreateOrUpdateSwimmingLaneOutcome MseClient::createOrUpdateSwimmingLane(const CreateOrUpdateSwimmingLaneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateOrUpdateSwimmingLaneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateOrUpdateSwimmingLaneOutcome(CreateOrUpdateSwimmingLaneResult(outcome.result()));
+	else
+		return CreateOrUpdateSwimmingLaneOutcome(outcome.error());
+}
+
+void MseClient::createOrUpdateSwimmingLaneAsync(const CreateOrUpdateSwimmingLaneRequest& request, const CreateOrUpdateSwimmingLaneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createOrUpdateSwimmingLane(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::CreateOrUpdateSwimmingLaneOutcomeCallable MseClient::createOrUpdateSwimmingLaneCallable(const CreateOrUpdateSwimmingLaneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateOrUpdateSwimmingLaneOutcome()>>(
+			[this, request]()
+			{
+			return this->createOrUpdateSwimmingLane(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseClient::CreateOrUpdateSwimmingLaneGroupOutcome MseClient::createOrUpdateSwimmingLaneGroup(const CreateOrUpdateSwimmingLaneGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateOrUpdateSwimmingLaneGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateOrUpdateSwimmingLaneGroupOutcome(CreateOrUpdateSwimmingLaneGroupResult(outcome.result()));
+	else
+		return CreateOrUpdateSwimmingLaneGroupOutcome(outcome.error());
+}
+
+void MseClient::createOrUpdateSwimmingLaneGroupAsync(const CreateOrUpdateSwimmingLaneGroupRequest& request, const CreateOrUpdateSwimmingLaneGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createOrUpdateSwimmingLaneGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::CreateOrUpdateSwimmingLaneGroupOutcomeCallable MseClient::createOrUpdateSwimmingLaneGroupCallable(const CreateOrUpdateSwimmingLaneGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateOrUpdateSwimmingLaneGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->createOrUpdateSwimmingLaneGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 MseClient::CreateZnodeOutcome MseClient::createZnode(const CreateZnodeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -915,6 +1095,42 @@ MseClient::DeleteGatewayDomainOutcomeCallable MseClient::deleteGatewayDomainCall
 	return task->get_future();
 }
 
+MseClient::DeleteGatewayRouteOutcome MseClient::deleteGatewayRoute(const DeleteGatewayRouteRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteGatewayRouteOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteGatewayRouteOutcome(DeleteGatewayRouteResult(outcome.result()));
+	else
+		return DeleteGatewayRouteOutcome(outcome.error());
+}
+
+void MseClient::deleteGatewayRouteAsync(const DeleteGatewayRouteRequest& request, const DeleteGatewayRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteGatewayRoute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::DeleteGatewayRouteOutcomeCallable MseClient::deleteGatewayRouteCallable(const DeleteGatewayRouteRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteGatewayRouteOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteGatewayRoute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 MseClient::DeleteGatewayServiceVersionOutcome MseClient::deleteGatewayServiceVersion(const DeleteGatewayServiceVersionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1059,6 +1275,42 @@ MseClient::DeleteNacosConfigsOutcomeCallable MseClient::deleteNacosConfigsCallab
 	return task->get_future();
 }
 
+MseClient::DeleteNacosInstanceOutcome MseClient::deleteNacosInstance(const DeleteNacosInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteNacosInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteNacosInstanceOutcome(DeleteNacosInstanceResult(outcome.result()));
+	else
+		return DeleteNacosInstanceOutcome(outcome.error());
+}
+
+void MseClient::deleteNacosInstanceAsync(const DeleteNacosInstanceRequest& request, const DeleteNacosInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteNacosInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::DeleteNacosInstanceOutcomeCallable MseClient::deleteNacosInstanceCallable(const DeleteNacosInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteNacosInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteNacosInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 MseClient::DeleteNacosServiceOutcome MseClient::deleteNacosService(const DeleteNacosServiceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1131,6 +1383,78 @@ MseClient::DeleteServiceSourceOutcomeCallable MseClient::deleteServiceSourceCall
 	return task->get_future();
 }
 
+MseClient::DeleteSwimmingLaneOutcome MseClient::deleteSwimmingLane(const DeleteSwimmingLaneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteSwimmingLaneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteSwimmingLaneOutcome(DeleteSwimmingLaneResult(outcome.result()));
+	else
+		return DeleteSwimmingLaneOutcome(outcome.error());
+}
+
+void MseClient::deleteSwimmingLaneAsync(const DeleteSwimmingLaneRequest& request, const DeleteSwimmingLaneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteSwimmingLane(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::DeleteSwimmingLaneOutcomeCallable MseClient::deleteSwimmingLaneCallable(const DeleteSwimmingLaneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteSwimmingLaneOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteSwimmingLane(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseClient::DeleteSwimmingLaneGroupOutcome MseClient::deleteSwimmingLaneGroup(const DeleteSwimmingLaneGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteSwimmingLaneGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteSwimmingLaneGroupOutcome(DeleteSwimmingLaneGroupResult(outcome.result()));
+	else
+		return DeleteSwimmingLaneGroupOutcome(outcome.error());
+}
+
+void MseClient::deleteSwimmingLaneGroupAsync(const DeleteSwimmingLaneGroupRequest& request, const DeleteSwimmingLaneGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteSwimmingLaneGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::DeleteSwimmingLaneGroupOutcomeCallable MseClient::deleteSwimmingLaneGroupCallable(const DeleteSwimmingLaneGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteSwimmingLaneGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteSwimmingLaneGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 MseClient::DeleteZnodeOutcome MseClient::deleteZnode(const DeleteZnodeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1383,6 +1707,42 @@ MseClient::GetGatewayOptionOutcomeCallable MseClient::getGatewayOptionCallable(c
 	return task->get_future();
 }
 
+MseClient::GetGatewayRouteDetailOutcome MseClient::getGatewayRouteDetail(const GetGatewayRouteDetailRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetGatewayRouteDetailOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetGatewayRouteDetailOutcome(GetGatewayRouteDetailResult(outcome.result()));
+	else
+		return GetGatewayRouteDetailOutcome(outcome.error());
+}
+
+void MseClient::getGatewayRouteDetailAsync(const GetGatewayRouteDetailRequest& request, const GetGatewayRouteDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getGatewayRouteDetail(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::GetGatewayRouteDetailOutcomeCallable MseClient::getGatewayRouteDetailCallable(const GetGatewayRouteDetailRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetGatewayRouteDetailOutcome()>>(
+			[this, request]()
+			{
+			return this->getGatewayRouteDetail(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 MseClient::GetGatewayServiceDetailOutcome MseClient::getGatewayServiceDetail(const GetGatewayServiceDetailRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1779,6 +2139,78 @@ MseClient::GetOverviewOutcomeCallable MseClient::getOverviewCallable(const GetOv
 	return task->get_future();
 }
 
+MseClient::GetServiceListOutcome MseClient::getServiceList(const GetServiceListRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetServiceListOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetServiceListOutcome(GetServiceListResult(outcome.result()));
+	else
+		return GetServiceListOutcome(outcome.error());
+}
+
+void MseClient::getServiceListAsync(const GetServiceListRequest& request, const GetServiceListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getServiceList(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::GetServiceListOutcomeCallable MseClient::getServiceListCallable(const GetServiceListRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetServiceListOutcome()>>(
+			[this, request]()
+			{
+			return this->getServiceList(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseClient::GetTagsBySwimmingLaneGroupIdOutcome MseClient::getTagsBySwimmingLaneGroupId(const GetTagsBySwimmingLaneGroupIdRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetTagsBySwimmingLaneGroupIdOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetTagsBySwimmingLaneGroupIdOutcome(GetTagsBySwimmingLaneGroupIdResult(outcome.result()));
+	else
+		return GetTagsBySwimmingLaneGroupIdOutcome(outcome.error());
+}
+
+void MseClient::getTagsBySwimmingLaneGroupIdAsync(const GetTagsBySwimmingLaneGroupIdRequest& request, const GetTagsBySwimmingLaneGroupIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getTagsBySwimmingLaneGroupId(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::GetTagsBySwimmingLaneGroupIdOutcomeCallable MseClient::getTagsBySwimmingLaneGroupIdCallable(const GetTagsBySwimmingLaneGroupIdRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetTagsBySwimmingLaneGroupIdOutcome()>>(
+			[this, request]()
+			{
+			return this->getTagsBySwimmingLaneGroupId(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 MseClient::ImportNacosConfigOutcome MseClient::importNacosConfig(const ImportNacosConfigRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2103,6 +2535,78 @@ MseClient::ListAnsServicesOutcomeCallable MseClient::listAnsServicesCallable(con
 	return task->get_future();
 }
 
+MseClient::ListAppBySwimmingLaneGroupTagOutcome MseClient::listAppBySwimmingLaneGroupTag(const ListAppBySwimmingLaneGroupTagRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListAppBySwimmingLaneGroupTagOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListAppBySwimmingLaneGroupTagOutcome(ListAppBySwimmingLaneGroupTagResult(outcome.result()));
+	else
+		return ListAppBySwimmingLaneGroupTagOutcome(outcome.error());
+}
+
+void MseClient::listAppBySwimmingLaneGroupTagAsync(const ListAppBySwimmingLaneGroupTagRequest& request, const ListAppBySwimmingLaneGroupTagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listAppBySwimmingLaneGroupTag(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::ListAppBySwimmingLaneGroupTagOutcomeCallable MseClient::listAppBySwimmingLaneGroupTagCallable(const ListAppBySwimmingLaneGroupTagRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListAppBySwimmingLaneGroupTagOutcome()>>(
+			[this, request]()
+			{
+			return this->listAppBySwimmingLaneGroupTag(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseClient::ListApplicationsWithTagRulesOutcome MseClient::listApplicationsWithTagRules(const ListApplicationsWithTagRulesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListApplicationsWithTagRulesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListApplicationsWithTagRulesOutcome(ListApplicationsWithTagRulesResult(outcome.result()));
+	else
+		return ListApplicationsWithTagRulesOutcome(outcome.error());
+}
+
+void MseClient::listApplicationsWithTagRulesAsync(const ListApplicationsWithTagRulesRequest& request, const ListApplicationsWithTagRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listApplicationsWithTagRules(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::ListApplicationsWithTagRulesOutcomeCallable MseClient::listApplicationsWithTagRulesCallable(const ListApplicationsWithTagRulesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListApplicationsWithTagRulesOutcome()>>(
+			[this, request]()
+			{
+			return this->listApplicationsWithTagRules(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 MseClient::ListClusterConnectionTypesOutcome MseClient::listClusterConnectionTypes(const ListClusterConnectionTypesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2381,46 +2885,82 @@ void MseClient::listGatewayAsync(const ListGatewayRequest& request, const ListGa
 
 MseClient::ListGatewayOutcomeCallable MseClient::listGatewayCallable(const ListGatewayRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<ListGatewayOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<ListGatewayOutcome()>>(
+			[this, request]()
+			{
+			return this->listGateway(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseClient::ListGatewayDomainOutcome MseClient::listGatewayDomain(const ListGatewayDomainRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListGatewayDomainOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListGatewayDomainOutcome(ListGatewayDomainResult(outcome.result()));
+	else
+		return ListGatewayDomainOutcome(outcome.error());
+}
+
+void MseClient::listGatewayDomainAsync(const ListGatewayDomainRequest& request, const ListGatewayDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listGatewayDomain(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::ListGatewayDomainOutcomeCallable MseClient::listGatewayDomainCallable(const ListGatewayDomainRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListGatewayDomainOutcome()>>(
 			[this, request]()
 			{
-			return this->listGateway(request);
+			return this->listGatewayDomain(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-MseClient::ListGatewayDomainOutcome MseClient::listGatewayDomain(const ListGatewayDomainRequest &request) const
+MseClient::ListGatewayRouteOutcome MseClient::listGatewayRoute(const ListGatewayRouteRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return ListGatewayDomainOutcome(endpointOutcome.error());
+		return ListGatewayRouteOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return ListGatewayDomainOutcome(ListGatewayDomainResult(outcome.result()));
+		return ListGatewayRouteOutcome(ListGatewayRouteResult(outcome.result()));
 	else
-		return ListGatewayDomainOutcome(outcome.error());
+		return ListGatewayRouteOutcome(outcome.error());
 }
 
-void MseClient::listGatewayDomainAsync(const ListGatewayDomainRequest& request, const ListGatewayDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void MseClient::listGatewayRouteAsync(const ListGatewayRouteRequest& request, const ListGatewayRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, listGatewayDomain(request), context);
+		handler(this, request, listGatewayRoute(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-MseClient::ListGatewayDomainOutcomeCallable MseClient::listGatewayDomainCallable(const ListGatewayDomainRequest &request) const
+MseClient::ListGatewayRouteOutcomeCallable MseClient::listGatewayRouteCallable(const ListGatewayRouteRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<ListGatewayDomainOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<ListGatewayRouteOutcome()>>(
 			[this, request]()
 			{
-			return this->listGatewayDomain(request);
+			return this->listGatewayRoute(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -2787,6 +3327,42 @@ MseClient::ModifyGovernanceKubernetesClusterOutcomeCallable MseClient::modifyGov
 	return task->get_future();
 }
 
+MseClient::OfflineGatewayRouteOutcome MseClient::offlineGatewayRoute(const OfflineGatewayRouteRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return OfflineGatewayRouteOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return OfflineGatewayRouteOutcome(OfflineGatewayRouteResult(outcome.result()));
+	else
+		return OfflineGatewayRouteOutcome(outcome.error());
+}
+
+void MseClient::offlineGatewayRouteAsync(const OfflineGatewayRouteRequest& request, const OfflineGatewayRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, offlineGatewayRoute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::OfflineGatewayRouteOutcomeCallable MseClient::offlineGatewayRouteCallable(const OfflineGatewayRouteRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<OfflineGatewayRouteOutcome()>>(
+			[this, request]()
+			{
+			return this->offlineGatewayRoute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 MseClient::PullServicesOutcome MseClient::pullServices(const PullServicesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2823,6 +3399,78 @@ MseClient::PullServicesOutcomeCallable MseClient::pullServicesCallable(const Pul
 	return task->get_future();
 }
 
+MseClient::QueryAllSwimmingLaneOutcome MseClient::queryAllSwimmingLane(const QueryAllSwimmingLaneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QueryAllSwimmingLaneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QueryAllSwimmingLaneOutcome(QueryAllSwimmingLaneResult(outcome.result()));
+	else
+		return QueryAllSwimmingLaneOutcome(outcome.error());
+}
+
+void MseClient::queryAllSwimmingLaneAsync(const QueryAllSwimmingLaneRequest& request, const QueryAllSwimmingLaneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, queryAllSwimmingLane(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::QueryAllSwimmingLaneOutcomeCallable MseClient::queryAllSwimmingLaneCallable(const QueryAllSwimmingLaneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QueryAllSwimmingLaneOutcome()>>(
+			[this, request]()
+			{
+			return this->queryAllSwimmingLane(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseClient::QueryAllSwimmingLaneGroupOutcome MseClient::queryAllSwimmingLaneGroup(const QueryAllSwimmingLaneGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QueryAllSwimmingLaneGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QueryAllSwimmingLaneGroupOutcome(QueryAllSwimmingLaneGroupResult(outcome.result()));
+	else
+		return QueryAllSwimmingLaneGroupOutcome(outcome.error());
+}
+
+void MseClient::queryAllSwimmingLaneGroupAsync(const QueryAllSwimmingLaneGroupRequest& request, const QueryAllSwimmingLaneGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, queryAllSwimmingLaneGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::QueryAllSwimmingLaneGroupOutcomeCallable MseClient::queryAllSwimmingLaneGroupCallable(const QueryAllSwimmingLaneGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QueryAllSwimmingLaneGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->queryAllSwimmingLaneGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 MseClient::QueryBusinessLocationsOutcome MseClient::queryBusinessLocations(const QueryBusinessLocationsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3183,6 +3831,42 @@ MseClient::QuerySlbSpecOutcomeCallable MseClient::querySlbSpecCallable(const Que
 	return task->get_future();
 }
 
+MseClient::QuerySwimmingLaneByIdOutcome MseClient::querySwimmingLaneById(const QuerySwimmingLaneByIdRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QuerySwimmingLaneByIdOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QuerySwimmingLaneByIdOutcome(QuerySwimmingLaneByIdResult(outcome.result()));
+	else
+		return QuerySwimmingLaneByIdOutcome(outcome.error());
+}
+
+void MseClient::querySwimmingLaneByIdAsync(const QuerySwimmingLaneByIdRequest& request, const QuerySwimmingLaneByIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, querySwimmingLaneById(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::QuerySwimmingLaneByIdOutcomeCallable MseClient::querySwimmingLaneByIdCallable(const QuerySwimmingLaneByIdRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QuerySwimmingLaneByIdOutcome()>>(
+			[this, request]()
+			{
+			return this->querySwimmingLaneById(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 MseClient::QueryZnodeDetailOutcome MseClient::queryZnodeDetail(const QueryZnodeDetailRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3651,6 +4335,78 @@ MseClient::UpdateGatewayOptionOutcomeCallable MseClient::updateGatewayOptionCall
 	return task->get_future();
 }
 
+MseClient::UpdateGatewayRouteOutcome MseClient::updateGatewayRoute(const UpdateGatewayRouteRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateGatewayRouteOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateGatewayRouteOutcome(UpdateGatewayRouteResult(outcome.result()));
+	else
+		return UpdateGatewayRouteOutcome(outcome.error());
+}
+
+void MseClient::updateGatewayRouteAsync(const UpdateGatewayRouteRequest& request, const UpdateGatewayRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateGatewayRoute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::UpdateGatewayRouteOutcomeCallable MseClient::updateGatewayRouteCallable(const UpdateGatewayRouteRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateGatewayRouteOutcome()>>(
+			[this, request]()
+			{
+			return this->updateGatewayRoute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseClient::UpdateGatewayRouteCORSOutcome MseClient::updateGatewayRouteCORS(const UpdateGatewayRouteCORSRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateGatewayRouteCORSOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateGatewayRouteCORSOutcome(UpdateGatewayRouteCORSResult(outcome.result()));
+	else
+		return UpdateGatewayRouteCORSOutcome(outcome.error());
+}
+
+void MseClient::updateGatewayRouteCORSAsync(const UpdateGatewayRouteCORSRequest& request, const UpdateGatewayRouteCORSAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateGatewayRouteCORS(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::UpdateGatewayRouteCORSOutcomeCallable MseClient::updateGatewayRouteCORSCallable(const UpdateGatewayRouteCORSRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateGatewayRouteCORSOutcome()>>(
+			[this, request]()
+			{
+			return this->updateGatewayRouteCORS(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 MseClient::UpdateGatewayRouteHTTPRewriteOutcome MseClient::updateGatewayRouteHTTPRewrite(const UpdateGatewayRouteHTTPRewriteRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3687,6 +4443,114 @@ MseClient::UpdateGatewayRouteHTTPRewriteOutcomeCallable MseClient::updateGateway
 	return task->get_future();
 }
 
+MseClient::UpdateGatewayRouteHeaderOpOutcome MseClient::updateGatewayRouteHeaderOp(const UpdateGatewayRouteHeaderOpRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateGatewayRouteHeaderOpOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateGatewayRouteHeaderOpOutcome(UpdateGatewayRouteHeaderOpResult(outcome.result()));
+	else
+		return UpdateGatewayRouteHeaderOpOutcome(outcome.error());
+}
+
+void MseClient::updateGatewayRouteHeaderOpAsync(const UpdateGatewayRouteHeaderOpRequest& request, const UpdateGatewayRouteHeaderOpAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateGatewayRouteHeaderOp(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::UpdateGatewayRouteHeaderOpOutcomeCallable MseClient::updateGatewayRouteHeaderOpCallable(const UpdateGatewayRouteHeaderOpRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateGatewayRouteHeaderOpOutcome()>>(
+			[this, request]()
+			{
+			return this->updateGatewayRouteHeaderOp(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseClient::UpdateGatewayRouteRetryOutcome MseClient::updateGatewayRouteRetry(const UpdateGatewayRouteRetryRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateGatewayRouteRetryOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateGatewayRouteRetryOutcome(UpdateGatewayRouteRetryResult(outcome.result()));
+	else
+		return UpdateGatewayRouteRetryOutcome(outcome.error());
+}
+
+void MseClient::updateGatewayRouteRetryAsync(const UpdateGatewayRouteRetryRequest& request, const UpdateGatewayRouteRetryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateGatewayRouteRetry(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::UpdateGatewayRouteRetryOutcomeCallable MseClient::updateGatewayRouteRetryCallable(const UpdateGatewayRouteRetryRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateGatewayRouteRetryOutcome()>>(
+			[this, request]()
+			{
+			return this->updateGatewayRouteRetry(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseClient::UpdateGatewayRouteTimeoutOutcome MseClient::updateGatewayRouteTimeout(const UpdateGatewayRouteTimeoutRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateGatewayRouteTimeoutOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateGatewayRouteTimeoutOutcome(UpdateGatewayRouteTimeoutResult(outcome.result()));
+	else
+		return UpdateGatewayRouteTimeoutOutcome(outcome.error());
+}
+
+void MseClient::updateGatewayRouteTimeoutAsync(const UpdateGatewayRouteTimeoutRequest& request, const UpdateGatewayRouteTimeoutAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateGatewayRouteTimeout(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseClient::UpdateGatewayRouteTimeoutOutcomeCallable MseClient::updateGatewayRouteTimeoutCallable(const UpdateGatewayRouteTimeoutRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateGatewayRouteTimeoutOutcome()>>(
+			[this, request]()
+			{
+			return this->updateGatewayRouteTimeout(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 MseClient::UpdateGatewayServiceVersionOutcome MseClient::updateGatewayServiceVersion(const UpdateGatewayServiceVersionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

mse/src/model/AddGatewayRouteRequest.cc

@@ -0,0 +1,161 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/AddGatewayRouteRequest.h>
+
+using AlibabaCloud::Mse::Model::AddGatewayRouteRequest;
+
+AddGatewayRouteRequest::AddGatewayRouteRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "AddGatewayRoute") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AddGatewayRouteRequest::~AddGatewayRouteRequest() {}
+
+std::string AddGatewayRouteRequest::getGatewayUniqueId() const {
+  return gatewayUniqueId_;
+}
+
+void AddGatewayRouteRequest::setGatewayUniqueId(const std::string &gatewayUniqueId) {
+  gatewayUniqueId_ = gatewayUniqueId;
+  setParameter(std::string("GatewayUniqueId"), gatewayUniqueId);
+}
+
+std::string AddGatewayRouteRequest::getDestinationType() const {
+  return destinationType_;
+}
+
+void AddGatewayRouteRequest::setDestinationType(const std::string &destinationType) {
+  destinationType_ = destinationType;
+  setParameter(std::string("DestinationType"), destinationType);
+}
+
+std::string AddGatewayRouteRequest::getDomainIdListJSON() const {
+  return domainIdListJSON_;
+}
+
+void AddGatewayRouteRequest::setDomainIdListJSON(const std::string &domainIdListJSON) {
+  domainIdListJSON_ = domainIdListJSON;
+  setParameter(std::string("DomainIdListJSON"), domainIdListJSON);
+}
+
+long AddGatewayRouteRequest::getDomainId() const {
+  return domainId_;
+}
+
+void AddGatewayRouteRequest::setDomainId(long domainId) {
+  domainId_ = domainId;
+  setParameter(std::string("DomainId"), std::to_string(domainId));
+}
+
+long AddGatewayRouteRequest::getGatewayId() const {
+  return gatewayId_;
+}
+
+void AddGatewayRouteRequest::setGatewayId(long gatewayId) {
+  gatewayId_ = gatewayId;
+  setParameter(std::string("GatewayId"), std::to_string(gatewayId));
+}
+
+int AddGatewayRouteRequest::getRouteOrder() const {
+  return routeOrder_;
+}
+
+void AddGatewayRouteRequest::setRouteOrder(int routeOrder) {
+  routeOrder_ = routeOrder;
+  setParameter(std::string("RouteOrder"), std::to_string(routeOrder));
+}
+
+std::vector<AddGatewayRouteRequest::Services> AddGatewayRouteRequest::getServices() const {
+  return services_;
+}
+
+void AddGatewayRouteRequest::setServices(const std::vector<AddGatewayRouteRequest::Services> &services) {
+  services_ = services;
+  for(int dep1 = 0; dep1 != services.size(); dep1++) {
+    setParameter(std::string("Services") + "." + std::to_string(dep1 + 1) + ".Name", services[dep1].name);
+    setParameter(std::string("Services") + "." + std::to_string(dep1 + 1) + ".Namespace", services[dep1]._namespace);
+    setParameter(std::string("Services") + "." + std::to_string(dep1 + 1) + ".SourceType", services[dep1].sourceType);
+    setParameter(std::string("Services") + "." + std::to_string(dep1 + 1) + ".ServiceId", std::to_string(services[dep1].serviceId));
+    setParameter(std::string("Services") + "." + std::to_string(dep1 + 1) + ".Percent", std::to_string(services[dep1].percent));
+    setParameter(std::string("Services") + "." + std::to_string(dep1 + 1) + ".Version", services[dep1].version);
+    setParameter(std::string("Services") + "." + std::to_string(dep1 + 1) + ".GroupName", services[dep1].groupName);
+  }
+}
+
+AddGatewayRouteRequest::Predicates AddGatewayRouteRequest::getPredicates() const {
+  return predicates_;
+}
+
+void AddGatewayRouteRequest::setPredicates(const AddGatewayRouteRequest::Predicates &predicates) {
+  predicates_ = predicates;
+  setParameter(std::string("Predicates") + ".PathPredicates.Path", predicates.pathPredicates.path);
+  setParameter(std::string("Predicates") + ".PathPredicates.IgnoreCase", predicates.pathPredicates.ignoreCase ? "true" : "false");
+  setParameter(std::string("Predicates") + ".PathPredicates.Type", predicates.pathPredicates.type);
+  for(int dep1 = 0; dep1 != predicates.methodPredicates.size(); dep1++) {
+    setParameter(std::string("Predicates") + ".MethodPredicates." + std::to_string(dep1 + 1), predicates.methodPredicates[dep1]);
+  }
+  for(int dep1 = 0; dep1 != predicates.headerPredicates.size(); dep1++) {
+    setParameter(std::string("Predicates") + ".HeaderPredicates." + std::to_string(dep1 + 1) + ".Type", predicates.headerPredicates[dep1].type);
+    setParameter(std::string("Predicates") + ".HeaderPredicates." + std::to_string(dep1 + 1) + ".Value", predicates.headerPredicates[dep1].value);
+    setParameter(std::string("Predicates") + ".HeaderPredicates." + std::to_string(dep1 + 1) + ".Key", predicates.headerPredicates[dep1].key);
+  }
+  for(int dep1 = 0; dep1 != predicates.queryPredicates.size(); dep1++) {
+    setParameter(std::string("Predicates") + ".QueryPredicates." + std::to_string(dep1 + 1) + ".Type", predicates.queryPredicates[dep1].type);
+    setParameter(std::string("Predicates") + ".QueryPredicates." + std::to_string(dep1 + 1) + ".Value", predicates.queryPredicates[dep1].value);
+    setParameter(std::string("Predicates") + ".QueryPredicates." + std::to_string(dep1 + 1) + ".Key", predicates.queryPredicates[dep1].key);
+  }
+}
+
+AddGatewayRouteRequest::RedirectJSON AddGatewayRouteRequest::getRedirectJSON() const {
+  return redirectJSON_;
+}
+
+void AddGatewayRouteRequest::setRedirectJSON(const AddGatewayRouteRequest::RedirectJSON &redirectJSON) {
+  redirectJSON_ = redirectJSON;
+  setParameter(std::string("RedirectJSON") + ".Path", redirectJSON.path);
+  setParameter(std::string("RedirectJSON") + ".Code", std::to_string(redirectJSON.code));
+  setParameter(std::string("RedirectJSON") + ".Host", redirectJSON.host);
+}
+
+AddGatewayRouteRequest::DirectResponseJSON AddGatewayRouteRequest::getDirectResponseJSON() const {
+  return directResponseJSON_;
+}
+
+void AddGatewayRouteRequest::setDirectResponseJSON(const AddGatewayRouteRequest::DirectResponseJSON &directResponseJSON) {
+  directResponseJSON_ = directResponseJSON;
+  setParameter(std::string("DirectResponseJSON") + ".Code", std::to_string(directResponseJSON.code));
+  setParameter(std::string("DirectResponseJSON") + ".Body", directResponseJSON.body);
+}
+
+std::string AddGatewayRouteRequest::getName() const {
+  return name_;
+}
+
+void AddGatewayRouteRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+std::string AddGatewayRouteRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void AddGatewayRouteRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+

mse/src/model/AddGatewayRouteResult.cc

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/AddGatewayRouteResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+AddGatewayRouteResult::AddGatewayRouteResult() :
+	ServiceResult()
+{}
+
+AddGatewayRouteResult::AddGatewayRouteResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AddGatewayRouteResult::~AddGatewayRouteResult()
+{}
+
+void AddGatewayRouteResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Data"].isNull())
+		data_ = std::stol(value["Data"].asString());
+
+}
+
+std::string AddGatewayRouteResult::getMessage()const
+{
+	return message_;
+}
+
+int AddGatewayRouteResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+long AddGatewayRouteResult::getData()const
+{
+	return data_;
+}
+
+int AddGatewayRouteResult::getCode()const
+{
+	return code_;
+}
+
+bool AddGatewayRouteResult::getSuccess()const
+{
+	return success_;
+}
+

mse/src/model/ApplyGatewayRouteRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/ApplyGatewayRouteRequest.h>
+
+using AlibabaCloud::Mse::Model::ApplyGatewayRouteRequest;
+
+ApplyGatewayRouteRequest::ApplyGatewayRouteRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "ApplyGatewayRoute") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+ApplyGatewayRouteRequest::~ApplyGatewayRouteRequest() {}
+
+std::string ApplyGatewayRouteRequest::getGatewayUniqueId() const {
+  return gatewayUniqueId_;
+}
+
+void ApplyGatewayRouteRequest::setGatewayUniqueId(const std::string &gatewayUniqueId) {
+  gatewayUniqueId_ = gatewayUniqueId;
+  setParameter(std::string("GatewayUniqueId"), gatewayUniqueId);
+}
+
+std::string ApplyGatewayRouteRequest::getRouteId() const {
+  return routeId_;
+}
+
+void ApplyGatewayRouteRequest::setRouteId(const std::string &routeId) {
+  routeId_ = routeId;
+  setParameter(std::string("RouteId"), routeId);
+}
+
+std::string ApplyGatewayRouteRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void ApplyGatewayRouteRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+

mse/src/model/ApplyGatewayRouteResult.cc

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/ApplyGatewayRouteResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+ApplyGatewayRouteResult::ApplyGatewayRouteResult() :
+	ServiceResult()
+{}
+
+ApplyGatewayRouteResult::ApplyGatewayRouteResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ApplyGatewayRouteResult::~ApplyGatewayRouteResult()
+{}
+
+void ApplyGatewayRouteResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString() == "true";
+
+}
+
+std::string ApplyGatewayRouteResult::getMessage()const
+{
+	return message_;
+}
+
+int ApplyGatewayRouteResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+bool ApplyGatewayRouteResult::getData()const
+{
+	return data_;
+}
+
+int ApplyGatewayRouteResult::getCode()const
+{
+	return code_;
+}
+
+bool ApplyGatewayRouteResult::getSuccess()const
+{
+	return success_;
+}
+

mse/src/model/ApplyTagPoliciesRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/ApplyTagPoliciesRequest.h>
+
+using AlibabaCloud::Mse::Model::ApplyTagPoliciesRequest;
+
+ApplyTagPoliciesRequest::ApplyTagPoliciesRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "ApplyTagPolicies") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ApplyTagPoliciesRequest::~ApplyTagPoliciesRequest() {}
+
+std::string ApplyTagPoliciesRequest::getRules() const {
+  return rules_;
+}
+
+void ApplyTagPoliciesRequest::setRules(const std::string &rules) {
+  rules_ = rules;
+  setParameter(std::string("Rules"), rules);
+}
+
+std::string ApplyTagPoliciesRequest::getSource() const {
+  return source_;
+}
+
+void ApplyTagPoliciesRequest::setSource(const std::string &source) {
+  source_ = source;
+  setParameter(std::string("Source"), source);
+}
+
+std::string ApplyTagPoliciesRequest::getNamespaceId() const {
+  return namespaceId_;
+}
+
+void ApplyTagPoliciesRequest::setNamespaceId(const std::string &namespaceId) {
+  namespaceId_ = namespaceId;
+  setParameter(std::string("NamespaceId"), namespaceId);
+}
+
+bool ApplyTagPoliciesRequest::getEnable() const {
+  return enable_;
+}
+
+void ApplyTagPoliciesRequest::setEnable(bool enable) {
+  enable_ = enable;
+  setParameter(std::string("Enable"), enable ? "true" : "false");
+}
+
+std::string ApplyTagPoliciesRequest::getAppId() const {
+  return appId_;
+}
+
+void ApplyTagPoliciesRequest::setAppId(const std::string &appId) {
+  appId_ = appId;
+  setParameter(std::string("AppId"), appId);
+}
+
+std::string ApplyTagPoliciesRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void ApplyTagPoliciesRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+
+std::string ApplyTagPoliciesRequest::getRegion() const {
+  return region_;
+}
+
+void ApplyTagPoliciesRequest::setRegion(const std::string &region) {
+  region_ = region;
+  setParameter(std::string("Region"), region);
+}
+

mse/src/model/ApplyTagPoliciesResult.cc

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/ApplyTagPoliciesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+ApplyTagPoliciesResult::ApplyTagPoliciesResult() :
+	ServiceResult()
+{}
+
+ApplyTagPoliciesResult::ApplyTagPoliciesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ApplyTagPoliciesResult::~ApplyTagPoliciesResult()
+{}
+
+void ApplyTagPoliciesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["RouteRuleVO"];
+	for (auto valueDataRouteRuleVO : allDataNode)
+	{
+		RouteRuleVO dataObject;
+		if(!valueDataRouteRuleVO["Status"].isNull())
+			dataObject.status = std::stoi(valueDataRouteRuleVO["Status"].asString());
+		if(!valueDataRouteRuleVO["InstanceNum"].isNull())
+			dataObject.instanceNum = std::stoi(valueDataRouteRuleVO["InstanceNum"].asString());
+		if(!valueDataRouteRuleVO["Remove"].isNull())
+			dataObject.remove = valueDataRouteRuleVO["Remove"].asString() == "true";
+		if(!valueDataRouteRuleVO["CarryData"].isNull())
+			dataObject.carryData = valueDataRouteRuleVO["CarryData"].asString() == "true";
+		if(!valueDataRouteRuleVO["Tag"].isNull())
+			dataObject.tag = valueDataRouteRuleVO["Tag"].asString();
+		if(!valueDataRouteRuleVO["Name"].isNull())
+			dataObject.name = valueDataRouteRuleVO["Name"].asString();
+		if(!valueDataRouteRuleVO["Rules"].isNull())
+			dataObject.rules = valueDataRouteRuleVO["Rules"].asString();
+		if(!valueDataRouteRuleVO["Id"].isNull())
+			dataObject.id = std::stol(valueDataRouteRuleVO["Id"].asString());
+		if(!valueDataRouteRuleVO["Rate"].isNull())
+			dataObject.rate = std::stoi(valueDataRouteRuleVO["Rate"].asString());
+		if(!valueDataRouteRuleVO["Enable"].isNull())
+			dataObject.enable = valueDataRouteRuleVO["Enable"].asString() == "true";
+		data_.push_back(dataObject);
+	}
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string ApplyTagPoliciesResult::getMessage()const
+{
+	return message_;
+}
+
+int ApplyTagPoliciesResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::vector<ApplyTagPoliciesResult::RouteRuleVO> ApplyTagPoliciesResult::getData()const
+{
+	return data_;
+}
+
+int ApplyTagPoliciesResult::getCode()const
+{
+	return code_;
+}
+
+bool ApplyTagPoliciesResult::getSuccess()const
+{
+	return success_;
+}
+

mse/src/model/CreateOrUpdateSwimmingLaneGroupRequest.cc

@@ -0,0 +1,144 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/CreateOrUpdateSwimmingLaneGroupRequest.h>
+
+using AlibabaCloud::Mse::Model::CreateOrUpdateSwimmingLaneGroupRequest;
+
+CreateOrUpdateSwimmingLaneGroupRequest::CreateOrUpdateSwimmingLaneGroupRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "CreateOrUpdateSwimmingLaneGroup") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateOrUpdateSwimmingLaneGroupRequest::~CreateOrUpdateSwimmingLaneGroupRequest() {}
+
+std::string CreateOrUpdateSwimmingLaneGroupRequest::getSource() const {
+  return source_;
+}
+
+void CreateOrUpdateSwimmingLaneGroupRequest::setSource(const std::string &source) {
+  source_ = source;
+  setParameter(std::string("Source"), source);
+}
+
+std::string CreateOrUpdateSwimmingLaneGroupRequest::getGmtModified() const {
+  return gmtModified_;
+}
+
+void CreateOrUpdateSwimmingLaneGroupRequest::setGmtModified(const std::string &gmtModified) {
+  gmtModified_ = gmtModified;
+  setParameter(std::string("GmtModified"), gmtModified);
+}
+
+std::string CreateOrUpdateSwimmingLaneGroupRequest::getUserId() const {
+  return userId_;
+}
+
+void CreateOrUpdateSwimmingLaneGroupRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+std::string CreateOrUpdateSwimmingLaneGroupRequest::getLicenseKey() const {
+  return licenseKey_;
+}
+
+void CreateOrUpdateSwimmingLaneGroupRequest::setLicenseKey(const std::string &licenseKey) {
+  licenseKey_ = licenseKey;
+  setParameter(std::string("LicenseKey"), licenseKey);
+}
+
+std::string CreateOrUpdateSwimmingLaneGroupRequest::getAppIds() const {
+  return appIds_;
+}
+
+void CreateOrUpdateSwimmingLaneGroupRequest::setAppIds(const std::string &appIds) {
+  appIds_ = appIds;
+  setParameter(std::string("AppIds"), appIds);
+}
+
+bool CreateOrUpdateSwimmingLaneGroupRequest::getEnable() const {
+  return enable_;
+}
+
+void CreateOrUpdateSwimmingLaneGroupRequest::setEnable(bool enable) {
+  enable_ = enable;
+  setParameter(std::string("Enable"), enable ? "true" : "false");
+}
+
+std::string CreateOrUpdateSwimmingLaneGroupRequest::getEntryApp() const {
+  return entryApp_;
+}
+
+void CreateOrUpdateSwimmingLaneGroupRequest::setEntryApp(const std::string &entryApp) {
+  entryApp_ = entryApp;
+  setParameter(std::string("EntryApp"), entryApp);
+}
+
+long CreateOrUpdateSwimmingLaneGroupRequest::getId() const {
+  return id_;
+}
+
+void CreateOrUpdateSwimmingLaneGroupRequest::setId(long id) {
+  id_ = id;
+  setParameter(std::string("Id"), std::to_string(id));
+}
+
+std::string CreateOrUpdateSwimmingLaneGroupRequest::getGmtCreate() const {
+  return gmtCreate_;
+}
+
+void CreateOrUpdateSwimmingLaneGroupRequest::setGmtCreate(const std::string &gmtCreate) {
+  gmtCreate_ = gmtCreate;
+  setParameter(std::string("GmtCreate"), gmtCreate);
+}
+
+std::string CreateOrUpdateSwimmingLaneGroupRequest::getName() const {
+  return name_;
+}
+
+void CreateOrUpdateSwimmingLaneGroupRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+std::string CreateOrUpdateSwimmingLaneGroupRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void CreateOrUpdateSwimmingLaneGroupRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+
+std::string CreateOrUpdateSwimmingLaneGroupRequest::getRegion() const {
+  return region_;
+}
+
+void CreateOrUpdateSwimmingLaneGroupRequest::setRegion(const std::string &region) {
+  region_ = region;
+  setParameter(std::string("Region"), region);
+}
+
+int CreateOrUpdateSwimmingLaneGroupRequest::getStatus() const {
+  return status_;
+}
+
+void CreateOrUpdateSwimmingLaneGroupRequest::setStatus(int status) {
+  status_ = status;
+  setParameter(std::string("Status"), std::to_string(status));
+}
+

mse/src/model/CreateOrUpdateSwimmingLaneGroupResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/CreateOrUpdateSwimmingLaneGroupResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+CreateOrUpdateSwimmingLaneGroupResult::CreateOrUpdateSwimmingLaneGroupResult() :
+	ServiceResult()
+{}
+
+CreateOrUpdateSwimmingLaneGroupResult::CreateOrUpdateSwimmingLaneGroupResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateOrUpdateSwimmingLaneGroupResult::~CreateOrUpdateSwimmingLaneGroupResult()
+{}
+
+void CreateOrUpdateSwimmingLaneGroupResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

mse/src/model/CreateOrUpdateSwimmingLaneRequest.cc

@@ -0,0 +1,191 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/CreateOrUpdateSwimmingLaneRequest.h>
+
+using AlibabaCloud::Mse::Model::CreateOrUpdateSwimmingLaneRequest;
+
+CreateOrUpdateSwimmingLaneRequest::CreateOrUpdateSwimmingLaneRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "CreateOrUpdateSwimmingLane") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateOrUpdateSwimmingLaneRequest::~CreateOrUpdateSwimmingLaneRequest() {}
+
+std::string CreateOrUpdateSwimmingLaneRequest::getSource() const {
+  return source_;
+}
+
+void CreateOrUpdateSwimmingLaneRequest::setSource(const std::string &source) {
+  source_ = source;
+  setParameter(std::string("Source"), source);
+}
+
+std::string CreateOrUpdateSwimmingLaneRequest::getGmtModified() const {
+  return gmtModified_;
+}
+
+void CreateOrUpdateSwimmingLaneRequest::setGmtModified(const std::string &gmtModified) {
+  gmtModified_ = gmtModified;
+  setParameter(std::string("GmtModified"), gmtModified);
+}
+
+std::string CreateOrUpdateSwimmingLaneRequest::getUserId() const {
+  return userId_;
+}
+
+void CreateOrUpdateSwimmingLaneRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+std::string CreateOrUpdateSwimmingLaneRequest::getLicenseKey() const {
+  return licenseKey_;
+}
+
+void CreateOrUpdateSwimmingLaneRequest::setLicenseKey(const std::string &licenseKey) {
+  licenseKey_ = licenseKey;
+  setParameter(std::string("LicenseKey"), licenseKey);
+}
+
+std::string CreateOrUpdateSwimmingLaneRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateOrUpdateSwimmingLaneRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateOrUpdateSwimmingLaneRequest::getEntryRule() const {
+  return entryRule_;
+}
+
+void CreateOrUpdateSwimmingLaneRequest::setEntryRule(const std::string &entryRule) {
+  entryRule_ = entryRule;
+  setParameter(std::string("EntryRule"), entryRule);
+}
+
+bool CreateOrUpdateSwimmingLaneRequest::getEnable() const {
+  return enable_;
+}
+
+void CreateOrUpdateSwimmingLaneRequest::setEnable(bool enable) {
+  enable_ = enable;
+  setParameter(std::string("Enable"), enable ? "true" : "false");
+}
+
+long CreateOrUpdateSwimmingLaneRequest::getId() const {
+  return id_;
+}
+
+void CreateOrUpdateSwimmingLaneRequest::setId(long id) {
+  id_ = id;
+  setParameter(std::string("Id"), std::to_string(id));
+}
+
+std::string CreateOrUpdateSwimmingLaneRequest::getTag() const {
+  return tag_;
+}
+
+void CreateOrUpdateSwimmingLaneRequest::setTag(const std::string &tag) {
+  tag_ = tag;
+  setParameter(std::string("Tag"), tag);
+}
+
+std::vector<CreateOrUpdateSwimmingLaneRequest::EntryRules> CreateOrUpdateSwimmingLaneRequest::getEntryRules() const {
+  return entryRules_;
+}
+
+void CreateOrUpdateSwimmingLaneRequest::setEntryRules(const std::vector<CreateOrUpdateSwimmingLaneRequest::EntryRules> &entryRules) {
+  entryRules_ = entryRules;
+  for(int dep1 = 0; dep1 != entryRules.size(); dep1++) {
+  auto entryRulesObj = entryRules.at(dep1);
+  std::string entryRulesObjStr = std::string("EntryRules") + "." + std::to_string(dep1 + 1);
+    for(int dep2 = 0; dep2 != entryRulesObj.restItems.size(); dep2++) {
+    auto restItemsObj = entryRulesObj.restItems.at(dep2);
+    std::string restItemsObjStr = entryRulesObjStr + ".RestItems" + "." + std::to_string(dep2 + 1);
+      setParameter(restItemsObjStr + ".Datum", restItemsObj.datum);
+      setParameter(restItemsObjStr + ".Divisor", std::to_string(restItemsObj.divisor));
+      setParameter(restItemsObjStr + ".Rate", std::to_string(restItemsObj.rate));
+      setParameter(restItemsObjStr + ".Name", restItemsObj.name);
+      setParameter(restItemsObjStr + ".Type", restItemsObj.type);
+      setParameter(restItemsObjStr + ".Cond", restItemsObj.cond);
+      setParameter(restItemsObjStr + ".Remainder", std::to_string(restItemsObj.remainder));
+      setParameter(restItemsObjStr + ".Value", restItemsObj.value);
+      setParameter(restItemsObjStr + ".Operator", restItemsObj._operator);
+    }
+    setParameter(entryRulesObjStr + ".Path", entryRulesObj.path);
+    setParameter(entryRulesObjStr + ".Condition", entryRulesObj.condition);
+    setParameter(entryRulesObjStr + ".Enable", entryRulesObj.enable ? "true" : "false");
+    setParameter(entryRulesObjStr + ".Priority", std::to_string(entryRulesObj.priority));
+  }
+}
+
+long CreateOrUpdateSwimmingLaneRequest::getGroupId() const {
+  return groupId_;
+}
+
+void CreateOrUpdateSwimmingLaneRequest::setGroupId(long groupId) {
+  groupId_ = groupId;
+  setParameter(std::string("GroupId"), std::to_string(groupId));
+}
+
+std::string CreateOrUpdateSwimmingLaneRequest::getGmtCreate() const {
+  return gmtCreate_;
+}
+
+void CreateOrUpdateSwimmingLaneRequest::setGmtCreate(const std::string &gmtCreate) {
+  gmtCreate_ = gmtCreate;
+  setParameter(std::string("GmtCreate"), gmtCreate);
+}
+
+bool CreateOrUpdateSwimmingLaneRequest::getEnableRules() const {
+  return enableRules_;
+}
+
+void CreateOrUpdateSwimmingLaneRequest::setEnableRules(bool enableRules) {
+  enableRules_ = enableRules;
+  setParameter(std::string("EnableRules"), enableRules ? "true" : "false");
+}
+
+std::string CreateOrUpdateSwimmingLaneRequest::getName() const {
+  return name_;
+}
+
+void CreateOrUpdateSwimmingLaneRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+std::string CreateOrUpdateSwimmingLaneRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void CreateOrUpdateSwimmingLaneRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+
+int CreateOrUpdateSwimmingLaneRequest::getStatus() const {
+  return status_;
+}
+
+void CreateOrUpdateSwimmingLaneRequest::setStatus(int status) {
+  status_ = status;
+  setParameter(std::string("Status"), std::to_string(status));
+}
+

mse/src/model/CreateOrUpdateSwimmingLaneResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/CreateOrUpdateSwimmingLaneResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+CreateOrUpdateSwimmingLaneResult::CreateOrUpdateSwimmingLaneResult() :
+	ServiceResult()
+{}
+
+CreateOrUpdateSwimmingLaneResult::CreateOrUpdateSwimmingLaneResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateOrUpdateSwimmingLaneResult::~CreateOrUpdateSwimmingLaneResult()
+{}
+
+void CreateOrUpdateSwimmingLaneResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

mse/src/model/DeleteGatewayRouteRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/DeleteGatewayRouteRequest.h>
+
+using AlibabaCloud::Mse::Model::DeleteGatewayRouteRequest;
+
+DeleteGatewayRouteRequest::DeleteGatewayRouteRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "DeleteGatewayRoute") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DeleteGatewayRouteRequest::~DeleteGatewayRouteRequest() {}
+
+std::string DeleteGatewayRouteRequest::getGatewayUniqueId() const {
+  return gatewayUniqueId_;
+}
+
+void DeleteGatewayRouteRequest::setGatewayUniqueId(const std::string &gatewayUniqueId) {
+  gatewayUniqueId_ = gatewayUniqueId;
+  setParameter(std::string("GatewayUniqueId"), gatewayUniqueId);
+}
+
+std::string DeleteGatewayRouteRequest::getRouteId() const {
+  return routeId_;
+}
+
+void DeleteGatewayRouteRequest::setRouteId(const std::string &routeId) {
+  routeId_ = routeId;
+  setParameter(std::string("RouteId"), routeId);
+}
+
+std::string DeleteGatewayRouteRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void DeleteGatewayRouteRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+

mse/src/model/DeleteGatewayRouteResult.cc

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/DeleteGatewayRouteResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+DeleteGatewayRouteResult::DeleteGatewayRouteResult() :
+	ServiceResult()
+{}
+
+DeleteGatewayRouteResult::DeleteGatewayRouteResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteGatewayRouteResult::~DeleteGatewayRouteResult()
+{}
+
+void DeleteGatewayRouteResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["Id"].isNull())
+		data_.id = std::stol(dataNode["Id"].asString());
+	if(!dataNode["Name"].isNull())
+		data_.name = dataNode["Name"].asString();
+	if(!dataNode["GatewayUniqueId"].isNull())
+		data_.gatewayUniqueId = dataNode["GatewayUniqueId"].asString();
+	if(!dataNode["GatewayId"].isNull())
+		data_.gatewayId = std::stol(dataNode["GatewayId"].asString());
+	if(!dataNode["Predicates"].isNull())
+		data_.predicates = dataNode["Predicates"].asString();
+	if(!dataNode["DefaultServiceId"].isNull())
+		data_.defaultServiceId = std::stol(dataNode["DefaultServiceId"].asString());
+	if(!dataNode["RouteOrder"].isNull())
+		data_.routeOrder = std::stoi(dataNode["RouteOrder"].asString());
+	if(!dataNode["Status"].isNull())
+		data_.status = std::stoi(dataNode["Status"].asString());
+	if(!dataNode["GmtCreate"].isNull())
+		data_.gmtCreate = dataNode["GmtCreate"].asString();
+	if(!dataNode["GmtModified"].isNull())
+		data_.gmtModified = dataNode["GmtModified"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string DeleteGatewayRouteResult::getMessage()const
+{
+	return message_;
+}
+
+int DeleteGatewayRouteResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+DeleteGatewayRouteResult::Data DeleteGatewayRouteResult::getData()const
+{
+	return data_;
+}
+
+int DeleteGatewayRouteResult::getCode()const
+{
+	return code_;
+}
+
+bool DeleteGatewayRouteResult::getSuccess()const
+{
+	return success_;
+}
+

mse/src/model/DeleteNacosInstanceRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/DeleteNacosInstanceRequest.h>
+
+using AlibabaCloud::Mse::Model::DeleteNacosInstanceRequest;
+
+DeleteNacosInstanceRequest::DeleteNacosInstanceRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "DeleteNacosInstance") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteNacosInstanceRequest::~DeleteNacosInstanceRequest() {}
+
+std::string DeleteNacosInstanceRequest::getClusterName() const {
+  return clusterName_;
+}
+
+void DeleteNacosInstanceRequest::setClusterName(const std::string &clusterName) {
+  clusterName_ = clusterName;
+  setParameter(std::string("ClusterName"), clusterName);
+}
+
+std::string DeleteNacosInstanceRequest::getIp() const {
+  return ip_;
+}
+
+void DeleteNacosInstanceRequest::setIp(const std::string &ip) {
+  ip_ = ip;
+  setParameter(std::string("Ip"), ip);
+}
+
+bool DeleteNacosInstanceRequest::getEphemeral() const {
+  return ephemeral_;
+}
+
+void DeleteNacosInstanceRequest::setEphemeral(bool ephemeral) {
+  ephemeral_ = ephemeral;
+  setParameter(std::string("Ephemeral"), ephemeral ? "true" : "false");
+}
+
+std::string DeleteNacosInstanceRequest::getGroupName() const {
+  return groupName_;
+}
+
+void DeleteNacosInstanceRequest::setGroupName(const std::string &groupName) {
+  groupName_ = groupName;
+  setParameter(std::string("GroupName"), groupName);
+}
+
+std::string DeleteNacosInstanceRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void DeleteNacosInstanceRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+
+std::string DeleteNacosInstanceRequest::getNamespaceId() const {
+  return namespaceId_;
+}
+
+void DeleteNacosInstanceRequest::setNamespaceId(const std::string &namespaceId) {
+  namespaceId_ = namespaceId;
+  setParameter(std::string("NamespaceId"), namespaceId);
+}
+
+int DeleteNacosInstanceRequest::getPort() const {
+  return port_;
+}
+
+void DeleteNacosInstanceRequest::setPort(int port) {
+  port_ = port;
+  setParameter(std::string("Port"), std::to_string(port));
+}
+
+std::string DeleteNacosInstanceRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void DeleteNacosInstanceRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+
+std::string DeleteNacosInstanceRequest::getServiceName() const {
+  return serviceName_;
+}
+
+void DeleteNacosInstanceRequest::setServiceName(const std::string &serviceName) {
+  serviceName_ = serviceName;
+  setParameter(std::string("ServiceName"), serviceName);
+}
+

mse/src/model/DeleteNacosInstanceResult.cc

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/DeleteNacosInstanceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+DeleteNacosInstanceResult::DeleteNacosInstanceResult() :
+	ServiceResult()
+{}
+
+DeleteNacosInstanceResult::DeleteNacosInstanceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteNacosInstanceResult::~DeleteNacosInstanceResult()
+{}
+
+void DeleteNacosInstanceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
+
+}
+
+std::string DeleteNacosInstanceResult::getMessage()const
+{
+	return message_;
+}
+
+int DeleteNacosInstanceResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string DeleteNacosInstanceResult::getData()const
+{
+	return data_;
+}
+
+std::string DeleteNacosInstanceResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string DeleteNacosInstanceResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+
+int DeleteNacosInstanceResult::getCode()const
+{
+	return code_;
+}
+
+bool DeleteNacosInstanceResult::getSuccess()const
+{
+	return success_;
+}
+

mse/src/model/DeleteSwimmingLaneGroupRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/DeleteSwimmingLaneGroupRequest.h>
+
+using AlibabaCloud::Mse::Model::DeleteSwimmingLaneGroupRequest;
+
+DeleteSwimmingLaneGroupRequest::DeleteSwimmingLaneGroupRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "DeleteSwimmingLaneGroup") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteSwimmingLaneGroupRequest::~DeleteSwimmingLaneGroupRequest() {}
+
+long DeleteSwimmingLaneGroupRequest::getGroupId() const {
+  return groupId_;
+}
+
+void DeleteSwimmingLaneGroupRequest::setGroupId(long groupId) {
+  groupId_ = groupId;
+  setParameter(std::string("GroupId"), std::to_string(groupId));
+}
+
+std::string DeleteSwimmingLaneGroupRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void DeleteSwimmingLaneGroupRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+

mse/src/model/DeleteSwimmingLaneGroupResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/DeleteSwimmingLaneGroupResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+DeleteSwimmingLaneGroupResult::DeleteSwimmingLaneGroupResult() :
+	ServiceResult()
+{}
+
+DeleteSwimmingLaneGroupResult::DeleteSwimmingLaneGroupResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteSwimmingLaneGroupResult::~DeleteSwimmingLaneGroupResult()
+{}
+
+void DeleteSwimmingLaneGroupResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

mse/src/model/DeleteSwimmingLaneRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/DeleteSwimmingLaneRequest.h>
+
+using AlibabaCloud::Mse::Model::DeleteSwimmingLaneRequest;
+
+DeleteSwimmingLaneRequest::DeleteSwimmingLaneRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "DeleteSwimmingLane") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteSwimmingLaneRequest::~DeleteSwimmingLaneRequest() {}
+
+long DeleteSwimmingLaneRequest::getLaneId() const {
+  return laneId_;
+}
+
+void DeleteSwimmingLaneRequest::setLaneId(long laneId) {
+  laneId_ = laneId;
+  setParameter(std::string("LaneId"), std::to_string(laneId));
+}
+
+std::string DeleteSwimmingLaneRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void DeleteSwimmingLaneRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+

mse/src/model/DeleteSwimmingLaneResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/DeleteSwimmingLaneResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+DeleteSwimmingLaneResult::DeleteSwimmingLaneResult() :
+	ServiceResult()
+{}
+
+DeleteSwimmingLaneResult::DeleteSwimmingLaneResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteSwimmingLaneResult::~DeleteSwimmingLaneResult()
+{}
+
+void DeleteSwimmingLaneResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

mse/src/model/GetGatewayRouteDetailRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/GetGatewayRouteDetailRequest.h>
+
+using AlibabaCloud::Mse::Model::GetGatewayRouteDetailRequest;
+
+GetGatewayRouteDetailRequest::GetGatewayRouteDetailRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "GetGatewayRouteDetail") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetGatewayRouteDetailRequest::~GetGatewayRouteDetailRequest() {}
+
+std::string GetGatewayRouteDetailRequest::getGatewayUniqueId() const {
+  return gatewayUniqueId_;
+}
+
+void GetGatewayRouteDetailRequest::setGatewayUniqueId(const std::string &gatewayUniqueId) {
+  gatewayUniqueId_ = gatewayUniqueId;
+  setParameter(std::string("GatewayUniqueId"), gatewayUniqueId);
+}
+
+long GetGatewayRouteDetailRequest::getRouteId() const {
+  return routeId_;
+}
+
+void GetGatewayRouteDetailRequest::setRouteId(long routeId) {
+  routeId_ = routeId;
+  setParameter(std::string("RouteId"), std::to_string(routeId));
+}
+
+std::string GetGatewayRouteDetailRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void GetGatewayRouteDetailRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+

mse/src/model/GetGatewayRouteDetailResult.cc

@@ -0,0 +1,248 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/GetGatewayRouteDetailResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+GetGatewayRouteDetailResult::GetGatewayRouteDetailResult() :
+	ServiceResult()
+{}
+
+GetGatewayRouteDetailResult::GetGatewayRouteDetailResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetGatewayRouteDetailResult::~GetGatewayRouteDetailResult()
+{}
+
+void GetGatewayRouteDetailResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["Id"].isNull())
+		data_.id = std::stol(dataNode["Id"].asString());
+	if(!dataNode["Name"].isNull())
+		data_.name = dataNode["Name"].asString();
+	if(!dataNode["GatewayUniqueId"].isNull())
+		data_.gatewayUniqueId = dataNode["GatewayUniqueId"].asString();
+	if(!dataNode["GatewayId"].isNull())
+		data_.gatewayId = std::stol(dataNode["GatewayId"].asString());
+	if(!dataNode["DefaultServiceId"].isNull())
+		data_.defaultServiceId = std::stol(dataNode["DefaultServiceId"].asString());
+	if(!dataNode["DefaultServiceName"].isNull())
+		data_.defaultServiceName = dataNode["DefaultServiceName"].asString();
+	if(!dataNode["Status"].isNull())
+		data_.status = std::stoi(dataNode["Status"].asString());
+	if(!dataNode["GmtCreate"].isNull())
+		data_.gmtCreate = dataNode["GmtCreate"].asString();
+	if(!dataNode["GmtModified"].isNull())
+		data_.gmtModified = dataNode["GmtModified"].asString();
+	if(!dataNode["RouteOrder"].isNull())
+		data_.routeOrder = std::stoi(dataNode["RouteOrder"].asString());
+	if(!dataNode["Predicates"].isNull())
+		data_.predicates = dataNode["Predicates"].asString();
+	if(!dataNode["DomainId"].isNull())
+		data_.domainId = std::stol(dataNode["DomainId"].asString());
+	if(!dataNode["DomainName"].isNull())
+		data_.domainName = dataNode["DomainName"].asString();
+	if(!dataNode["Services"].isNull())
+		data_.services = dataNode["Services"].asString();
+	if(!dataNode["DestinationType"].isNull())
+		data_.destinationType = dataNode["DestinationType"].asString();
+	auto allRouteServicesNode = dataNode["RouteServices"]["RouteServicesItem"];
+	for (auto dataNodeRouteServicesRouteServicesItem : allRouteServicesNode)
+	{
+		Data::RouteServicesItem routeServicesItemObject;
+		if(!dataNodeRouteServicesRouteServicesItem["ServiceId"].isNull())
+			routeServicesItemObject.serviceId = std::stol(dataNodeRouteServicesRouteServicesItem["ServiceId"].asString());
+		if(!dataNodeRouteServicesRouteServicesItem["ServiceName"].isNull())
+			routeServicesItemObject.serviceName = dataNodeRouteServicesRouteServicesItem["ServiceName"].asString();
+		if(!dataNodeRouteServicesRouteServicesItem["Percent"].isNull())
+			routeServicesItemObject.percent = std::stoi(dataNodeRouteServicesRouteServicesItem["Percent"].asString());
+		if(!dataNodeRouteServicesRouteServicesItem["Version"].isNull())
+			routeServicesItemObject.version = dataNodeRouteServicesRouteServicesItem["Version"].asString();
+		if(!dataNodeRouteServicesRouteServicesItem["Name"].isNull())
+			routeServicesItemObject.name = dataNodeRouteServicesRouteServicesItem["Name"].asString();
+		if(!dataNodeRouteServicesRouteServicesItem["SourceType"].isNull())
+			routeServicesItemObject.sourceType = dataNodeRouteServicesRouteServicesItem["SourceType"].asString();
+		if(!dataNodeRouteServicesRouteServicesItem["Namespace"].isNull())
+			routeServicesItemObject._namespace = dataNodeRouteServicesRouteServicesItem["Namespace"].asString();
+		if(!dataNodeRouteServicesRouteServicesItem["GroupName"].isNull())
+			routeServicesItemObject.groupName = dataNodeRouteServicesRouteServicesItem["GroupName"].asString();
+		data_.routeServices.push_back(routeServicesItemObject);
+	}
+	auto routePredicatesNode = dataNode["RoutePredicates"];
+	auto allHeaderPredicatesNode = routePredicatesNode["HeaderPredicates"]["HeaderPredicatesItem"];
+	for (auto routePredicatesNodeHeaderPredicatesHeaderPredicatesItem : allHeaderPredicatesNode)
+	{
+		Data::RoutePredicates::HeaderPredicatesItem headerPredicatesItemObject;
+		if(!routePredicatesNodeHeaderPredicatesHeaderPredicatesItem["Key"].isNull())
+			headerPredicatesItemObject.key = routePredicatesNodeHeaderPredicatesHeaderPredicatesItem["Key"].asString();
+		if(!routePredicatesNodeHeaderPredicatesHeaderPredicatesItem["Value"].isNull())
+			headerPredicatesItemObject.value = routePredicatesNodeHeaderPredicatesHeaderPredicatesItem["Value"].asString();
+		if(!routePredicatesNodeHeaderPredicatesHeaderPredicatesItem["Type"].isNull())
+			headerPredicatesItemObject.type = routePredicatesNodeHeaderPredicatesHeaderPredicatesItem["Type"].asString();
+		data_.routePredicates.headerPredicates.push_back(headerPredicatesItemObject);
+	}
+	auto allQueryPredicatesNode = routePredicatesNode["QueryPredicates"]["QueryPredicatesItem"];
+	for (auto routePredicatesNodeQueryPredicatesQueryPredicatesItem : allQueryPredicatesNode)
+	{
+		Data::RoutePredicates::QueryPredicatesItem queryPredicatesItemObject;
+		if(!routePredicatesNodeQueryPredicatesQueryPredicatesItem["Key"].isNull())
+			queryPredicatesItemObject.key = routePredicatesNodeQueryPredicatesQueryPredicatesItem["Key"].asString();
+		if(!routePredicatesNodeQueryPredicatesQueryPredicatesItem["Value"].isNull())
+			queryPredicatesItemObject.value = routePredicatesNodeQueryPredicatesQueryPredicatesItem["Value"].asString();
+		if(!routePredicatesNodeQueryPredicatesQueryPredicatesItem["Type"].isNull())
+			queryPredicatesItemObject.type = routePredicatesNodeQueryPredicatesQueryPredicatesItem["Type"].asString();
+		data_.routePredicates.queryPredicates.push_back(queryPredicatesItemObject);
+	}
+	auto pathPredicatesNode = routePredicatesNode["PathPredicates"];
+	if(!pathPredicatesNode["Path"].isNull())
+		data_.routePredicates.pathPredicates.path = pathPredicatesNode["Path"].asString();
+	if(!pathPredicatesNode["Type"].isNull())
+		data_.routePredicates.pathPredicates.type = pathPredicatesNode["Type"].asString();
+	if(!pathPredicatesNode["IgnoreCase"].isNull())
+		data_.routePredicates.pathPredicates.ignoreCase = pathPredicatesNode["IgnoreCase"].asString() == "true";
+		auto allMethodPredicates = routePredicatesNode["MethodPredicates"]["MethodPredicates"];
+		for (auto value : allMethodPredicates)
+			data_.routePredicates.methodPredicates.push_back(value.asString());
+	auto hTTPRewriteNode = dataNode["HTTPRewrite"];
+	if(!hTTPRewriteNode["Status"].isNull())
+		data_.hTTPRewrite.status = hTTPRewriteNode["Status"].asString();
+	if(!hTTPRewriteNode["Path"].isNull())
+		data_.hTTPRewrite.path = hTTPRewriteNode["Path"].asString();
+	if(!hTTPRewriteNode["Host"].isNull())
+		data_.hTTPRewrite.host = hTTPRewriteNode["Host"].asString();
+	if(!hTTPRewriteNode["PathType"].isNull())
+		data_.hTTPRewrite.pathType = hTTPRewriteNode["PathType"].asString();
+	if(!hTTPRewriteNode["Pattern"].isNull())
+		data_.hTTPRewrite.pattern = hTTPRewriteNode["Pattern"].asString();
+	if(!hTTPRewriteNode["Substitution"].isNull())
+		data_.hTTPRewrite.substitution = hTTPRewriteNode["Substitution"].asString();
+	auto headerOpNode = dataNode["HeaderOp"];
+	if(!headerOpNode["Status"].isNull())
+		data_.headerOp.status = headerOpNode["Status"].asString();
+	auto allHeaderOpItemsNode = headerOpNode["HeaderOpItems"]["HeaderOpItemsItem"];
+	for (auto headerOpNodeHeaderOpItemsHeaderOpItemsItem : allHeaderOpItemsNode)
+	{
+		Data::HeaderOp::HeaderOpItemsItem headerOpItemsItemObject;
+		if(!headerOpNodeHeaderOpItemsHeaderOpItemsItem["DirectionType"].isNull())
+			headerOpItemsItemObject.directionType = headerOpNodeHeaderOpItemsHeaderOpItemsItem["DirectionType"].asString();
+		if(!headerOpNodeHeaderOpItemsHeaderOpItemsItem["OpType"].isNull())
+			headerOpItemsItemObject.opType = headerOpNodeHeaderOpItemsHeaderOpItemsItem["OpType"].asString();
+		if(!headerOpNodeHeaderOpItemsHeaderOpItemsItem["Key"].isNull())
+			headerOpItemsItemObject.key = headerOpNodeHeaderOpItemsHeaderOpItemsItem["Key"].asString();
+		if(!headerOpNodeHeaderOpItemsHeaderOpItemsItem["Value"].isNull())
+			headerOpItemsItemObject.value = headerOpNodeHeaderOpItemsHeaderOpItemsItem["Value"].asString();
+		data_.headerOp.headerOpItems.push_back(headerOpItemsItemObject);
+	}
+	auto directResponseNode = dataNode["DirectResponse"];
+	if(!directResponseNode["Code"].isNull())
+		data_.directResponse.code = std::stoi(directResponseNode["Code"].asString());
+	if(!directResponseNode["Body"].isNull())
+		data_.directResponse.body = directResponseNode["Body"].asString();
+	auto corsNode = dataNode["Cors"];
+	if(!corsNode["Status"].isNull())
+		data_.cors.status = corsNode["Status"].asString();
+	if(!corsNode["AllowOrigins"].isNull())
+		data_.cors.allowOrigins = corsNode["AllowOrigins"].asString();
+	if(!corsNode["AllowMethods"].isNull())
+		data_.cors.allowMethods = corsNode["AllowMethods"].asString();
+	if(!corsNode["AllowHeaders"].isNull())
+		data_.cors.allowHeaders = corsNode["AllowHeaders"].asString();
+	if(!corsNode["ExposeHeaders"].isNull())
+		data_.cors.exposeHeaders = corsNode["ExposeHeaders"].asString();
+	if(!corsNode["TimeUnit"].isNull())
+		data_.cors.timeUnit = corsNode["TimeUnit"].asString();
+	if(!corsNode["UnitNum"].isNull())
+		data_.cors.unitNum = std::stol(corsNode["UnitNum"].asString());
+	if(!corsNode["AllowCredentials"].isNull())
+		data_.cors.allowCredentials = corsNode["AllowCredentials"].asString() == "true";
+	auto timeoutNode = dataNode["Timeout"];
+	if(!timeoutNode["UnitNum"].isNull())
+		data_.timeout.unitNum = std::stoi(timeoutNode["UnitNum"].asString());
+	if(!timeoutNode["TimeUnit"].isNull())
+		data_.timeout.timeUnit = timeoutNode["TimeUnit"].asString();
+	if(!timeoutNode["Status"].isNull())
+		data_.timeout.status = timeoutNode["Status"].asString();
+	auto retryNode = dataNode["Retry"];
+	if(!retryNode["Attempts"].isNull())
+		data_.retry.attempts = std::stoi(retryNode["Attempts"].asString());
+	if(!retryNode["Status"].isNull())
+		data_.retry.status = retryNode["Status"].asString();
+		auto allRetryOn = retryNode["RetryOn"]["retryOn"];
+		for (auto value : allRetryOn)
+			data_.retry.retryOn.push_back(value.asString());
+		auto allHttpCodes = retryNode["HttpCodes"]["httpCodes"];
+		for (auto value : allHttpCodes)
+			data_.retry.httpCodes.push_back(value.asString());
+	auto redirectNode = dataNode["Redirect"];
+	if(!redirectNode["Code"].isNull())
+		data_.redirect.code = std::stoi(redirectNode["Code"].asString());
+	if(!redirectNode["Host"].isNull())
+		data_.redirect.host = redirectNode["Host"].asString();
+	if(!redirectNode["Path"].isNull())
+		data_.redirect.path = redirectNode["Path"].asString();
+		auto allDomainIdList = dataNode["DomainIdList"]["DomainIdList"];
+		for (auto value : allDomainIdList)
+			data_.domainIdList.push_back(value.asString());
+		auto allDomainNameList = dataNode["DomainNameList"]["DomainNameList"];
+		for (auto value : allDomainNameList)
+			data_.domainNameList.push_back(value.asString());
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string GetGatewayRouteDetailResult::getMessage()const
+{
+	return message_;
+}
+
+int GetGatewayRouteDetailResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+GetGatewayRouteDetailResult::Data GetGatewayRouteDetailResult::getData()const
+{
+	return data_;
+}
+
+int GetGatewayRouteDetailResult::getCode()const
+{
+	return code_;
+}
+
+bool GetGatewayRouteDetailResult::getSuccess()const
+{
+	return success_;
+}
+

mse/src/model/GetServiceListRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/GetServiceListRequest.h>
+
+using AlibabaCloud::Mse::Model::GetServiceListRequest;
+
+GetServiceListRequest::GetServiceListRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "GetServiceList") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetServiceListRequest::~GetServiceListRequest() {}
+
+std::string GetServiceListRequest::getServiceName() const {
+  return serviceName_;
+}
+
+void GetServiceListRequest::setServiceName(const std::string &serviceName) {
+  serviceName_ = serviceName;
+  setParameter(std::string("ServiceName"), serviceName);
+}
+
+std::string GetServiceListRequest::getIp() const {
+  return ip_;
+}
+
+void GetServiceListRequest::setIp(const std::string &ip) {
+  ip_ = ip;
+  setParameter(std::string("Ip"), ip);
+}
+
+std::string GetServiceListRequest::getServiceType() const {
+  return serviceType_;
+}
+
+void GetServiceListRequest::setServiceType(const std::string &serviceType) {
+  serviceType_ = serviceType;
+  setParameter(std::string("ServiceType"), serviceType);
+}
+
+std::string GetServiceListRequest::getAppId() const {
+  return appId_;
+}
+
+void GetServiceListRequest::setAppId(const std::string &appId) {
+  appId_ = appId;
+  setParameter(std::string("AppId"), appId);
+}
+
+std::string GetServiceListRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void GetServiceListRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+
+std::string GetServiceListRequest::getRegion() const {
+  return region_;
+}
+
+void GetServiceListRequest::setRegion(const std::string &region) {
+  region_ = region;
+  setParameter(std::string("Region"), region);
+}
+

mse/src/model/GetServiceListResult.cc

@@ -0,0 +1,122 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/GetServiceListResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+GetServiceListResult::GetServiceListResult() :
+	ServiceResult()
+{}
+
+GetServiceListResult::GetServiceListResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetServiceListResult::~GetServiceListResult()
+{}
+
+void GetServiceListResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["MscServiceDetailResponse"];
+	for (auto valueDataMscServiceDetailResponse : allDataNode)
+	{
+		MscServiceDetailResponse dataObject;
+		if(!valueDataMscServiceDetailResponse["EdasAppName"].isNull())
+			dataObject.edasAppName = valueDataMscServiceDetailResponse["EdasAppName"].asString();
+		if(!valueDataMscServiceDetailResponse["DubboApplicationName"].isNull())
+			dataObject.dubboApplicationName = valueDataMscServiceDetailResponse["DubboApplicationName"].asString();
+		if(!valueDataMscServiceDetailResponse["Version"].isNull())
+			dataObject.version = valueDataMscServiceDetailResponse["Version"].asString();
+		if(!valueDataMscServiceDetailResponse["SpringApplicationName"].isNull())
+			dataObject.springApplicationName = valueDataMscServiceDetailResponse["SpringApplicationName"].asString();
+		if(!valueDataMscServiceDetailResponse["RegistryType"].isNull())
+			dataObject.registryType = valueDataMscServiceDetailResponse["RegistryType"].asString();
+		if(!valueDataMscServiceDetailResponse["ServiceType"].isNull())
+			dataObject.serviceType = valueDataMscServiceDetailResponse["ServiceType"].asString();
+		if(!valueDataMscServiceDetailResponse["ServiceName"].isNull())
+			dataObject.serviceName = valueDataMscServiceDetailResponse["ServiceName"].asString();
+		if(!valueDataMscServiceDetailResponse["Metadata"].isNull())
+			dataObject.metadata = valueDataMscServiceDetailResponse["Metadata"].asString();
+		if(!valueDataMscServiceDetailResponse["Group"].isNull())
+			dataObject.group = valueDataMscServiceDetailResponse["Group"].asString();
+		auto allMethodsNode = valueDataMscServiceDetailResponse["Methods"]["Method"];
+		for (auto valueDataMscServiceDetailResponseMethodsMethod : allMethodsNode)
+		{
+			MscServiceDetailResponse::Method methodsObject;
+			if(!valueDataMscServiceDetailResponseMethodsMethod["Name"].isNull())
+				methodsObject.name = valueDataMscServiceDetailResponseMethodsMethod["Name"].asString();
+			if(!valueDataMscServiceDetailResponseMethodsMethod["MethodController"].isNull())
+				methodsObject.methodController = valueDataMscServiceDetailResponseMethodsMethod["MethodController"].asString();
+			if(!valueDataMscServiceDetailResponseMethodsMethod["ReturnType"].isNull())
+				methodsObject.returnType = valueDataMscServiceDetailResponseMethodsMethod["ReturnType"].asString();
+			auto allPaths = value["Paths"]["Path"];
+			for (auto value : allPaths)
+				methodsObject.paths.push_back(value.asString());
+			auto allParameterTypes = value["ParameterTypes"]["ParameterType"];
+			for (auto value : allParameterTypes)
+				methodsObject.parameterTypes.push_back(value.asString());
+			auto allRequestMethods = value["RequestMethods"]["RequestMethod"];
+			for (auto value : allRequestMethods)
+				methodsObject.requestMethods.push_back(value.asString());
+			dataObject.methods.push_back(methodsObject);
+		}
+		data_.push_back(dataObject);
+	}
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string GetServiceListResult::getMessage()const
+{
+	return message_;
+}
+
+int GetServiceListResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::vector<GetServiceListResult::MscServiceDetailResponse> GetServiceListResult::getData()const
+{
+	return data_;
+}
+
+int GetServiceListResult::getCode()const
+{
+	return code_;
+}
+
+bool GetServiceListResult::getSuccess()const
+{
+	return success_;
+}
+

mse/src/model/GetTagsBySwimmingLaneGroupIdRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/GetTagsBySwimmingLaneGroupIdRequest.h>
+
+using AlibabaCloud::Mse::Model::GetTagsBySwimmingLaneGroupIdRequest;
+
+GetTagsBySwimmingLaneGroupIdRequest::GetTagsBySwimmingLaneGroupIdRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "GetTagsBySwimmingLaneGroupId") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetTagsBySwimmingLaneGroupIdRequest::~GetTagsBySwimmingLaneGroupIdRequest() {}
+
+long GetTagsBySwimmingLaneGroupIdRequest::getGroupId() const {
+  return groupId_;
+}
+
+void GetTagsBySwimmingLaneGroupIdRequest::setGroupId(long groupId) {
+  groupId_ = groupId;
+  setParameter(std::string("GroupId"), std::to_string(groupId));
+}
+
+std::string GetTagsBySwimmingLaneGroupIdRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void GetTagsBySwimmingLaneGroupIdRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+

mse/src/model/GetTagsBySwimmingLaneGroupIdResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/GetTagsBySwimmingLaneGroupIdResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+GetTagsBySwimmingLaneGroupIdResult::GetTagsBySwimmingLaneGroupIdResult() :
+	ServiceResult()
+{}
+
+GetTagsBySwimmingLaneGroupIdResult::GetTagsBySwimmingLaneGroupIdResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetTagsBySwimmingLaneGroupIdResult::~GetTagsBySwimmingLaneGroupIdResult()
+{}
+
+void GetTagsBySwimmingLaneGroupIdResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

mse/src/model/ListAppBySwimmingLaneGroupTagRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/ListAppBySwimmingLaneGroupTagRequest.h>
+
+using AlibabaCloud::Mse::Model::ListAppBySwimmingLaneGroupTagRequest;
+
+ListAppBySwimmingLaneGroupTagRequest::ListAppBySwimmingLaneGroupTagRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "ListAppBySwimmingLaneGroupTag") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListAppBySwimmingLaneGroupTagRequest::~ListAppBySwimmingLaneGroupTagRequest() {}
+
+long ListAppBySwimmingLaneGroupTagRequest::getGroupId() const {
+  return groupId_;
+}
+
+void ListAppBySwimmingLaneGroupTagRequest::setGroupId(long groupId) {
+  groupId_ = groupId;
+  setParameter(std::string("GroupId"), std::to_string(groupId));
+}
+
+std::string ListAppBySwimmingLaneGroupTagRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void ListAppBySwimmingLaneGroupTagRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+
+std::string ListAppBySwimmingLaneGroupTagRequest::getTag() const {
+  return tag_;
+}
+
+void ListAppBySwimmingLaneGroupTagRequest::setTag(const std::string &tag) {
+  tag_ = tag;
+  setParameter(std::string("Tag"), tag);
+}
+

mse/src/model/ListAppBySwimmingLaneGroupTagResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/ListAppBySwimmingLaneGroupTagResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+ListAppBySwimmingLaneGroupTagResult::ListAppBySwimmingLaneGroupTagResult() :
+	ServiceResult()
+{}
+
+ListAppBySwimmingLaneGroupTagResult::ListAppBySwimmingLaneGroupTagResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListAppBySwimmingLaneGroupTagResult::~ListAppBySwimmingLaneGroupTagResult()
+{}
+
+void ListAppBySwimmingLaneGroupTagResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

mse/src/model/ListApplicationsWithTagRulesRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/ListApplicationsWithTagRulesRequest.h>
+
+using AlibabaCloud::Mse::Model::ListApplicationsWithTagRulesRequest;
+
+ListApplicationsWithTagRulesRequest::ListApplicationsWithTagRulesRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "ListApplicationsWithTagRules") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+ListApplicationsWithTagRulesRequest::~ListApplicationsWithTagRulesRequest() {}
+
+std::string ListApplicationsWithTagRulesRequest::getSource() const {
+  return source_;
+}
+
+void ListApplicationsWithTagRulesRequest::setSource(const std::string &source) {
+  source_ = source;
+  setParameter(std::string("Source"), source);
+}
+
+int ListApplicationsWithTagRulesRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void ListApplicationsWithTagRulesRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string ListApplicationsWithTagRulesRequest::getAppName() const {
+  return appName_;
+}
+
+void ListApplicationsWithTagRulesRequest::setAppName(const std::string &appName) {
+  appName_ = appName;
+  setParameter(std::string("AppName"), appName);
+}
+
+std::string ListApplicationsWithTagRulesRequest::getAppId() const {
+  return appId_;
+}
+
+void ListApplicationsWithTagRulesRequest::setAppId(const std::string &appId) {
+  appId_ = appId;
+  setParameter(std::string("AppId"), appId);
+}
+
+int ListApplicationsWithTagRulesRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void ListApplicationsWithTagRulesRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string ListApplicationsWithTagRulesRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void ListApplicationsWithTagRulesRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+
+std::string ListApplicationsWithTagRulesRequest::getRegion() const {
+  return region_;
+}
+
+void ListApplicationsWithTagRulesRequest::setRegion(const std::string &region) {
+  region_ = region;
+  setParameter(std::string("Region"), region);
+}
+

mse/src/model/ListApplicationsWithTagRulesResult.cc

@@ -0,0 +1,124 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/ListApplicationsWithTagRulesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+ListApplicationsWithTagRulesResult::ListApplicationsWithTagRulesResult() :
+	ServiceResult()
+{}
+
+ListApplicationsWithTagRulesResult::ListApplicationsWithTagRulesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListApplicationsWithTagRulesResult::~ListApplicationsWithTagRulesResult()
+{}
+
+void ListApplicationsWithTagRulesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["TotalSize"].isNull())
+		data_.totalSize = std::stoi(dataNode["TotalSize"].asString());
+	if(!dataNode["PageNumber"].isNull())
+		data_.pageNumber = std::stoi(dataNode["PageNumber"].asString());
+	if(!dataNode["PageSize"].isNull())
+		data_.pageSize = std::stoi(dataNode["PageSize"].asString());
+	auto allResultNode = dataNode["Result"]["ApplicationList"];
+	for (auto dataNodeResultApplicationList : allResultNode)
+	{
+		Data::ApplicationList applicationListObject;
+		if(!dataNodeResultApplicationList["AppName"].isNull())
+			applicationListObject.appName = dataNodeResultApplicationList["AppName"].asString();
+		if(!dataNodeResultApplicationList["AppId"].isNull())
+			applicationListObject.appId = dataNodeResultApplicationList["AppId"].asString();
+		if(!dataNodeResultApplicationList["RouteStatus"].isNull())
+			applicationListObject.routeStatus = std::stol(dataNodeResultApplicationList["RouteStatus"].asString());
+		auto allRouteRulesNode = dataNodeResultApplicationList["RouteRules"]["RouteRule"];
+		for (auto dataNodeResultApplicationListRouteRulesRouteRule : allRouteRulesNode)
+		{
+			Data::ApplicationList::RouteRule routeRulesObject;
+			if(!dataNodeResultApplicationListRouteRulesRouteRule["Status"].isNull())
+				routeRulesObject.status = std::stoi(dataNodeResultApplicationListRouteRulesRouteRule["Status"].asString());
+			if(!dataNodeResultApplicationListRouteRulesRouteRule["InstanceNum"].isNull())
+				routeRulesObject.instanceNum = std::stoi(dataNodeResultApplicationListRouteRulesRouteRule["InstanceNum"].asString());
+			if(!dataNodeResultApplicationListRouteRulesRouteRule["Remove"].isNull())
+				routeRulesObject.remove = dataNodeResultApplicationListRouteRulesRouteRule["Remove"].asString() == "true";
+			if(!dataNodeResultApplicationListRouteRulesRouteRule["CarryData"].isNull())
+				routeRulesObject.carryData = dataNodeResultApplicationListRouteRulesRouteRule["CarryData"].asString() == "true";
+			if(!dataNodeResultApplicationListRouteRulesRouteRule["Tag"].isNull())
+				routeRulesObject.tag = dataNodeResultApplicationListRouteRulesRouteRule["Tag"].asString();
+			if(!dataNodeResultApplicationListRouteRulesRouteRule["Name"].isNull())
+				routeRulesObject.name = dataNodeResultApplicationListRouteRulesRouteRule["Name"].asString();
+			if(!dataNodeResultApplicationListRouteRulesRouteRule["Rules"].isNull())
+				routeRulesObject.rules = dataNodeResultApplicationListRouteRulesRouteRule["Rules"].asString();
+			if(!dataNodeResultApplicationListRouteRulesRouteRule["Id"].isNull())
+				routeRulesObject.id = std::stol(dataNodeResultApplicationListRouteRulesRouteRule["Id"].asString());
+			if(!dataNodeResultApplicationListRouteRulesRouteRule["Rate"].isNull())
+				routeRulesObject.rate = std::stoi(dataNodeResultApplicationListRouteRulesRouteRule["Rate"].asString());
+			if(!dataNodeResultApplicationListRouteRulesRouteRule["GmtModified"].isNull())
+				routeRulesObject.gmtModified = std::stol(dataNodeResultApplicationListRouteRulesRouteRule["GmtModified"].asString());
+			if(!dataNodeResultApplicationListRouteRulesRouteRule["Enable"].isNull())
+				routeRulesObject.enable = dataNodeResultApplicationListRouteRulesRouteRule["Enable"].asString() == "true";
+			applicationListObject.routeRules.push_back(routeRulesObject);
+		}
+		data_.result.push_back(applicationListObject);
+	}
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string ListApplicationsWithTagRulesResult::getMessage()const
+{
+	return message_;
+}
+
+int ListApplicationsWithTagRulesResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+ListApplicationsWithTagRulesResult::Data ListApplicationsWithTagRulesResult::getData()const
+{
+	return data_;
+}
+
+int ListApplicationsWithTagRulesResult::getCode()const
+{
+	return code_;
+}
+
+bool ListApplicationsWithTagRulesResult::getSuccess()const
+{
+	return success_;
+}
+

mse/src/model/ListGatewayRouteRequest.cc

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/ListGatewayRouteRequest.h>
+
+using AlibabaCloud::Mse::Model::ListGatewayRouteRequest;
+
+ListGatewayRouteRequest::ListGatewayRouteRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "ListGatewayRoute") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListGatewayRouteRequest::~ListGatewayRouteRequest() {}
+
+int ListGatewayRouteRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void ListGatewayRouteRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string ListGatewayRouteRequest::getOrderItem() const {
+  return orderItem_;
+}
+
+void ListGatewayRouteRequest::setOrderItem(const std::string &orderItem) {
+  orderItem_ = orderItem;
+  setParameter(std::string("OrderItem"), orderItem);
+}
+
+int ListGatewayRouteRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void ListGatewayRouteRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+bool ListGatewayRouteRequest::getDescSort() const {
+  return descSort_;
+}
+
+void ListGatewayRouteRequest::setDescSort(bool descSort) {
+  descSort_ = descSort;
+  setParameter(std::string("DescSort"), descSort ? "true" : "false");
+}
+
+ListGatewayRouteRequest::FilterParams ListGatewayRouteRequest::getFilterParams() const {
+  return filterParams_;
+}
+
+void ListGatewayRouteRequest::setFilterParams(const ListGatewayRouteRequest::FilterParams &filterParams) {
+  filterParams_ = filterParams;
+  setParameter(std::string("FilterParams") + ".DefaultServiceId", std::to_string(filterParams.defaultServiceId));
+  setParameter(std::string("FilterParams") + ".RouteOrder", std::to_string(filterParams.routeOrder));
+  setParameter(std::string("FilterParams") + ".GatewayUniqueId", filterParams.gatewayUniqueId);
+  setParameter(std::string("FilterParams") + ".Name", filterParams.name);
+  setParameter(std::string("FilterParams") + ".GatewayId", std::to_string(filterParams.gatewayId));
+  setParameter(std::string("FilterParams") + ".DomainId", std::to_string(filterParams.domainId));
+  setParameter(std::string("FilterParams") + ".Status", std::to_string(filterParams.status));
+}
+
+std::string ListGatewayRouteRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void ListGatewayRouteRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+

mse/src/model/ListGatewayRouteResult.cc

@@ -0,0 +1,195 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/ListGatewayRouteResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+ListGatewayRouteResult::ListGatewayRouteResult() :
+	ServiceResult()
+{}
+
+ListGatewayRouteResult::ListGatewayRouteResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListGatewayRouteResult::~ListGatewayRouteResult()
+{}
+
+void ListGatewayRouteResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["TotalSize"].isNull())
+		data_.totalSize = std::stol(dataNode["TotalSize"].asString());
+	if(!dataNode["PageNumber"].isNull())
+		data_.pageNumber = std::stoi(dataNode["PageNumber"].asString());
+	if(!dataNode["PageSize"].isNull())
+		data_.pageSize = std::stoi(dataNode["PageSize"].asString());
+	auto allResultNode = dataNode["Result"]["Routes"];
+	for (auto dataNodeResultRoutes : allResultNode)
+	{
+		Data::Routes routesObject;
+		if(!dataNodeResultRoutes["Id"].isNull())
+			routesObject.id = std::stol(dataNodeResultRoutes["Id"].asString());
+		if(!dataNodeResultRoutes["Name"].isNull())
+			routesObject.name = dataNodeResultRoutes["Name"].asString();
+		if(!dataNodeResultRoutes["GatewayUniqueId"].isNull())
+			routesObject.gatewayUniqueId = dataNodeResultRoutes["GatewayUniqueId"].asString();
+		if(!dataNodeResultRoutes["GatewayId"].isNull())
+			routesObject.gatewayId = std::stol(dataNodeResultRoutes["GatewayId"].asString());
+		if(!dataNodeResultRoutes["Status"].isNull())
+			routesObject.status = std::stoi(dataNodeResultRoutes["Status"].asString());
+		if(!dataNodeResultRoutes["RouteOrder"].isNull())
+			routesObject.routeOrder = std::stoi(dataNodeResultRoutes["RouteOrder"].asString());
+		if(!dataNodeResultRoutes["DefaultServiceName"].isNull())
+			routesObject.defaultServiceName = dataNodeResultRoutes["DefaultServiceName"].asString();
+		if(!dataNodeResultRoutes["DefaultServiceId"].isNull())
+			routesObject.defaultServiceId = std::stol(dataNodeResultRoutes["DefaultServiceId"].asString());
+		if(!dataNodeResultRoutes["Predicates"].isNull())
+			routesObject.predicates = dataNodeResultRoutes["Predicates"].asString();
+		if(!dataNodeResultRoutes["GmtCreate"].isNull())
+			routesObject.gmtCreate = dataNodeResultRoutes["GmtCreate"].asString();
+		if(!dataNodeResultRoutes["GmtModified"].isNull())
+			routesObject.gmtModified = dataNodeResultRoutes["GmtModified"].asString();
+		if(!dataNodeResultRoutes["Services"].isNull())
+			routesObject.services = dataNodeResultRoutes["Services"].asString();
+		if(!dataNodeResultRoutes["DomainId"].isNull())
+			routesObject.domainId = std::stol(dataNodeResultRoutes["DomainId"].asString());
+		if(!dataNodeResultRoutes["DomainName"].isNull())
+			routesObject.domainName = dataNodeResultRoutes["DomainName"].asString();
+		if(!dataNodeResultRoutes["DestinationType"].isNull())
+			routesObject.destinationType = dataNodeResultRoutes["DestinationType"].asString();
+		auto allRouteServicesNode = dataNodeResultRoutes["RouteServices"]["RouteServicesItem"];
+		for (auto dataNodeResultRoutesRouteServicesRouteServicesItem : allRouteServicesNode)
+		{
+			Data::Routes::RouteServicesItem routeServicesObject;
+			if(!dataNodeResultRoutesRouteServicesRouteServicesItem["ServiceId"].isNull())
+				routeServicesObject.serviceId = std::stol(dataNodeResultRoutesRouteServicesRouteServicesItem["ServiceId"].asString());
+			if(!dataNodeResultRoutesRouteServicesRouteServicesItem["ServiceName"].isNull())
+				routeServicesObject.serviceName = dataNodeResultRoutesRouteServicesRouteServicesItem["ServiceName"].asString();
+			if(!dataNodeResultRoutesRouteServicesRouteServicesItem["Percent"].isNull())
+				routeServicesObject.percent = std::stoi(dataNodeResultRoutesRouteServicesRouteServicesItem["Percent"].asString());
+			if(!dataNodeResultRoutesRouteServicesRouteServicesItem["Version"].isNull())
+				routeServicesObject.version = dataNodeResultRoutesRouteServicesRouteServicesItem["Version"].asString();
+			if(!dataNodeResultRoutesRouteServicesRouteServicesItem["Name"].isNull())
+				routeServicesObject.name = dataNodeResultRoutesRouteServicesRouteServicesItem["Name"].asString();
+			if(!dataNodeResultRoutesRouteServicesRouteServicesItem["SourceType"].isNull())
+				routeServicesObject.sourceType = dataNodeResultRoutesRouteServicesRouteServicesItem["SourceType"].asString();
+			if(!dataNodeResultRoutesRouteServicesRouteServicesItem["Namespace"].isNull())
+				routeServicesObject._namespace = dataNodeResultRoutesRouteServicesRouteServicesItem["Namespace"].asString();
+			if(!dataNodeResultRoutesRouteServicesRouteServicesItem["GroupName"].isNull())
+				routeServicesObject.groupName = dataNodeResultRoutesRouteServicesRouteServicesItem["GroupName"].asString();
+			routesObject.routeServices.push_back(routeServicesObject);
+		}
+		auto routePredicatesNode = value["RoutePredicates"];
+		auto allHeaderPredicatesNode = routePredicatesNode["HeaderPredicates"]["HeaderPredicatesItem"];
+		for (auto routePredicatesNodeHeaderPredicatesHeaderPredicatesItem : allHeaderPredicatesNode)
+		{
+			Data::Routes::RoutePredicates::HeaderPredicatesItem headerPredicatesItemObject;
+			if(!routePredicatesNodeHeaderPredicatesHeaderPredicatesItem["Key"].isNull())
+				headerPredicatesItemObject.key = routePredicatesNodeHeaderPredicatesHeaderPredicatesItem["Key"].asString();
+			if(!routePredicatesNodeHeaderPredicatesHeaderPredicatesItem["Value"].isNull())
+				headerPredicatesItemObject.value = routePredicatesNodeHeaderPredicatesHeaderPredicatesItem["Value"].asString();
+			if(!routePredicatesNodeHeaderPredicatesHeaderPredicatesItem["Type"].isNull())
+				headerPredicatesItemObject.type = routePredicatesNodeHeaderPredicatesHeaderPredicatesItem["Type"].asString();
+			routesObject.routePredicates.headerPredicates.push_back(headerPredicatesItemObject);
+		}
+		auto allQueryPredicatesNode = routePredicatesNode["QueryPredicates"]["QueryPredicatesItem"];
+		for (auto routePredicatesNodeQueryPredicatesQueryPredicatesItem : allQueryPredicatesNode)
+		{
+			Data::Routes::RoutePredicates::QueryPredicatesItem queryPredicatesItemObject;
+			if(!routePredicatesNodeQueryPredicatesQueryPredicatesItem["Key"].isNull())
+				queryPredicatesItemObject.key = routePredicatesNodeQueryPredicatesQueryPredicatesItem["Key"].asString();
+			if(!routePredicatesNodeQueryPredicatesQueryPredicatesItem["Value"].isNull())
+				queryPredicatesItemObject.value = routePredicatesNodeQueryPredicatesQueryPredicatesItem["Value"].asString();
+			if(!routePredicatesNodeQueryPredicatesQueryPredicatesItem["Type"].isNull())
+				queryPredicatesItemObject.type = routePredicatesNodeQueryPredicatesQueryPredicatesItem["Type"].asString();
+			routesObject.routePredicates.queryPredicates.push_back(queryPredicatesItemObject);
+		}
+		auto pathPredicatesNode = routePredicatesNode["PathPredicates"];
+		if(!pathPredicatesNode["Path"].isNull())
+			routesObject.routePredicates.pathPredicates.path = pathPredicatesNode["Path"].asString();
+		if(!pathPredicatesNode["Type"].isNull())
+			routesObject.routePredicates.pathPredicates.type = pathPredicatesNode["Type"].asString();
+		if(!pathPredicatesNode["IgnoreCase"].isNull())
+			routesObject.routePredicates.pathPredicates.ignoreCase = pathPredicatesNode["IgnoreCase"].asString() == "true";
+			auto allMethodPredicates = routePredicatesNode["MethodPredicates"]["MethodPredicates"];
+			for (auto value : allMethodPredicates)
+				routesObject.routePredicates.methodPredicates.push_back(value.asString());
+		auto directResponseNode = value["DirectResponse"];
+		if(!directResponseNode["Code"].isNull())
+			routesObject.directResponse.code = std::stoi(directResponseNode["Code"].asString());
+		if(!directResponseNode["Body"].isNull())
+			routesObject.directResponse.body = directResponseNode["Body"].asString();
+		auto redirectNode = value["Redirect"];
+		if(!redirectNode["Code"].isNull())
+			routesObject.redirect.code = std::stoi(redirectNode["Code"].asString());
+		if(!redirectNode["Host"].isNull())
+			routesObject.redirect.host = redirectNode["Host"].asString();
+		if(!redirectNode["Path"].isNull())
+			routesObject.redirect.path = redirectNode["Path"].asString();
+		auto allDomainIdList = value["DomainIdList"]["DomainIdList"];
+		for (auto value : allDomainIdList)
+			routesObject.domainIdList.push_back(value.asString());
+		auto allDomainNameList = value["DomainNameList"]["DomainNameList"];
+		for (auto value : allDomainNameList)
+			routesObject.domainNameList.push_back(value.asString());
+		data_.result.push_back(routesObject);
+	}
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string ListGatewayRouteResult::getMessage()const
+{
+	return message_;
+}
+
+int ListGatewayRouteResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+ListGatewayRouteResult::Data ListGatewayRouteResult::getData()const
+{
+	return data_;
+}
+
+int ListGatewayRouteResult::getCode()const
+{
+	return code_;
+}
+
+bool ListGatewayRouteResult::getSuccess()const
+{
+	return success_;
+}
+

mse/src/model/OfflineGatewayRouteRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/OfflineGatewayRouteRequest.h>
+
+using AlibabaCloud::Mse::Model::OfflineGatewayRouteRequest;
+
+OfflineGatewayRouteRequest::OfflineGatewayRouteRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "OfflineGatewayRoute") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+OfflineGatewayRouteRequest::~OfflineGatewayRouteRequest() {}
+
+std::string OfflineGatewayRouteRequest::getGatewayUniqueId() const {
+  return gatewayUniqueId_;
+}
+
+void OfflineGatewayRouteRequest::setGatewayUniqueId(const std::string &gatewayUniqueId) {
+  gatewayUniqueId_ = gatewayUniqueId;
+  setParameter(std::string("GatewayUniqueId"), gatewayUniqueId);
+}
+
+std::string OfflineGatewayRouteRequest::getRouteId() const {
+  return routeId_;
+}
+
+void OfflineGatewayRouteRequest::setRouteId(const std::string &routeId) {
+  routeId_ = routeId;
+  setParameter(std::string("RouteId"), routeId);
+}
+
+std::string OfflineGatewayRouteRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void OfflineGatewayRouteRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+

mse/src/model/OfflineGatewayRouteResult.cc

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/OfflineGatewayRouteResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+OfflineGatewayRouteResult::OfflineGatewayRouteResult() :
+	ServiceResult()
+{}
+
+OfflineGatewayRouteResult::OfflineGatewayRouteResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+OfflineGatewayRouteResult::~OfflineGatewayRouteResult()
+{}
+
+void OfflineGatewayRouteResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString() == "true";
+
+}
+
+std::string OfflineGatewayRouteResult::getMessage()const
+{
+	return message_;
+}
+
+int OfflineGatewayRouteResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+bool OfflineGatewayRouteResult::getData()const
+{
+	return data_;
+}
+
+int OfflineGatewayRouteResult::getCode()const
+{
+	return code_;
+}
+
+bool OfflineGatewayRouteResult::getSuccess()const
+{
+	return success_;
+}
+

mse/src/model/QueryAllSwimmingLaneGroupRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/QueryAllSwimmingLaneGroupRequest.h>
+
+using AlibabaCloud::Mse::Model::QueryAllSwimmingLaneGroupRequest;
+
+QueryAllSwimmingLaneGroupRequest::QueryAllSwimmingLaneGroupRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "QueryAllSwimmingLaneGroup") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+QueryAllSwimmingLaneGroupRequest::~QueryAllSwimmingLaneGroupRequest() {}
+
+std::string QueryAllSwimmingLaneGroupRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void QueryAllSwimmingLaneGroupRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+

mse/src/model/QueryAllSwimmingLaneGroupResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/QueryAllSwimmingLaneGroupResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+QueryAllSwimmingLaneGroupResult::QueryAllSwimmingLaneGroupResult() :
+	ServiceResult()
+{}
+
+QueryAllSwimmingLaneGroupResult::QueryAllSwimmingLaneGroupResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+QueryAllSwimmingLaneGroupResult::~QueryAllSwimmingLaneGroupResult()
+{}
+
+void QueryAllSwimmingLaneGroupResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

mse/src/model/QueryAllSwimmingLaneRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/QueryAllSwimmingLaneRequest.h>
+
+using AlibabaCloud::Mse::Model::QueryAllSwimmingLaneRequest;
+
+QueryAllSwimmingLaneRequest::QueryAllSwimmingLaneRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "QueryAllSwimmingLane") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+QueryAllSwimmingLaneRequest::~QueryAllSwimmingLaneRequest() {}
+
+long QueryAllSwimmingLaneRequest::getGroupId() const {
+  return groupId_;
+}
+
+void QueryAllSwimmingLaneRequest::setGroupId(long groupId) {
+  groupId_ = groupId;
+  setParameter(std::string("GroupId"), std::to_string(groupId));
+}
+
+std::string QueryAllSwimmingLaneRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void QueryAllSwimmingLaneRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+

mse/src/model/QueryAllSwimmingLaneResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/QueryAllSwimmingLaneResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+QueryAllSwimmingLaneResult::QueryAllSwimmingLaneResult() :
+	ServiceResult()
+{}
+
+QueryAllSwimmingLaneResult::QueryAllSwimmingLaneResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+QueryAllSwimmingLaneResult::~QueryAllSwimmingLaneResult()
+{}
+
+void QueryAllSwimmingLaneResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

mse/src/model/QuerySwimmingLaneByIdRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/QuerySwimmingLaneByIdRequest.h>
+
+using AlibabaCloud::Mse::Model::QuerySwimmingLaneByIdRequest;
+
+QuerySwimmingLaneByIdRequest::QuerySwimmingLaneByIdRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "QuerySwimmingLaneById") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+QuerySwimmingLaneByIdRequest::~QuerySwimmingLaneByIdRequest() {}
+
+long QuerySwimmingLaneByIdRequest::getLaneId() const {
+  return laneId_;
+}
+
+void QuerySwimmingLaneByIdRequest::setLaneId(long laneId) {
+  laneId_ = laneId;
+  setParameter(std::string("LaneId"), std::to_string(laneId));
+}
+
+std::string QuerySwimmingLaneByIdRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void QuerySwimmingLaneByIdRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+

mse/src/model/QuerySwimmingLaneByIdResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/QuerySwimmingLaneByIdResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+QuerySwimmingLaneByIdResult::QuerySwimmingLaneByIdResult() :
+	ServiceResult()
+{}
+
+QuerySwimmingLaneByIdResult::QuerySwimmingLaneByIdResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+QuerySwimmingLaneByIdResult::~QuerySwimmingLaneByIdResult()
+{}
+
+void QuerySwimmingLaneByIdResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

mse/src/model/UpdateGatewayRouteCORSRequest.cc

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/UpdateGatewayRouteCORSRequest.h>
+
+using AlibabaCloud::Mse::Model::UpdateGatewayRouteCORSRequest;
+
+UpdateGatewayRouteCORSRequest::UpdateGatewayRouteCORSRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "UpdateGatewayRouteCORS") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateGatewayRouteCORSRequest::~UpdateGatewayRouteCORSRequest() {}
+
+UpdateGatewayRouteCORSRequest::CorsJSON UpdateGatewayRouteCORSRequest::getCorsJSON() const {
+  return corsJSON_;
+}
+
+void UpdateGatewayRouteCORSRequest::setCorsJSON(const UpdateGatewayRouteCORSRequest::CorsJSON &corsJSON) {
+  corsJSON_ = corsJSON;
+  setParameter(std::string("CorsJSON") + ".AllowCredentials", corsJSON.allowCredentials ? "true" : "false");
+  setParameter(std::string("CorsJSON") + ".AllowOrigins", corsJSON.allowOrigins);
+  setParameter(std::string("CorsJSON") + ".AllowMethods", corsJSON.allowMethods);
+  setParameter(std::string("CorsJSON") + ".AllowHeaders", corsJSON.allowHeaders);
+  setParameter(std::string("CorsJSON") + ".ExposeHeaders", corsJSON.exposeHeaders);
+  setParameter(std::string("CorsJSON") + ".TimeUnit", corsJSON.timeUnit);
+  setParameter(std::string("CorsJSON") + ".UnitNum", std::to_string(corsJSON.unitNum));
+  setParameter(std::string("CorsJSON") + ".Status", corsJSON.status);
+}
+
+std::string UpdateGatewayRouteCORSRequest::getGatewayUniqueId() const {
+  return gatewayUniqueId_;
+}
+
+void UpdateGatewayRouteCORSRequest::setGatewayUniqueId(const std::string &gatewayUniqueId) {
+  gatewayUniqueId_ = gatewayUniqueId;
+  setParameter(std::string("GatewayUniqueId"), gatewayUniqueId);
+}
+
+std::string UpdateGatewayRouteCORSRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void UpdateGatewayRouteCORSRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+
+long UpdateGatewayRouteCORSRequest::getId() const {
+  return id_;
+}
+
+void UpdateGatewayRouteCORSRequest::setId(long id) {
+  id_ = id;
+  setParameter(std::string("Id"), std::to_string(id));
+}
+
+long UpdateGatewayRouteCORSRequest::getGatewayId() const {
+  return gatewayId_;
+}
+
+void UpdateGatewayRouteCORSRequest::setGatewayId(long gatewayId) {
+  gatewayId_ = gatewayId;
+  setParameter(std::string("GatewayId"), std::to_string(gatewayId));
+}
+

mse/src/model/UpdateGatewayRouteCORSResult.cc

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/UpdateGatewayRouteCORSResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+UpdateGatewayRouteCORSResult::UpdateGatewayRouteCORSResult() :
+	ServiceResult()
+{}
+
+UpdateGatewayRouteCORSResult::UpdateGatewayRouteCORSResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateGatewayRouteCORSResult::~UpdateGatewayRouteCORSResult()
+{}
+
+void UpdateGatewayRouteCORSResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Data"].isNull())
+		data_ = std::stol(value["Data"].asString());
+
+}
+
+std::string UpdateGatewayRouteCORSResult::getMessage()const
+{
+	return message_;
+}
+
+int UpdateGatewayRouteCORSResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+long UpdateGatewayRouteCORSResult::getData()const
+{
+	return data_;
+}
+
+int UpdateGatewayRouteCORSResult::getCode()const
+{
+	return code_;
+}
+
+bool UpdateGatewayRouteCORSResult::getSuccess()const
+{
+	return success_;
+}
+

mse/src/model/UpdateGatewayRouteHeaderOpRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/UpdateGatewayRouteHeaderOpRequest.h>
+
+using AlibabaCloud::Mse::Model::UpdateGatewayRouteHeaderOpRequest;
+
+UpdateGatewayRouteHeaderOpRequest::UpdateGatewayRouteHeaderOpRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "UpdateGatewayRouteHeaderOp") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateGatewayRouteHeaderOpRequest::~UpdateGatewayRouteHeaderOpRequest() {}
+
+std::string UpdateGatewayRouteHeaderOpRequest::getGatewayUniqueId() const {
+  return gatewayUniqueId_;
+}
+
+void UpdateGatewayRouteHeaderOpRequest::setGatewayUniqueId(const std::string &gatewayUniqueId) {
+  gatewayUniqueId_ = gatewayUniqueId;
+  setParameter(std::string("GatewayUniqueId"), gatewayUniqueId);
+}
+
+std::string UpdateGatewayRouteHeaderOpRequest::getHeaderOpJSON() const {
+  return headerOpJSON_;
+}
+
+void UpdateGatewayRouteHeaderOpRequest::setHeaderOpJSON(const std::string &headerOpJSON) {
+  headerOpJSON_ = headerOpJSON;
+  setParameter(std::string("HeaderOpJSON"), headerOpJSON);
+}
+
+std::string UpdateGatewayRouteHeaderOpRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void UpdateGatewayRouteHeaderOpRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+
+long UpdateGatewayRouteHeaderOpRequest::getId() const {
+  return id_;
+}
+
+void UpdateGatewayRouteHeaderOpRequest::setId(long id) {
+  id_ = id;
+  setParameter(std::string("Id"), std::to_string(id));
+}
+
+long UpdateGatewayRouteHeaderOpRequest::getGatewayId() const {
+  return gatewayId_;
+}
+
+void UpdateGatewayRouteHeaderOpRequest::setGatewayId(long gatewayId) {
+  gatewayId_ = gatewayId;
+  setParameter(std::string("GatewayId"), std::to_string(gatewayId));
+}
+

mse/src/model/UpdateGatewayRouteHeaderOpResult.cc

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/UpdateGatewayRouteHeaderOpResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+UpdateGatewayRouteHeaderOpResult::UpdateGatewayRouteHeaderOpResult() :
+	ServiceResult()
+{}
+
+UpdateGatewayRouteHeaderOpResult::UpdateGatewayRouteHeaderOpResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateGatewayRouteHeaderOpResult::~UpdateGatewayRouteHeaderOpResult()
+{}
+
+void UpdateGatewayRouteHeaderOpResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Data"].isNull())
+		data_ = std::stol(value["Data"].asString());
+
+}
+
+std::string UpdateGatewayRouteHeaderOpResult::getMessage()const
+{
+	return message_;
+}
+
+int UpdateGatewayRouteHeaderOpResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+long UpdateGatewayRouteHeaderOpResult::getData()const
+{
+	return data_;
+}
+
+int UpdateGatewayRouteHeaderOpResult::getCode()const
+{
+	return code_;
+}
+
+bool UpdateGatewayRouteHeaderOpResult::getSuccess()const
+{
+	return success_;
+}
+

mse/src/model/UpdateGatewayRouteRequest.cc

@@ -0,0 +1,161 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/UpdateGatewayRouteRequest.h>
+
+using AlibabaCloud::Mse::Model::UpdateGatewayRouteRequest;
+
+UpdateGatewayRouteRequest::UpdateGatewayRouteRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "UpdateGatewayRoute") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateGatewayRouteRequest::~UpdateGatewayRouteRequest() {}
+
+std::string UpdateGatewayRouteRequest::getGatewayUniqueId() const {
+  return gatewayUniqueId_;
+}
+
+void UpdateGatewayRouteRequest::setGatewayUniqueId(const std::string &gatewayUniqueId) {
+  gatewayUniqueId_ = gatewayUniqueId;
+  setParameter(std::string("GatewayUniqueId"), gatewayUniqueId);
+}
+
+std::string UpdateGatewayRouteRequest::getDestinationType() const {
+  return destinationType_;
+}
+
+void UpdateGatewayRouteRequest::setDestinationType(const std::string &destinationType) {
+  destinationType_ = destinationType;
+  setParameter(std::string("DestinationType"), destinationType);
+}
+
+std::string UpdateGatewayRouteRequest::getDomainIdListJSON() const {
+  return domainIdListJSON_;
+}
+
+void UpdateGatewayRouteRequest::setDomainIdListJSON(const std::string &domainIdListJSON) {
+  domainIdListJSON_ = domainIdListJSON;
+  setParameter(std::string("DomainIdListJSON"), domainIdListJSON);
+}
+
+long UpdateGatewayRouteRequest::getId() const {
+  return id_;
+}
+
+void UpdateGatewayRouteRequest::setId(long id) {
+  id_ = id;
+  setParameter(std::string("Id"), std::to_string(id));
+}
+
+long UpdateGatewayRouteRequest::getGatewayId() const {
+  return gatewayId_;
+}
+
+void UpdateGatewayRouteRequest::setGatewayId(long gatewayId) {
+  gatewayId_ = gatewayId;
+  setParameter(std::string("GatewayId"), std::to_string(gatewayId));
+}
+
+int UpdateGatewayRouteRequest::getRouteOrder() const {
+  return routeOrder_;
+}
+
+void UpdateGatewayRouteRequest::setRouteOrder(int routeOrder) {
+  routeOrder_ = routeOrder;
+  setParameter(std::string("RouteOrder"), std::to_string(routeOrder));
+}
+
+std::vector<UpdateGatewayRouteRequest::Services> UpdateGatewayRouteRequest::getServices() const {
+  return services_;
+}
+
+void UpdateGatewayRouteRequest::setServices(const std::vector<UpdateGatewayRouteRequest::Services> &services) {
+  services_ = services;
+  for(int dep1 = 0; dep1 != services.size(); dep1++) {
+    setParameter(std::string("Services") + "." + std::to_string(dep1 + 1) + ".Name", services[dep1].name);
+    setParameter(std::string("Services") + "." + std::to_string(dep1 + 1) + ".Namespace", services[dep1]._namespace);
+    setParameter(std::string("Services") + "." + std::to_string(dep1 + 1) + ".SourceType", services[dep1].sourceType);
+    setParameter(std::string("Services") + "." + std::to_string(dep1 + 1) + ".ServiceId", std::to_string(services[dep1].serviceId));
+    setParameter(std::string("Services") + "." + std::to_string(dep1 + 1) + ".Percent", std::to_string(services[dep1].percent));
+    setParameter(std::string("Services") + "." + std::to_string(dep1 + 1) + ".Version", services[dep1].version);
+    setParameter(std::string("Services") + "." + std::to_string(dep1 + 1) + ".GroupName", services[dep1].groupName);
+  }
+}
+
+UpdateGatewayRouteRequest::Predicates UpdateGatewayRouteRequest::getPredicates() const {
+  return predicates_;
+}
+
+void UpdateGatewayRouteRequest::setPredicates(const UpdateGatewayRouteRequest::Predicates &predicates) {
+  predicates_ = predicates;
+  setParameter(std::string("Predicates") + ".PathPredicates.Path", predicates.pathPredicates.path);
+  setParameter(std::string("Predicates") + ".PathPredicates.IgnoreCase", predicates.pathPredicates.ignoreCase ? "true" : "false");
+  setParameter(std::string("Predicates") + ".PathPredicates.Type", predicates.pathPredicates.type);
+  for(int dep1 = 0; dep1 != predicates.methodPredicates.size(); dep1++) {
+    setParameter(std::string("Predicates") + ".MethodPredicates." + std::to_string(dep1 + 1), predicates.methodPredicates[dep1]);
+  }
+  for(int dep1 = 0; dep1 != predicates.headerPredicates.size(); dep1++) {
+    setParameter(std::string("Predicates") + ".HeaderPredicates." + std::to_string(dep1 + 1) + ".Type", predicates.headerPredicates[dep1].type);
+    setParameter(std::string("Predicates") + ".HeaderPredicates." + std::to_string(dep1 + 1) + ".Value", predicates.headerPredicates[dep1].value);
+    setParameter(std::string("Predicates") + ".HeaderPredicates." + std::to_string(dep1 + 1) + ".Key", predicates.headerPredicates[dep1].key);
+  }
+  for(int dep1 = 0; dep1 != predicates.queryPredicates.size(); dep1++) {
+    setParameter(std::string("Predicates") + ".QueryPredicates." + std::to_string(dep1 + 1) + ".Type", predicates.queryPredicates[dep1].type);
+    setParameter(std::string("Predicates") + ".QueryPredicates." + std::to_string(dep1 + 1) + ".Value", predicates.queryPredicates[dep1].value);
+    setParameter(std::string("Predicates") + ".QueryPredicates." + std::to_string(dep1 + 1) + ".Key", predicates.queryPredicates[dep1].key);
+  }
+}
+
+UpdateGatewayRouteRequest::RedirectJSON UpdateGatewayRouteRequest::getRedirectJSON() const {
+  return redirectJSON_;
+}
+
+void UpdateGatewayRouteRequest::setRedirectJSON(const UpdateGatewayRouteRequest::RedirectJSON &redirectJSON) {
+  redirectJSON_ = redirectJSON;
+  setParameter(std::string("RedirectJSON") + ".Path", redirectJSON.path);
+  setParameter(std::string("RedirectJSON") + ".Code", std::to_string(redirectJSON.code));
+  setParameter(std::string("RedirectJSON") + ".Host", redirectJSON.host);
+}
+
+UpdateGatewayRouteRequest::DirectResponseJSON UpdateGatewayRouteRequest::getDirectResponseJSON() const {
+  return directResponseJSON_;
+}
+
+void UpdateGatewayRouteRequest::setDirectResponseJSON(const UpdateGatewayRouteRequest::DirectResponseJSON &directResponseJSON) {
+  directResponseJSON_ = directResponseJSON;
+  setParameter(std::string("DirectResponseJSON") + ".Code", std::to_string(directResponseJSON.code));
+  setParameter(std::string("DirectResponseJSON") + ".Body", directResponseJSON.body);
+}
+
+std::string UpdateGatewayRouteRequest::getName() const {
+  return name_;
+}
+
+void UpdateGatewayRouteRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+std::string UpdateGatewayRouteRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void UpdateGatewayRouteRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+

mse/src/model/UpdateGatewayRouteResult.cc

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/UpdateGatewayRouteResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+UpdateGatewayRouteResult::UpdateGatewayRouteResult() :
+	ServiceResult()
+{}
+
+UpdateGatewayRouteResult::UpdateGatewayRouteResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateGatewayRouteResult::~UpdateGatewayRouteResult()
+{}
+
+void UpdateGatewayRouteResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Data"].isNull())
+		data_ = std::stol(value["Data"].asString());
+
+}
+
+std::string UpdateGatewayRouteResult::getMessage()const
+{
+	return message_;
+}
+
+int UpdateGatewayRouteResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+long UpdateGatewayRouteResult::getData()const
+{
+	return data_;
+}
+
+int UpdateGatewayRouteResult::getCode()const
+{
+	return code_;
+}
+
+bool UpdateGatewayRouteResult::getSuccess()const
+{
+	return success_;
+}
+

mse/src/model/UpdateGatewayRouteRetryRequest.cc

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/UpdateGatewayRouteRetryRequest.h>
+
+using AlibabaCloud::Mse::Model::UpdateGatewayRouteRetryRequest;
+
+UpdateGatewayRouteRetryRequest::UpdateGatewayRouteRetryRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "UpdateGatewayRouteRetry") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateGatewayRouteRetryRequest::~UpdateGatewayRouteRetryRequest() {}
+
+std::string UpdateGatewayRouteRetryRequest::getGatewayUniqueId() const {
+  return gatewayUniqueId_;
+}
+
+void UpdateGatewayRouteRetryRequest::setGatewayUniqueId(const std::string &gatewayUniqueId) {
+  gatewayUniqueId_ = gatewayUniqueId;
+  setParameter(std::string("GatewayUniqueId"), gatewayUniqueId);
+}
+
+UpdateGatewayRouteRetryRequest::RetryJSON UpdateGatewayRouteRetryRequest::getRetryJSON() const {
+  return retryJSON_;
+}
+
+void UpdateGatewayRouteRetryRequest::setRetryJSON(const UpdateGatewayRouteRetryRequest::RetryJSON &retryJSON) {
+  retryJSON_ = retryJSON;
+  for(int dep1 = 0; dep1 != retryJSON.httpCodes.size(); dep1++) {
+    setParameter(std::string("RetryJSON") + ".HttpCodes." + std::to_string(dep1 + 1), retryJSON.httpCodes[dep1]);
+  }
+  setParameter(std::string("RetryJSON") + ".Attempts", std::to_string(retryJSON.attempts));
+  for(int dep1 = 0; dep1 != retryJSON.retryOn.size(); dep1++) {
+    setParameter(std::string("RetryJSON") + ".RetryOn." + std::to_string(dep1 + 1), retryJSON.retryOn[dep1]);
+  }
+  setParameter(std::string("RetryJSON") + ".Status", retryJSON.status);
+}
+
+std::string UpdateGatewayRouteRetryRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void UpdateGatewayRouteRetryRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+
+long UpdateGatewayRouteRetryRequest::getId() const {
+  return id_;
+}
+
+void UpdateGatewayRouteRetryRequest::setId(long id) {
+  id_ = id;
+  setParameter(std::string("Id"), std::to_string(id));
+}
+
+long UpdateGatewayRouteRetryRequest::getGatewayId() const {
+  return gatewayId_;
+}
+
+void UpdateGatewayRouteRetryRequest::setGatewayId(long gatewayId) {
+  gatewayId_ = gatewayId;
+  setParameter(std::string("GatewayId"), std::to_string(gatewayId));
+}
+

mse/src/model/UpdateGatewayRouteRetryResult.cc

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/UpdateGatewayRouteRetryResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+UpdateGatewayRouteRetryResult::UpdateGatewayRouteRetryResult() :
+	ServiceResult()
+{}
+
+UpdateGatewayRouteRetryResult::UpdateGatewayRouteRetryResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateGatewayRouteRetryResult::~UpdateGatewayRouteRetryResult()
+{}
+
+void UpdateGatewayRouteRetryResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["Data"].isNull())
+		data_ = std::stol(value["Data"].asString());
+
+}
+
+std::string UpdateGatewayRouteRetryResult::getMessage()const
+{
+	return message_;
+}
+
+int UpdateGatewayRouteRetryResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+long UpdateGatewayRouteRetryResult::getData()const
+{
+	return data_;
+}
+
+int UpdateGatewayRouteRetryResult::getCode()const
+{
+	return code_;
+}
+
+bool UpdateGatewayRouteRetryResult::getSuccess()const
+{
+	return success_;
+}
+

mse/src/model/UpdateGatewayRouteTimeoutRequest.cc

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mse/model/UpdateGatewayRouteTimeoutRequest.h>
+
+using AlibabaCloud::Mse::Model::UpdateGatewayRouteTimeoutRequest;
+
+UpdateGatewayRouteTimeoutRequest::UpdateGatewayRouteTimeoutRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "UpdateGatewayRouteTimeout") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateGatewayRouteTimeoutRequest::~UpdateGatewayRouteTimeoutRequest() {}
+
+UpdateGatewayRouteTimeoutRequest::TimeoutJSON UpdateGatewayRouteTimeoutRequest::getTimeoutJSON() const {
+  return timeoutJSON_;
+}
+
+void UpdateGatewayRouteTimeoutRequest::setTimeoutJSON(const UpdateGatewayRouteTimeoutRequest::TimeoutJSON &timeoutJSON) {
+  timeoutJSON_ = timeoutJSON;
+  setParameter(std::string("TimeoutJSON") + ".TimeUnit", timeoutJSON.timeUnit);
+  setParameter(std::string("TimeoutJSON") + ".UnitNum", std::to_string(timeoutJSON.unitNum));
+  setParameter(std::string("TimeoutJSON") + ".Status", timeoutJSON.status);
+}
+
+std::string UpdateGatewayRouteTimeoutRequest::getGatewayUniqueId() const {
+  return gatewayUniqueId_;
+}
+
+void UpdateGatewayRouteTimeoutRequest::setGatewayUniqueId(const std::string &gatewayUniqueId) {
+  gatewayUniqueId_ = gatewayUniqueId;
+  setParameter(std::string("GatewayUniqueId"), gatewayUniqueId);
+}
+
+std::string UpdateGatewayRouteTimeoutRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void UpdateGatewayRouteTimeoutRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+
+long UpdateGatewayRouteTimeoutRequest::getId() const {
+  return id_;
+}
+
+void UpdateGatewayRouteTimeoutRequest::setId(long id) {
+  id_ = id;
+  setParameter(std::string("Id"), std::to_string(id));
+}
+
+long UpdateGatewayRouteTimeoutRequest::getGatewayId() const {
+  return gatewayId_;
+}
+
+void UpdateGatewayRouteTimeoutRequest::setGatewayId(long gatewayId) {
+  gatewayId_ = gatewayId;
+  setParameter(std::string("GatewayId"), std::to_string(gatewayId));
+}
+