Add ListDashboardUrl api.

CHANGELOG

@@ -1,3 +1,6 @@
+2022-05-13 Version: 1.36.1125
+- Add ListDashboardUrl api.
+
 2022-05-11 Version: 1.36.1124
 - Update by sdk platform.
 

VERSION

@@ -1 +1 @@
-1.36.1124
+1.36.1125

mse/CMakeLists.txt

@@ -39,16 +39,20 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/AddMockRuleResult.h
 	include/alibabacloud/mse/model/AddSSLCertRequest.h
 	include/alibabacloud/mse/model/AddSSLCertResult.h
+	include/alibabacloud/mse/model/AddSeataServerRequest.h
+	include/alibabacloud/mse/model/AddSeataServerResult.h
+	include/alibabacloud/mse/model/AddSecurityGroupRuleRequest.h
+	include/alibabacloud/mse/model/AddSecurityGroupRuleResult.h
 	include/alibabacloud/mse/model/AddServiceSourceRequest.h
 	include/alibabacloud/mse/model/AddServiceSourceResult.h
+	include/alibabacloud/mse/model/AddTestRequest.h
+	include/alibabacloud/mse/model/AddTestResult.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
-	include/alibabacloud/mse/model/CreateAlarmRuleResult.h
 	include/alibabacloud/mse/model/CreateApplicationRequest.h
 	include/alibabacloud/mse/model/CreateApplicationResult.h
 	include/alibabacloud/mse/model/CreateClusterRequest.h
@@ -65,10 +69,10 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/CreateOrUpdateSwimmingLaneResult.h
 	include/alibabacloud/mse/model/CreateOrUpdateSwimmingLaneGroupRequest.h
 	include/alibabacloud/mse/model/CreateOrUpdateSwimmingLaneGroupResult.h
+	include/alibabacloud/mse/model/CreateVGroupRequest.h
+	include/alibabacloud/mse/model/CreateVGroupResult.h
 	include/alibabacloud/mse/model/CreateZnodeRequest.h
 	include/alibabacloud/mse/model/CreateZnodeResult.h
-	include/alibabacloud/mse/model/DeleteAlarmRuleRequest.h
-	include/alibabacloud/mse/model/DeleteAlarmRuleResult.h
 	include/alibabacloud/mse/model/DeleteAuthResourceRequest.h
 	include/alibabacloud/mse/model/DeleteAuthResourceResult.h
 	include/alibabacloud/mse/model/DeleteClusterRequest.h
@@ -81,6 +85,8 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/DeleteGatewayDomainResult.h
 	include/alibabacloud/mse/model/DeleteGatewayRouteRequest.h
 	include/alibabacloud/mse/model/DeleteGatewayRouteResult.h
+	include/alibabacloud/mse/model/DeleteGatewayServiceRequest.h
+	include/alibabacloud/mse/model/DeleteGatewayServiceResult.h
 	include/alibabacloud/mse/model/DeleteGatewayServiceVersionRequest.h
 	include/alibabacloud/mse/model/DeleteGatewayServiceVersionResult.h
 	include/alibabacloud/mse/model/DeleteGatewaySlbRequest.h
@@ -93,18 +99,30 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/DeleteNacosInstanceResult.h
 	include/alibabacloud/mse/model/DeleteNacosServiceRequest.h
 	include/alibabacloud/mse/model/DeleteNacosServiceResult.h
+	include/alibabacloud/mse/model/DeleteSeataServerRequest.h
+	include/alibabacloud/mse/model/DeleteSeataServerResult.h
+	include/alibabacloud/mse/model/DeleteSecurityGroupRuleRequest.h
+	include/alibabacloud/mse/model/DeleteSecurityGroupRuleResult.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/DeleteVGroupRequest.h
+	include/alibabacloud/mse/model/DeleteVGroupResult.h
 	include/alibabacloud/mse/model/DeleteZnodeRequest.h
 	include/alibabacloud/mse/model/DeleteZnodeResult.h
 	include/alibabacloud/mse/model/ExportNacosConfigRequest.h
 	include/alibabacloud/mse/model/ExportNacosConfigResult.h
+	include/alibabacloud/mse/model/GetAppMessageQueueRouteRequest.h
+	include/alibabacloud/mse/model/GetAppMessageQueueRouteResult.h
+	include/alibabacloud/mse/model/GetApplicationListRequest.h
+	include/alibabacloud/mse/model/GetApplicationListResult.h
 	include/alibabacloud/mse/model/GetBlackWhiteListRequest.h
 	include/alibabacloud/mse/model/GetBlackWhiteListResult.h
+	include/alibabacloud/mse/model/GetDashBoardUrlRequest.h
+	include/alibabacloud/mse/model/GetDashBoardUrlResult.h
 	include/alibabacloud/mse/model/GetEngineNamepaceRequest.h
 	include/alibabacloud/mse/model/GetEngineNamepaceResult.h
 	include/alibabacloud/mse/model/GetGatewayRequest.h
@@ -145,14 +163,6 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/ImportNacosConfigResult.h
 	include/alibabacloud/mse/model/ImportServicesRequest.h
 	include/alibabacloud/mse/model/ImportServicesResult.h
-	include/alibabacloud/mse/model/ListAlarmContactGroupsRequest.h
-	include/alibabacloud/mse/model/ListAlarmContactGroupsResult.h
-	include/alibabacloud/mse/model/ListAlarmHistoriesRequest.h
-	include/alibabacloud/mse/model/ListAlarmHistoriesResult.h
-	include/alibabacloud/mse/model/ListAlarmItemsRequest.h
-	include/alibabacloud/mse/model/ListAlarmItemsResult.h
-	include/alibabacloud/mse/model/ListAlarmRulesRequest.h
-	include/alibabacloud/mse/model/ListAlarmRulesResult.h
 	include/alibabacloud/mse/model/ListAnsInstancesRequest.h
 	include/alibabacloud/mse/model/ListAnsInstancesResult.h
 	include/alibabacloud/mse/model/ListAnsServiceClustersRequest.h
@@ -165,6 +175,8 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/ListApplicationsWithTagRulesResult.h
 	include/alibabacloud/mse/model/ListClusterConnectionTypesRequest.h
 	include/alibabacloud/mse/model/ListClusterConnectionTypesResult.h
+	include/alibabacloud/mse/model/ListClusterDetailFeatureRequest.h
+	include/alibabacloud/mse/model/ListClusterDetailFeatureResult.h
 	include/alibabacloud/mse/model/ListClusterTypesRequest.h
 	include/alibabacloud/mse/model/ListClusterTypesResult.h
 	include/alibabacloud/mse/model/ListClusterVersionsRequest.h
@@ -187,6 +199,8 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/ListGatewayServiceResult.h
 	include/alibabacloud/mse/model/ListGatewaySlbRequest.h
 	include/alibabacloud/mse/model/ListGatewaySlbResult.h
+	include/alibabacloud/mse/model/ListInstancesRequest.h
+	include/alibabacloud/mse/model/ListInstancesResult.h
 	include/alibabacloud/mse/model/ListListenersByConfigRequest.h
 	include/alibabacloud/mse/model/ListListenersByConfigResult.h
 	include/alibabacloud/mse/model/ListListenersByIpRequest.h
@@ -197,6 +211,10 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/ListNacosHistoryConfigsResult.h
 	include/alibabacloud/mse/model/ListSSLCertRequest.h
 	include/alibabacloud/mse/model/ListSSLCertResult.h
+	include/alibabacloud/mse/model/ListSecurityGroupRequest.h
+	include/alibabacloud/mse/model/ListSecurityGroupResult.h
+	include/alibabacloud/mse/model/ListSecurityGroupRuleRequest.h
+	include/alibabacloud/mse/model/ListSecurityGroupRuleResult.h
 	include/alibabacloud/mse/model/ListServiceSourceRequest.h
 	include/alibabacloud/mse/model/ListServiceSourceResult.h
 	include/alibabacloud/mse/model/ListZnodeChildrenRequest.h
@@ -233,14 +251,16 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/QuerySlbSpecResult.h
 	include/alibabacloud/mse/model/QuerySwimmingLaneByIdRequest.h
 	include/alibabacloud/mse/model/QuerySwimmingLaneByIdResult.h
+	include/alibabacloud/mse/model/QueryUserVpcRequest.h
+	include/alibabacloud/mse/model/QueryUserVpcResult.h
 	include/alibabacloud/mse/model/QueryZnodeDetailRequest.h
 	include/alibabacloud/mse/model/QueryZnodeDetailResult.h
 	include/alibabacloud/mse/model/RestartClusterRequest.h
 	include/alibabacloud/mse/model/RestartClusterResult.h
+	include/alibabacloud/mse/model/RestartSeataServerRequest.h
+	include/alibabacloud/mse/model/RestartSeataServerResult.h
 	include/alibabacloud/mse/model/RetryClusterRequest.h
 	include/alibabacloud/mse/model/RetryClusterResult.h
-	include/alibabacloud/mse/model/ScalingClusterRequest.h
-	include/alibabacloud/mse/model/ScalingClusterResult.h
 	include/alibabacloud/mse/model/SelectGatewaySlbRequest.h
 	include/alibabacloud/mse/model/SelectGatewaySlbResult.h
 	include/alibabacloud/mse/model/UpdateAclRequest.h
@@ -271,10 +291,16 @@ set(mse_public_header_model
 	include/alibabacloud/mse/model/UpdateGatewayRouteRetryResult.h
 	include/alibabacloud/mse/model/UpdateGatewayRouteTimeoutRequest.h
 	include/alibabacloud/mse/model/UpdateGatewayRouteTimeoutResult.h
+	include/alibabacloud/mse/model/UpdateGatewayRouteWafStatusRequest.h
+	include/alibabacloud/mse/model/UpdateGatewayRouteWafStatusResult.h
+	include/alibabacloud/mse/model/UpdateGatewayServiceTrafficPolicyRequest.h
+	include/alibabacloud/mse/model/UpdateGatewayServiceTrafficPolicyResult.h
 	include/alibabacloud/mse/model/UpdateGatewayServiceVersionRequest.h
 	include/alibabacloud/mse/model/UpdateGatewayServiceVersionResult.h
 	include/alibabacloud/mse/model/UpdateImageRequest.h
 	include/alibabacloud/mse/model/UpdateImageResult.h
+	include/alibabacloud/mse/model/UpdateMessageQueueRouteRequest.h
+	include/alibabacloud/mse/model/UpdateMessageQueueRouteResult.h
 	include/alibabacloud/mse/model/UpdateNacosClusterRequest.h
 	include/alibabacloud/mse/model/UpdateNacosClusterResult.h
 	include/alibabacloud/mse/model/UpdateNacosConfigRequest.h
@@ -310,16 +336,20 @@ set(mse_src
 	src/model/AddMockRuleResult.cc
 	src/model/AddSSLCertRequest.cc
 	src/model/AddSSLCertResult.cc
+	src/model/AddSeataServerRequest.cc
+	src/model/AddSeataServerResult.cc
+	src/model/AddSecurityGroupRuleRequest.cc
+	src/model/AddSecurityGroupRuleResult.cc
 	src/model/AddServiceSourceRequest.cc
 	src/model/AddServiceSourceResult.cc
+	src/model/AddTestRequest.cc
+	src/model/AddTestResult.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
-	src/model/CreateAlarmRuleResult.cc
 	src/model/CreateApplicationRequest.cc
 	src/model/CreateApplicationResult.cc
 	src/model/CreateClusterRequest.cc
@@ -336,10 +366,10 @@ set(mse_src
 	src/model/CreateOrUpdateSwimmingLaneResult.cc
 	src/model/CreateOrUpdateSwimmingLaneGroupRequest.cc
 	src/model/CreateOrUpdateSwimmingLaneGroupResult.cc
+	src/model/CreateVGroupRequest.cc
+	src/model/CreateVGroupResult.cc
 	src/model/CreateZnodeRequest.cc
 	src/model/CreateZnodeResult.cc
-	src/model/DeleteAlarmRuleRequest.cc
-	src/model/DeleteAlarmRuleResult.cc
 	src/model/DeleteAuthResourceRequest.cc
 	src/model/DeleteAuthResourceResult.cc
 	src/model/DeleteClusterRequest.cc
@@ -352,6 +382,8 @@ set(mse_src
 	src/model/DeleteGatewayDomainResult.cc
 	src/model/DeleteGatewayRouteRequest.cc
 	src/model/DeleteGatewayRouteResult.cc
+	src/model/DeleteGatewayServiceRequest.cc
+	src/model/DeleteGatewayServiceResult.cc
 	src/model/DeleteGatewayServiceVersionRequest.cc
 	src/model/DeleteGatewayServiceVersionResult.cc
 	src/model/DeleteGatewaySlbRequest.cc
@@ -364,18 +396,30 @@ set(mse_src
 	src/model/DeleteNacosInstanceResult.cc
 	src/model/DeleteNacosServiceRequest.cc
 	src/model/DeleteNacosServiceResult.cc
+	src/model/DeleteSeataServerRequest.cc
+	src/model/DeleteSeataServerResult.cc
+	src/model/DeleteSecurityGroupRuleRequest.cc
+	src/model/DeleteSecurityGroupRuleResult.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/DeleteVGroupRequest.cc
+	src/model/DeleteVGroupResult.cc
 	src/model/DeleteZnodeRequest.cc
 	src/model/DeleteZnodeResult.cc
 	src/model/ExportNacosConfigRequest.cc
 	src/model/ExportNacosConfigResult.cc
+	src/model/GetAppMessageQueueRouteRequest.cc
+	src/model/GetAppMessageQueueRouteResult.cc
+	src/model/GetApplicationListRequest.cc
+	src/model/GetApplicationListResult.cc
 	src/model/GetBlackWhiteListRequest.cc
 	src/model/GetBlackWhiteListResult.cc
+	src/model/GetDashBoardUrlRequest.cc
+	src/model/GetDashBoardUrlResult.cc
 	src/model/GetEngineNamepaceRequest.cc
 	src/model/GetEngineNamepaceResult.cc
 	src/model/GetGatewayRequest.cc
@@ -416,14 +460,6 @@ set(mse_src
 	src/model/ImportNacosConfigResult.cc
 	src/model/ImportServicesRequest.cc
 	src/model/ImportServicesResult.cc
-	src/model/ListAlarmContactGroupsRequest.cc
-	src/model/ListAlarmContactGroupsResult.cc
-	src/model/ListAlarmHistoriesRequest.cc
-	src/model/ListAlarmHistoriesResult.cc
-	src/model/ListAlarmItemsRequest.cc
-	src/model/ListAlarmItemsResult.cc
-	src/model/ListAlarmRulesRequest.cc
-	src/model/ListAlarmRulesResult.cc
 	src/model/ListAnsInstancesRequest.cc
 	src/model/ListAnsInstancesResult.cc
 	src/model/ListAnsServiceClustersRequest.cc
@@ -436,6 +472,8 @@ set(mse_src
 	src/model/ListApplicationsWithTagRulesResult.cc
 	src/model/ListClusterConnectionTypesRequest.cc
 	src/model/ListClusterConnectionTypesResult.cc
+	src/model/ListClusterDetailFeatureRequest.cc
+	src/model/ListClusterDetailFeatureResult.cc
 	src/model/ListClusterTypesRequest.cc
 	src/model/ListClusterTypesResult.cc
 	src/model/ListClusterVersionsRequest.cc
@@ -458,6 +496,8 @@ set(mse_src
 	src/model/ListGatewayServiceResult.cc
 	src/model/ListGatewaySlbRequest.cc
 	src/model/ListGatewaySlbResult.cc
+	src/model/ListInstancesRequest.cc
+	src/model/ListInstancesResult.cc
 	src/model/ListListenersByConfigRequest.cc
 	src/model/ListListenersByConfigResult.cc
 	src/model/ListListenersByIpRequest.cc
@@ -468,6 +508,10 @@ set(mse_src
 	src/model/ListNacosHistoryConfigsResult.cc
 	src/model/ListSSLCertRequest.cc
 	src/model/ListSSLCertResult.cc
+	src/model/ListSecurityGroupRequest.cc
+	src/model/ListSecurityGroupResult.cc
+	src/model/ListSecurityGroupRuleRequest.cc
+	src/model/ListSecurityGroupRuleResult.cc
 	src/model/ListServiceSourceRequest.cc
 	src/model/ListServiceSourceResult.cc
 	src/model/ListZnodeChildrenRequest.cc
@@ -504,14 +548,16 @@ set(mse_src
 	src/model/QuerySlbSpecResult.cc
 	src/model/QuerySwimmingLaneByIdRequest.cc
 	src/model/QuerySwimmingLaneByIdResult.cc
+	src/model/QueryUserVpcRequest.cc
+	src/model/QueryUserVpcResult.cc
 	src/model/QueryZnodeDetailRequest.cc
 	src/model/QueryZnodeDetailResult.cc
 	src/model/RestartClusterRequest.cc
 	src/model/RestartClusterResult.cc
+	src/model/RestartSeataServerRequest.cc
+	src/model/RestartSeataServerResult.cc
 	src/model/RetryClusterRequest.cc
 	src/model/RetryClusterResult.cc
-	src/model/ScalingClusterRequest.cc
-	src/model/ScalingClusterResult.cc
 	src/model/SelectGatewaySlbRequest.cc
 	src/model/SelectGatewaySlbResult.cc
 	src/model/UpdateAclRequest.cc
@@ -542,10 +588,16 @@ set(mse_src
 	src/model/UpdateGatewayRouteRetryResult.cc
 	src/model/UpdateGatewayRouteTimeoutRequest.cc
 	src/model/UpdateGatewayRouteTimeoutResult.cc
+	src/model/UpdateGatewayRouteWafStatusRequest.cc
+	src/model/UpdateGatewayRouteWafStatusResult.cc
+	src/model/UpdateGatewayServiceTrafficPolicyRequest.cc
+	src/model/UpdateGatewayServiceTrafficPolicyResult.cc
 	src/model/UpdateGatewayServiceVersionRequest.cc
 	src/model/UpdateGatewayServiceVersionResult.cc
 	src/model/UpdateImageRequest.cc
 	src/model/UpdateImageResult.cc
+	src/model/UpdateMessageQueueRouteRequest.cc
+	src/model/UpdateMessageQueueRouteResult.cc
 	src/model/UpdateNacosClusterRequest.cc
 	src/model/UpdateNacosClusterResult.cc
 	src/model/UpdateNacosConfigRequest.cc

mse/include/alibabacloud/mse/MseClient.h

@@ -40,16 +40,20 @@
 #include "model/AddMockRuleResult.h"
 #include "model/AddSSLCertRequest.h"
 #include "model/AddSSLCertResult.h"
+#include "model/AddSeataServerRequest.h"
+#include "model/AddSeataServerResult.h"
+#include "model/AddSecurityGroupRuleRequest.h"
+#include "model/AddSecurityGroupRuleResult.h"
 #include "model/AddServiceSourceRequest.h"
 #include "model/AddServiceSourceResult.h"
+#include "model/AddTestRequest.h"
+#include "model/AddTestResult.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"
-#include "model/CreateAlarmRuleResult.h"
 #include "model/CreateApplicationRequest.h"
 #include "model/CreateApplicationResult.h"
 #include "model/CreateClusterRequest.h"
@@ -66,10 +70,10 @@
 #include "model/CreateOrUpdateSwimmingLaneResult.h"
 #include "model/CreateOrUpdateSwimmingLaneGroupRequest.h"
 #include "model/CreateOrUpdateSwimmingLaneGroupResult.h"
+#include "model/CreateVGroupRequest.h"
+#include "model/CreateVGroupResult.h"
 #include "model/CreateZnodeRequest.h"
 #include "model/CreateZnodeResult.h"
-#include "model/DeleteAlarmRuleRequest.h"
-#include "model/DeleteAlarmRuleResult.h"
 #include "model/DeleteAuthResourceRequest.h"
 #include "model/DeleteAuthResourceResult.h"
 #include "model/DeleteClusterRequest.h"
@@ -82,6 +86,8 @@
 #include "model/DeleteGatewayDomainResult.h"
 #include "model/DeleteGatewayRouteRequest.h"
 #include "model/DeleteGatewayRouteResult.h"
+#include "model/DeleteGatewayServiceRequest.h"
+#include "model/DeleteGatewayServiceResult.h"
 #include "model/DeleteGatewayServiceVersionRequest.h"
 #include "model/DeleteGatewayServiceVersionResult.h"
 #include "model/DeleteGatewaySlbRequest.h"
@@ -94,18 +100,30 @@
 #include "model/DeleteNacosInstanceResult.h"
 #include "model/DeleteNacosServiceRequest.h"
 #include "model/DeleteNacosServiceResult.h"
+#include "model/DeleteSeataServerRequest.h"
+#include "model/DeleteSeataServerResult.h"
+#include "model/DeleteSecurityGroupRuleRequest.h"
+#include "model/DeleteSecurityGroupRuleResult.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/DeleteVGroupRequest.h"
+#include "model/DeleteVGroupResult.h"
 #include "model/DeleteZnodeRequest.h"
 #include "model/DeleteZnodeResult.h"
 #include "model/ExportNacosConfigRequest.h"
 #include "model/ExportNacosConfigResult.h"
+#include "model/GetAppMessageQueueRouteRequest.h"
+#include "model/GetAppMessageQueueRouteResult.h"
+#include "model/GetApplicationListRequest.h"
+#include "model/GetApplicationListResult.h"
 #include "model/GetBlackWhiteListRequest.h"
 #include "model/GetBlackWhiteListResult.h"
+#include "model/GetDashBoardUrlRequest.h"
+#include "model/GetDashBoardUrlResult.h"
 #include "model/GetEngineNamepaceRequest.h"
 #include "model/GetEngineNamepaceResult.h"
 #include "model/GetGatewayRequest.h"
@@ -146,14 +164,6 @@
 #include "model/ImportNacosConfigResult.h"
 #include "model/ImportServicesRequest.h"
 #include "model/ImportServicesResult.h"
-#include "model/ListAlarmContactGroupsRequest.h"
-#include "model/ListAlarmContactGroupsResult.h"
-#include "model/ListAlarmHistoriesRequest.h"
-#include "model/ListAlarmHistoriesResult.h"
-#include "model/ListAlarmItemsRequest.h"
-#include "model/ListAlarmItemsResult.h"
-#include "model/ListAlarmRulesRequest.h"
-#include "model/ListAlarmRulesResult.h"
 #include "model/ListAnsInstancesRequest.h"
 #include "model/ListAnsInstancesResult.h"
 #include "model/ListAnsServiceClustersRequest.h"
@@ -166,6 +176,8 @@
 #include "model/ListApplicationsWithTagRulesResult.h"
 #include "model/ListClusterConnectionTypesRequest.h"
 #include "model/ListClusterConnectionTypesResult.h"
+#include "model/ListClusterDetailFeatureRequest.h"
+#include "model/ListClusterDetailFeatureResult.h"
 #include "model/ListClusterTypesRequest.h"
 #include "model/ListClusterTypesResult.h"
 #include "model/ListClusterVersionsRequest.h"
@@ -188,6 +200,8 @@
 #include "model/ListGatewayServiceResult.h"
 #include "model/ListGatewaySlbRequest.h"
 #include "model/ListGatewaySlbResult.h"
+#include "model/ListInstancesRequest.h"
+#include "model/ListInstancesResult.h"
 #include "model/ListListenersByConfigRequest.h"
 #include "model/ListListenersByConfigResult.h"
 #include "model/ListListenersByIpRequest.h"
@@ -198,6 +212,10 @@
 #include "model/ListNacosHistoryConfigsResult.h"
 #include "model/ListSSLCertRequest.h"
 #include "model/ListSSLCertResult.h"
+#include "model/ListSecurityGroupRequest.h"
+#include "model/ListSecurityGroupResult.h"
+#include "model/ListSecurityGroupRuleRequest.h"
+#include "model/ListSecurityGroupRuleResult.h"
 #include "model/ListServiceSourceRequest.h"
 #include "model/ListServiceSourceResult.h"
 #include "model/ListZnodeChildrenRequest.h"
@@ -234,14 +252,16 @@
 #include "model/QuerySlbSpecResult.h"
 #include "model/QuerySwimmingLaneByIdRequest.h"
 #include "model/QuerySwimmingLaneByIdResult.h"
+#include "model/QueryUserVpcRequest.h"
+#include "model/QueryUserVpcResult.h"
 #include "model/QueryZnodeDetailRequest.h"
 #include "model/QueryZnodeDetailResult.h"
 #include "model/RestartClusterRequest.h"
 #include "model/RestartClusterResult.h"
+#include "model/RestartSeataServerRequest.h"
+#include "model/RestartSeataServerResult.h"
 #include "model/RetryClusterRequest.h"
 #include "model/RetryClusterResult.h"
-#include "model/ScalingClusterRequest.h"
-#include "model/ScalingClusterResult.h"
 #include "model/SelectGatewaySlbRequest.h"
 #include "model/SelectGatewaySlbResult.h"
 #include "model/UpdateAclRequest.h"
@@ -272,10 +292,16 @@
 #include "model/UpdateGatewayRouteRetryResult.h"
 #include "model/UpdateGatewayRouteTimeoutRequest.h"
 #include "model/UpdateGatewayRouteTimeoutResult.h"
+#include "model/UpdateGatewayRouteWafStatusRequest.h"
+#include "model/UpdateGatewayRouteWafStatusResult.h"
+#include "model/UpdateGatewayServiceTrafficPolicyRequest.h"
+#include "model/UpdateGatewayServiceTrafficPolicyResult.h"
 #include "model/UpdateGatewayServiceVersionRequest.h"
 #include "model/UpdateGatewayServiceVersionResult.h"
 #include "model/UpdateImageRequest.h"
 #include "model/UpdateImageResult.h"
+#include "model/UpdateMessageQueueRouteRequest.h"
+#include "model/UpdateMessageQueueRouteResult.h"
 #include "model/UpdateNacosClusterRequest.h"
 #include "model/UpdateNacosClusterResult.h"
 #include "model/UpdateNacosConfigRequest.h"
@@ -326,9 +352,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::AddSSLCertResult> AddSSLCertOutcome;
 			typedef std::future<AddSSLCertOutcome> AddSSLCertOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::AddSSLCertRequest&, const AddSSLCertOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddSSLCertAsyncHandler;
+			typedef Outcome<Error, Model::AddSeataServerResult> AddSeataServerOutcome;
+			typedef std::future<AddSeataServerOutcome> AddSeataServerOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::AddSeataServerRequest&, const AddSeataServerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddSeataServerAsyncHandler;
+			typedef Outcome<Error, Model::AddSecurityGroupRuleResult> AddSecurityGroupRuleOutcome;
+			typedef std::future<AddSecurityGroupRuleOutcome> AddSecurityGroupRuleOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::AddSecurityGroupRuleRequest&, const AddSecurityGroupRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddSecurityGroupRuleAsyncHandler;
 			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::AddTestResult> AddTestOutcome;
+			typedef std::future<AddTestOutcome> AddTestOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::AddTestRequest&, const AddTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddTestAsyncHandler;
 			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;
@@ -338,9 +373,6 @@ namespace AlibabaCloud
 			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;
-			typedef Outcome<Error, Model::CreateAlarmRuleResult> CreateAlarmRuleOutcome;
-			typedef std::future<CreateAlarmRuleOutcome> CreateAlarmRuleOutcomeCallable;
-			typedef std::function<void(const MseClient*, const Model::CreateAlarmRuleRequest&, const CreateAlarmRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAlarmRuleAsyncHandler;
 			typedef Outcome<Error, Model::CreateApplicationResult> CreateApplicationOutcome;
 			typedef std::future<CreateApplicationOutcome> CreateApplicationOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::CreateApplicationRequest&, const CreateApplicationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateApplicationAsyncHandler;
@@ -365,12 +397,12 @@ namespace AlibabaCloud
 			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::CreateVGroupResult> CreateVGroupOutcome;
+			typedef std::future<CreateVGroupOutcome> CreateVGroupOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::CreateVGroupRequest&, const CreateVGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVGroupAsyncHandler;
 			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;
-			typedef Outcome<Error, Model::DeleteAlarmRuleResult> DeleteAlarmRuleOutcome;
-			typedef std::future<DeleteAlarmRuleOutcome> DeleteAlarmRuleOutcomeCallable;
-			typedef std::function<void(const MseClient*, const Model::DeleteAlarmRuleRequest&, const DeleteAlarmRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAlarmRuleAsyncHandler;
 			typedef Outcome<Error, Model::DeleteAuthResourceResult> DeleteAuthResourceOutcome;
 			typedef std::future<DeleteAuthResourceOutcome> DeleteAuthResourceOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::DeleteAuthResourceRequest&, const DeleteAuthResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAuthResourceAsyncHandler;
@@ -389,6 +421,9 @@ namespace AlibabaCloud
 			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::DeleteGatewayServiceResult> DeleteGatewayServiceOutcome;
+			typedef std::future<DeleteGatewayServiceOutcome> DeleteGatewayServiceOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::DeleteGatewayServiceRequest&, const DeleteGatewayServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGatewayServiceAsyncHandler;
 			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;
@@ -407,6 +442,12 @@ namespace AlibabaCloud
 			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::DeleteSeataServerResult> DeleteSeataServerOutcome;
+			typedef std::future<DeleteSeataServerOutcome> DeleteSeataServerOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::DeleteSeataServerRequest&, const DeleteSeataServerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSeataServerAsyncHandler;
+			typedef Outcome<Error, Model::DeleteSecurityGroupRuleResult> DeleteSecurityGroupRuleOutcome;
+			typedef std::future<DeleteSecurityGroupRuleOutcome> DeleteSecurityGroupRuleOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::DeleteSecurityGroupRuleRequest&, const DeleteSecurityGroupRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSecurityGroupRuleAsyncHandler;
 			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;
@@ -416,15 +457,27 @@ namespace AlibabaCloud
 			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::DeleteVGroupResult> DeleteVGroupOutcome;
+			typedef std::future<DeleteVGroupOutcome> DeleteVGroupOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::DeleteVGroupRequest&, const DeleteVGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVGroupAsyncHandler;
 			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;
 			typedef Outcome<Error, Model::ExportNacosConfigResult> ExportNacosConfigOutcome;
 			typedef std::future<ExportNacosConfigOutcome> ExportNacosConfigOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ExportNacosConfigRequest&, const ExportNacosConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExportNacosConfigAsyncHandler;
+			typedef Outcome<Error, Model::GetAppMessageQueueRouteResult> GetAppMessageQueueRouteOutcome;
+			typedef std::future<GetAppMessageQueueRouteOutcome> GetAppMessageQueueRouteOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::GetAppMessageQueueRouteRequest&, const GetAppMessageQueueRouteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAppMessageQueueRouteAsyncHandler;
+			typedef Outcome<Error, Model::GetApplicationListResult> GetApplicationListOutcome;
+			typedef std::future<GetApplicationListOutcome> GetApplicationListOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::GetApplicationListRequest&, const GetApplicationListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetApplicationListAsyncHandler;
 			typedef Outcome<Error, Model::GetBlackWhiteListResult> GetBlackWhiteListOutcome;
 			typedef std::future<GetBlackWhiteListOutcome> GetBlackWhiteListOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::GetBlackWhiteListRequest&, const GetBlackWhiteListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetBlackWhiteListAsyncHandler;
+			typedef Outcome<Error, Model::GetDashBoardUrlResult> GetDashBoardUrlOutcome;
+			typedef std::future<GetDashBoardUrlOutcome> GetDashBoardUrlOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::GetDashBoardUrlRequest&, const GetDashBoardUrlOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDashBoardUrlAsyncHandler;
 			typedef Outcome<Error, Model::GetEngineNamepaceResult> GetEngineNamepaceOutcome;
 			typedef std::future<GetEngineNamepaceOutcome> GetEngineNamepaceOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::GetEngineNamepaceRequest&, const GetEngineNamepaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetEngineNamepaceAsyncHandler;
@@ -485,18 +538,6 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ImportServicesResult> ImportServicesOutcome;
 			typedef std::future<ImportServicesOutcome> ImportServicesOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ImportServicesRequest&, const ImportServicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImportServicesAsyncHandler;
-			typedef Outcome<Error, Model::ListAlarmContactGroupsResult> ListAlarmContactGroupsOutcome;
-			typedef std::future<ListAlarmContactGroupsOutcome> ListAlarmContactGroupsOutcomeCallable;
-			typedef std::function<void(const MseClient*, const Model::ListAlarmContactGroupsRequest&, const ListAlarmContactGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAlarmContactGroupsAsyncHandler;
-			typedef Outcome<Error, Model::ListAlarmHistoriesResult> ListAlarmHistoriesOutcome;
-			typedef std::future<ListAlarmHistoriesOutcome> ListAlarmHistoriesOutcomeCallable;
-			typedef std::function<void(const MseClient*, const Model::ListAlarmHistoriesRequest&, const ListAlarmHistoriesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAlarmHistoriesAsyncHandler;
-			typedef Outcome<Error, Model::ListAlarmItemsResult> ListAlarmItemsOutcome;
-			typedef std::future<ListAlarmItemsOutcome> ListAlarmItemsOutcomeCallable;
-			typedef std::function<void(const MseClient*, const Model::ListAlarmItemsRequest&, const ListAlarmItemsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAlarmItemsAsyncHandler;
-			typedef Outcome<Error, Model::ListAlarmRulesResult> ListAlarmRulesOutcome;
-			typedef std::future<ListAlarmRulesOutcome> ListAlarmRulesOutcomeCallable;
-			typedef std::function<void(const MseClient*, const Model::ListAlarmRulesRequest&, const ListAlarmRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAlarmRulesAsyncHandler;
 			typedef Outcome<Error, Model::ListAnsInstancesResult> ListAnsInstancesOutcome;
 			typedef std::future<ListAnsInstancesOutcome> ListAnsInstancesOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ListAnsInstancesRequest&, const ListAnsInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAnsInstancesAsyncHandler;
@@ -515,6 +556,9 @@ namespace AlibabaCloud
 			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;
+			typedef Outcome<Error, Model::ListClusterDetailFeatureResult> ListClusterDetailFeatureOutcome;
+			typedef std::future<ListClusterDetailFeatureOutcome> ListClusterDetailFeatureOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::ListClusterDetailFeatureRequest&, const ListClusterDetailFeatureOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListClusterDetailFeatureAsyncHandler;
 			typedef Outcome<Error, Model::ListClusterTypesResult> ListClusterTypesOutcome;
 			typedef std::future<ListClusterTypesOutcome> ListClusterTypesOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ListClusterTypesRequest&, const ListClusterTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListClusterTypesAsyncHandler;
@@ -548,6 +592,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListGatewaySlbResult> ListGatewaySlbOutcome;
 			typedef std::future<ListGatewaySlbOutcome> ListGatewaySlbOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ListGatewaySlbRequest&, const ListGatewaySlbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListGatewaySlbAsyncHandler;
+			typedef Outcome<Error, Model::ListInstancesResult> ListInstancesOutcome;
+			typedef std::future<ListInstancesOutcome> ListInstancesOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::ListInstancesRequest&, const ListInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListInstancesAsyncHandler;
 			typedef Outcome<Error, Model::ListListenersByConfigResult> ListListenersByConfigOutcome;
 			typedef std::future<ListListenersByConfigOutcome> ListListenersByConfigOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ListListenersByConfigRequest&, const ListListenersByConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListListenersByConfigAsyncHandler;
@@ -563,6 +610,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListSSLCertResult> ListSSLCertOutcome;
 			typedef std::future<ListSSLCertOutcome> ListSSLCertOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ListSSLCertRequest&, const ListSSLCertOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSSLCertAsyncHandler;
+			typedef Outcome<Error, Model::ListSecurityGroupResult> ListSecurityGroupOutcome;
+			typedef std::future<ListSecurityGroupOutcome> ListSecurityGroupOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::ListSecurityGroupRequest&, const ListSecurityGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSecurityGroupAsyncHandler;
+			typedef Outcome<Error, Model::ListSecurityGroupRuleResult> ListSecurityGroupRuleOutcome;
+			typedef std::future<ListSecurityGroupRuleOutcome> ListSecurityGroupRuleOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::ListSecurityGroupRuleRequest&, const ListSecurityGroupRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSecurityGroupRuleAsyncHandler;
 			typedef Outcome<Error, Model::ListServiceSourceResult> ListServiceSourceOutcome;
 			typedef std::future<ListServiceSourceOutcome> ListServiceSourceOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::ListServiceSourceRequest&, const ListServiceSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListServiceSourceAsyncHandler;
@@ -617,18 +670,21 @@ namespace AlibabaCloud
 			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::QueryUserVpcResult> QueryUserVpcOutcome;
+			typedef std::future<QueryUserVpcOutcome> QueryUserVpcOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::QueryUserVpcRequest&, const QueryUserVpcOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryUserVpcAsyncHandler;
 			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;
 			typedef Outcome<Error, Model::RestartClusterResult> RestartClusterOutcome;
 			typedef std::future<RestartClusterOutcome> RestartClusterOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::RestartClusterRequest&, const RestartClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestartClusterAsyncHandler;
+			typedef Outcome<Error, Model::RestartSeataServerResult> RestartSeataServerOutcome;
+			typedef std::future<RestartSeataServerOutcome> RestartSeataServerOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::RestartSeataServerRequest&, const RestartSeataServerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestartSeataServerAsyncHandler;
 			typedef Outcome<Error, Model::RetryClusterResult> RetryClusterOutcome;
 			typedef std::future<RetryClusterOutcome> RetryClusterOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::RetryClusterRequest&, const RetryClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RetryClusterAsyncHandler;
-			typedef Outcome<Error, Model::ScalingClusterResult> ScalingClusterOutcome;
-			typedef std::future<ScalingClusterOutcome> ScalingClusterOutcomeCallable;
-			typedef std::function<void(const MseClient*, const Model::ScalingClusterRequest&, const ScalingClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ScalingClusterAsyncHandler;
 			typedef Outcome<Error, Model::SelectGatewaySlbResult> SelectGatewaySlbOutcome;
 			typedef std::future<SelectGatewaySlbOutcome> SelectGatewaySlbOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::SelectGatewaySlbRequest&, const SelectGatewaySlbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SelectGatewaySlbAsyncHandler;
@@ -674,12 +730,21 @@ namespace AlibabaCloud
 			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::UpdateGatewayRouteWafStatusResult> UpdateGatewayRouteWafStatusOutcome;
+			typedef std::future<UpdateGatewayRouteWafStatusOutcome> UpdateGatewayRouteWafStatusOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::UpdateGatewayRouteWafStatusRequest&, const UpdateGatewayRouteWafStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayRouteWafStatusAsyncHandler;
+			typedef Outcome<Error, Model::UpdateGatewayServiceTrafficPolicyResult> UpdateGatewayServiceTrafficPolicyOutcome;
+			typedef std::future<UpdateGatewayServiceTrafficPolicyOutcome> UpdateGatewayServiceTrafficPolicyOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::UpdateGatewayServiceTrafficPolicyRequest&, const UpdateGatewayServiceTrafficPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGatewayServiceTrafficPolicyAsyncHandler;
 			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;
 			typedef Outcome<Error, Model::UpdateImageResult> UpdateImageOutcome;
 			typedef std::future<UpdateImageOutcome> UpdateImageOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::UpdateImageRequest&, const UpdateImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateImageAsyncHandler;
+			typedef Outcome<Error, Model::UpdateMessageQueueRouteResult> UpdateMessageQueueRouteOutcome;
+			typedef std::future<UpdateMessageQueueRouteOutcome> UpdateMessageQueueRouteOutcomeCallable;
+			typedef std::function<void(const MseClient*, const Model::UpdateMessageQueueRouteRequest&, const UpdateMessageQueueRouteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateMessageQueueRouteAsyncHandler;
 			typedef Outcome<Error, Model::UpdateNacosClusterResult> UpdateNacosClusterOutcome;
 			typedef std::future<UpdateNacosClusterOutcome> UpdateNacosClusterOutcomeCallable;
 			typedef std::function<void(const MseClient*, const Model::UpdateNacosClusterRequest&, const UpdateNacosClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateNacosClusterAsyncHandler;
@@ -733,9 +798,18 @@ namespace AlibabaCloud
 			AddSSLCertOutcome addSSLCert(const Model::AddSSLCertRequest &request)const;
 			void addSSLCertAsync(const Model::AddSSLCertRequest& request, const AddSSLCertAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddSSLCertOutcomeCallable addSSLCertCallable(const Model::AddSSLCertRequest& request) const;
+			AddSeataServerOutcome addSeataServer(const Model::AddSeataServerRequest &request)const;
+			void addSeataServerAsync(const Model::AddSeataServerRequest& request, const AddSeataServerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddSeataServerOutcomeCallable addSeataServerCallable(const Model::AddSeataServerRequest& request) const;
+			AddSecurityGroupRuleOutcome addSecurityGroupRule(const Model::AddSecurityGroupRuleRequest &request)const;
+			void addSecurityGroupRuleAsync(const Model::AddSecurityGroupRuleRequest& request, const AddSecurityGroupRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddSecurityGroupRuleOutcomeCallable addSecurityGroupRuleCallable(const Model::AddSecurityGroupRuleRequest& request) const;
 			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;
+			AddTestOutcome addTest(const Model::AddTestRequest &request)const;
+			void addTestAsync(const Model::AddTestRequest& request, const AddTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddTestOutcomeCallable addTestCallable(const Model::AddTestRequest& 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;
@@ -745,9 +819,6 @@ namespace AlibabaCloud
 			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;
-			CreateAlarmRuleOutcome createAlarmRule(const Model::CreateAlarmRuleRequest &request)const;
-			void createAlarmRuleAsync(const Model::CreateAlarmRuleRequest& request, const CreateAlarmRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateAlarmRuleOutcomeCallable createAlarmRuleCallable(const Model::CreateAlarmRuleRequest& request) const;
 			CreateApplicationOutcome createApplication(const Model::CreateApplicationRequest &request)const;
 			void createApplicationAsync(const Model::CreateApplicationRequest& request, const CreateApplicationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateApplicationOutcomeCallable createApplicationCallable(const Model::CreateApplicationRequest& request) const;
@@ -772,12 +843,12 @@ namespace AlibabaCloud
 			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;
+			CreateVGroupOutcome createVGroup(const Model::CreateVGroupRequest &request)const;
+			void createVGroupAsync(const Model::CreateVGroupRequest& request, const CreateVGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateVGroupOutcomeCallable createVGroupCallable(const Model::CreateVGroupRequest& 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;
-			DeleteAlarmRuleOutcome deleteAlarmRule(const Model::DeleteAlarmRuleRequest &request)const;
-			void deleteAlarmRuleAsync(const Model::DeleteAlarmRuleRequest& request, const DeleteAlarmRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DeleteAlarmRuleOutcomeCallable deleteAlarmRuleCallable(const Model::DeleteAlarmRuleRequest& request) const;
 			DeleteAuthResourceOutcome deleteAuthResource(const Model::DeleteAuthResourceRequest &request)const;
 			void deleteAuthResourceAsync(const Model::DeleteAuthResourceRequest& request, const DeleteAuthResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteAuthResourceOutcomeCallable deleteAuthResourceCallable(const Model::DeleteAuthResourceRequest& request) const;
@@ -796,6 +867,9 @@ namespace AlibabaCloud
 			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;
+			DeleteGatewayServiceOutcome deleteGatewayService(const Model::DeleteGatewayServiceRequest &request)const;
+			void deleteGatewayServiceAsync(const Model::DeleteGatewayServiceRequest& request, const DeleteGatewayServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteGatewayServiceOutcomeCallable deleteGatewayServiceCallable(const Model::DeleteGatewayServiceRequest& 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;
@@ -814,6 +888,12 @@ namespace AlibabaCloud
 			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;
+			DeleteSeataServerOutcome deleteSeataServer(const Model::DeleteSeataServerRequest &request)const;
+			void deleteSeataServerAsync(const Model::DeleteSeataServerRequest& request, const DeleteSeataServerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteSeataServerOutcomeCallable deleteSeataServerCallable(const Model::DeleteSeataServerRequest& request) const;
+			DeleteSecurityGroupRuleOutcome deleteSecurityGroupRule(const Model::DeleteSecurityGroupRuleRequest &request)const;
+			void deleteSecurityGroupRuleAsync(const Model::DeleteSecurityGroupRuleRequest& request, const DeleteSecurityGroupRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteSecurityGroupRuleOutcomeCallable deleteSecurityGroupRuleCallable(const Model::DeleteSecurityGroupRuleRequest& 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;
@@ -823,15 +903,27 @@ namespace AlibabaCloud
 			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;
+			DeleteVGroupOutcome deleteVGroup(const Model::DeleteVGroupRequest &request)const;
+			void deleteVGroupAsync(const Model::DeleteVGroupRequest& request, const DeleteVGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteVGroupOutcomeCallable deleteVGroupCallable(const Model::DeleteVGroupRequest& 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;
 			ExportNacosConfigOutcome exportNacosConfig(const Model::ExportNacosConfigRequest &request)const;
 			void exportNacosConfigAsync(const Model::ExportNacosConfigRequest& request, const ExportNacosConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ExportNacosConfigOutcomeCallable exportNacosConfigCallable(const Model::ExportNacosConfigRequest& request) const;
+			GetAppMessageQueueRouteOutcome getAppMessageQueueRoute(const Model::GetAppMessageQueueRouteRequest &request)const;
+			void getAppMessageQueueRouteAsync(const Model::GetAppMessageQueueRouteRequest& request, const GetAppMessageQueueRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAppMessageQueueRouteOutcomeCallable getAppMessageQueueRouteCallable(const Model::GetAppMessageQueueRouteRequest& request) const;
+			GetApplicationListOutcome getApplicationList(const Model::GetApplicationListRequest &request)const;
+			void getApplicationListAsync(const Model::GetApplicationListRequest& request, const GetApplicationListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetApplicationListOutcomeCallable getApplicationListCallable(const Model::GetApplicationListRequest& request) const;
 			GetBlackWhiteListOutcome getBlackWhiteList(const Model::GetBlackWhiteListRequest &request)const;
 			void getBlackWhiteListAsync(const Model::GetBlackWhiteListRequest& request, const GetBlackWhiteListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetBlackWhiteListOutcomeCallable getBlackWhiteListCallable(const Model::GetBlackWhiteListRequest& request) const;
+			GetDashBoardUrlOutcome getDashBoardUrl(const Model::GetDashBoardUrlRequest &request)const;
+			void getDashBoardUrlAsync(const Model::GetDashBoardUrlRequest& request, const GetDashBoardUrlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetDashBoardUrlOutcomeCallable getDashBoardUrlCallable(const Model::GetDashBoardUrlRequest& request) const;
 			GetEngineNamepaceOutcome getEngineNamepace(const Model::GetEngineNamepaceRequest &request)const;
 			void getEngineNamepaceAsync(const Model::GetEngineNamepaceRequest& request, const GetEngineNamepaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetEngineNamepaceOutcomeCallable getEngineNamepaceCallable(const Model::GetEngineNamepaceRequest& request) const;
@@ -892,18 +984,6 @@ namespace AlibabaCloud
 			ImportServicesOutcome importServices(const Model::ImportServicesRequest &request)const;
 			void importServicesAsync(const Model::ImportServicesRequest& request, const ImportServicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ImportServicesOutcomeCallable importServicesCallable(const Model::ImportServicesRequest& request) const;
-			ListAlarmContactGroupsOutcome listAlarmContactGroups(const Model::ListAlarmContactGroupsRequest &request)const;
-			void listAlarmContactGroupsAsync(const Model::ListAlarmContactGroupsRequest& request, const ListAlarmContactGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ListAlarmContactGroupsOutcomeCallable listAlarmContactGroupsCallable(const Model::ListAlarmContactGroupsRequest& request) const;
-			ListAlarmHistoriesOutcome listAlarmHistories(const Model::ListAlarmHistoriesRequest &request)const;
-			void listAlarmHistoriesAsync(const Model::ListAlarmHistoriesRequest& request, const ListAlarmHistoriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ListAlarmHistoriesOutcomeCallable listAlarmHistoriesCallable(const Model::ListAlarmHistoriesRequest& request) const;
-			ListAlarmItemsOutcome listAlarmItems(const Model::ListAlarmItemsRequest &request)const;
-			void listAlarmItemsAsync(const Model::ListAlarmItemsRequest& request, const ListAlarmItemsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ListAlarmItemsOutcomeCallable listAlarmItemsCallable(const Model::ListAlarmItemsRequest& request) const;
-			ListAlarmRulesOutcome listAlarmRules(const Model::ListAlarmRulesRequest &request)const;
-			void listAlarmRulesAsync(const Model::ListAlarmRulesRequest& request, const ListAlarmRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ListAlarmRulesOutcomeCallable listAlarmRulesCallable(const Model::ListAlarmRulesRequest& request) const;
 			ListAnsInstancesOutcome listAnsInstances(const Model::ListAnsInstancesRequest &request)const;
 			void listAnsInstancesAsync(const Model::ListAnsInstancesRequest& request, const ListAnsInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListAnsInstancesOutcomeCallable listAnsInstancesCallable(const Model::ListAnsInstancesRequest& request) const;
@@ -922,6 +1002,9 @@ namespace AlibabaCloud
 			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;
+			ListClusterDetailFeatureOutcome listClusterDetailFeature(const Model::ListClusterDetailFeatureRequest &request)const;
+			void listClusterDetailFeatureAsync(const Model::ListClusterDetailFeatureRequest& request, const ListClusterDetailFeatureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListClusterDetailFeatureOutcomeCallable listClusterDetailFeatureCallable(const Model::ListClusterDetailFeatureRequest& request) const;
 			ListClusterTypesOutcome listClusterTypes(const Model::ListClusterTypesRequest &request)const;
 			void listClusterTypesAsync(const Model::ListClusterTypesRequest& request, const ListClusterTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListClusterTypesOutcomeCallable listClusterTypesCallable(const Model::ListClusterTypesRequest& request) const;
@@ -955,6 +1038,9 @@ namespace AlibabaCloud
 			ListGatewaySlbOutcome listGatewaySlb(const Model::ListGatewaySlbRequest &request)const;
 			void listGatewaySlbAsync(const Model::ListGatewaySlbRequest& request, const ListGatewaySlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListGatewaySlbOutcomeCallable listGatewaySlbCallable(const Model::ListGatewaySlbRequest& request) const;
+			ListInstancesOutcome listInstances(const Model::ListInstancesRequest &request)const;
+			void listInstancesAsync(const Model::ListInstancesRequest& request, const ListInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListInstancesOutcomeCallable listInstancesCallable(const Model::ListInstancesRequest& request) const;
 			ListListenersByConfigOutcome listListenersByConfig(const Model::ListListenersByConfigRequest &request)const;
 			void listListenersByConfigAsync(const Model::ListListenersByConfigRequest& request, const ListListenersByConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListListenersByConfigOutcomeCallable listListenersByConfigCallable(const Model::ListListenersByConfigRequest& request) const;
@@ -970,6 +1056,12 @@ namespace AlibabaCloud
 			ListSSLCertOutcome listSSLCert(const Model::ListSSLCertRequest &request)const;
 			void listSSLCertAsync(const Model::ListSSLCertRequest& request, const ListSSLCertAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListSSLCertOutcomeCallable listSSLCertCallable(const Model::ListSSLCertRequest& request) const;
+			ListSecurityGroupOutcome listSecurityGroup(const Model::ListSecurityGroupRequest &request)const;
+			void listSecurityGroupAsync(const Model::ListSecurityGroupRequest& request, const ListSecurityGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListSecurityGroupOutcomeCallable listSecurityGroupCallable(const Model::ListSecurityGroupRequest& request) const;
+			ListSecurityGroupRuleOutcome listSecurityGroupRule(const Model::ListSecurityGroupRuleRequest &request)const;
+			void listSecurityGroupRuleAsync(const Model::ListSecurityGroupRuleRequest& request, const ListSecurityGroupRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListSecurityGroupRuleOutcomeCallable listSecurityGroupRuleCallable(const Model::ListSecurityGroupRuleRequest& request) const;
 			ListServiceSourceOutcome listServiceSource(const Model::ListServiceSourceRequest &request)const;
 			void listServiceSourceAsync(const Model::ListServiceSourceRequest& request, const ListServiceSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListServiceSourceOutcomeCallable listServiceSourceCallable(const Model::ListServiceSourceRequest& request) const;
@@ -1024,18 +1116,21 @@ namespace AlibabaCloud
 			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;
+			QueryUserVpcOutcome queryUserVpc(const Model::QueryUserVpcRequest &request)const;
+			void queryUserVpcAsync(const Model::QueryUserVpcRequest& request, const QueryUserVpcAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryUserVpcOutcomeCallable queryUserVpcCallable(const Model::QueryUserVpcRequest& 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;
 			RestartClusterOutcome restartCluster(const Model::RestartClusterRequest &request)const;
 			void restartClusterAsync(const Model::RestartClusterRequest& request, const RestartClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RestartClusterOutcomeCallable restartClusterCallable(const Model::RestartClusterRequest& request) const;
+			RestartSeataServerOutcome restartSeataServer(const Model::RestartSeataServerRequest &request)const;
+			void restartSeataServerAsync(const Model::RestartSeataServerRequest& request, const RestartSeataServerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RestartSeataServerOutcomeCallable restartSeataServerCallable(const Model::RestartSeataServerRequest& request) const;
 			RetryClusterOutcome retryCluster(const Model::RetryClusterRequest &request)const;
 			void retryClusterAsync(const Model::RetryClusterRequest& request, const RetryClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RetryClusterOutcomeCallable retryClusterCallable(const Model::RetryClusterRequest& request) const;
-			ScalingClusterOutcome scalingCluster(const Model::ScalingClusterRequest &request)const;
-			void scalingClusterAsync(const Model::ScalingClusterRequest& request, const ScalingClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ScalingClusterOutcomeCallable scalingClusterCallable(const Model::ScalingClusterRequest& request) const;
 			SelectGatewaySlbOutcome selectGatewaySlb(const Model::SelectGatewaySlbRequest &request)const;
 			void selectGatewaySlbAsync(const Model::SelectGatewaySlbRequest& request, const SelectGatewaySlbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SelectGatewaySlbOutcomeCallable selectGatewaySlbCallable(const Model::SelectGatewaySlbRequest& request) const;
@@ -1081,12 +1176,21 @@ namespace AlibabaCloud
 			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;
+			UpdateGatewayRouteWafStatusOutcome updateGatewayRouteWafStatus(const Model::UpdateGatewayRouteWafStatusRequest &request)const;
+			void updateGatewayRouteWafStatusAsync(const Model::UpdateGatewayRouteWafStatusRequest& request, const UpdateGatewayRouteWafStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateGatewayRouteWafStatusOutcomeCallable updateGatewayRouteWafStatusCallable(const Model::UpdateGatewayRouteWafStatusRequest& request) const;
+			UpdateGatewayServiceTrafficPolicyOutcome updateGatewayServiceTrafficPolicy(const Model::UpdateGatewayServiceTrafficPolicyRequest &request)const;
+			void updateGatewayServiceTrafficPolicyAsync(const Model::UpdateGatewayServiceTrafficPolicyRequest& request, const UpdateGatewayServiceTrafficPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateGatewayServiceTrafficPolicyOutcomeCallable updateGatewayServiceTrafficPolicyCallable(const Model::UpdateGatewayServiceTrafficPolicyRequest& 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;
 			UpdateImageOutcome updateImage(const Model::UpdateImageRequest &request)const;
 			void updateImageAsync(const Model::UpdateImageRequest& request, const UpdateImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateImageOutcomeCallable updateImageCallable(const Model::UpdateImageRequest& request) const;
+			UpdateMessageQueueRouteOutcome updateMessageQueueRoute(const Model::UpdateMessageQueueRouteRequest &request)const;
+			void updateMessageQueueRouteAsync(const Model::UpdateMessageQueueRouteRequest& request, const UpdateMessageQueueRouteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateMessageQueueRouteOutcomeCallable updateMessageQueueRouteCallable(const Model::UpdateMessageQueueRouteRequest& request) const;
 			UpdateNacosClusterOutcome updateNacosCluster(const Model::UpdateNacosClusterRequest &request)const;
 			void updateNacosClusterAsync(const Model::UpdateNacosClusterRequest& request, const UpdateNacosClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateNacosClusterOutcomeCallable updateNacosClusterCallable(const Model::UpdateNacosClusterRequest& request) const;

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

@@ -84,6 +84,8 @@ public:
 	void setGatewayId(long gatewayId);
 	int getRouteOrder() const;
 	void setRouteOrder(int routeOrder);
+	bool getEnableWaf() const;
+	void setEnableWaf(bool enableWaf);
 	std::vector<Services> getServices() const;
 	void setServices(const std::vector<Services> &services);
 	Predicates getPredicates() const;
@@ -104,6 +106,7 @@ private:
 	long domainId_;
 	long gatewayId_;
 	int routeOrder_;
+	bool enableWaf_;
 	std::vector<Services> services_;
 	Predicates predicates_;
 	RedirectJSON redirectJSON_;

mse/include/alibabacloud/mse/model/ScalingClusterRequest.h → mse/include/alibabacloud/mse/model/AddSeataServerRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_MSE_MODEL_SCALINGCLUSTERREQUEST_H_
-#define ALIBABACLOUD_MSE_MODEL_SCALINGCLUSTERREQUEST_H_
+#ifndef ALIBABACLOUD_MSE_MODEL_ADDSEATASERVERREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_ADDSEATASERVERREQUEST_H_
 
 #include <alibabacloud/mse/MseExport.h>
 #include <alibabacloud/core/RpcServiceRequest.h>
@@ -26,35 +26,38 @@
 namespace AlibabaCloud {
 namespace Mse {
 namespace Model {
-class ALIBABACLOUD_MSE_EXPORT ScalingClusterRequest : public RpcServiceRequest {
+class ALIBABACLOUD_MSE_EXPORT AddSeataServerRequest : public RpcServiceRequest {
 public:
-	ScalingClusterRequest();
-	~ScalingClusterRequest();
-	std::string getClusterSpecification() const;
-	void setClusterSpecification(const std::string &clusterSpecification);
-	int getCpu() const;
-	void setCpu(int cpu);
-	std::string getClusterId() const;
-	void setClusterId(const std::string &clusterId);
-	std::string getInstanceId() const;
-	void setInstanceId(const std::string &instanceId);
-	long getMemoryCapacity() const;
-	void setMemoryCapacity(long memoryCapacity);
-	int getInstanceCount() const;
-	void setInstanceCount(int instanceCount);
+	AddSeataServerRequest();
+	~AddSeataServerRequest();
+	int getReplica() const;
+	void setReplica(int replica);
+	std::string getPrimaryUser() const;
+	void setPrimaryUser(const std::string &primaryUser);
+	std::string getVpc() const;
+	void setVpc(const std::string &vpc);
+	std::string getVswitch() const;
+	void setVswitch(const std::string &vswitch);
+	std::string getName() const;
+	void setName(const std::string &name);
 	std::string getAcceptLanguage() const;
 	void setAcceptLanguage(const std::string &acceptLanguage);
+	std::string getZoneId() const;
+	void setZoneId(const std::string &zoneId);
+	std::string getRegion() const;
+	void setRegion(const std::string &region);
 
 private:
-	std::string clusterSpecification_;
-	int cpu_;
-	std::string clusterId_;
-	std::string instanceId_;
-	long memoryCapacity_;
-	int instanceCount_;
+	int replica_;
+	std::string primaryUser_;
+	std::string vpc_;
+	std::string vswitch_;
+	std::string name_;
 	std::string acceptLanguage_;
+	std::string zoneId_;
+	std::string region_;
 };
 } // namespace Model
 } // namespace Mse
 } // namespace AlibabaCloud
-#endif // !ALIBABACLOUD_MSE_MODEL_SCALINGCLUSTERREQUEST_H_
+#endif // !ALIBABACLOUD_MSE_MODEL_ADDSEATASERVERREQUEST_H_

mse/include/alibabacloud/mse/model/ScalingClusterResult.h → mse/include/alibabacloud/mse/model/AddSeataServerResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_MSE_MODEL_SCALINGCLUSTERRESULT_H_
-#define ALIBABACLOUD_MSE_MODEL_SCALINGCLUSTERRESULT_H_
+#ifndef ALIBABACLOUD_MSE_MODEL_ADDSEATASERVERRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_ADDSEATASERVERRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,27 +29,31 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_MSE_EXPORT ScalingClusterResult : public ServiceResult
+			class ALIBABACLOUD_MSE_EXPORT AddSeataServerResult : public ServiceResult
 			{
 			public:
 
 
-				ScalingClusterResult();
-				explicit ScalingClusterResult(const std::string &payload);
-				~ScalingClusterResult();
+				AddSeataServerResult();
+				explicit AddSeataServerResult(const std::string &payload);
+				~AddSeataServerResult();
 				std::string getMessage()const;
-				std::string getErrorCode()const;
+				int getHttpStatusCode()const;
+				std::string getData()const;
+				int getCode()const;
 				bool getSuccess()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
 				std::string message_;
-				std::string errorCode_;
+				int httpStatusCode_;
+				std::string data_;
+				int code_;
 				bool success_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_MSE_MODEL_SCALINGCLUSTERRESULT_H_
+#endif // !ALIBABACLOUD_MSE_MODEL_ADDSEATASERVERRESULT_H_

mse/include/alibabacloud/mse/model/AddSecurityGroupRuleRequest.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_ADDSECURITYGROUPRULEREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_ADDSECURITYGROUPRULEREQUEST_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 AddSecurityGroupRuleRequest : public RpcServiceRequest {
+public:
+	AddSecurityGroupRuleRequest();
+	~AddSecurityGroupRuleRequest();
+	std::string getPortRange() const;
+	void setPortRange(const std::string &portRange);
+	std::string getGatewayUniqueId() const;
+	void setGatewayUniqueId(const std::string &gatewayUniqueId);
+	std::string getSecurityGroupId() const;
+	void setSecurityGroupId(const std::string &securityGroupId);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	std::string portRange_;
+	std::string gatewayUniqueId_;
+	std::string securityGroupId_;
+	std::string description_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_ADDSECURITYGROUPRULEREQUEST_H_

mse/include/alibabacloud/mse/model/AddSecurityGroupRuleResult.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_ADDSECURITYGROUPRULERESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_ADDSECURITYGROUPRULERESULT_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 AddSecurityGroupRuleResult : public ServiceResult
+			{
+			public:
+
+
+				AddSecurityGroupRuleResult();
+				explicit AddSecurityGroupRuleResult(const std::string &payload);
+				~AddSecurityGroupRuleResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_ADDSECURITYGROUPRULERESULT_H_

mse/include/alibabacloud/mse/model/AddServiceSourceRequest.h

@@ -28,8 +28,15 @@ namespace Mse {
 namespace Model {
 class ALIBABACLOUD_MSE_EXPORT AddServiceSourceRequest : public RpcServiceRequest {
 public:
+	struct IngressOptionsRequest {
+		bool enableIngress;
+		std::string watchNamespace;
+		std::string ingressClass;
+	};
 	AddServiceSourceRequest();
 	~AddServiceSourceRequest();
+	IngressOptionsRequest getIngressOptionsRequest() const;
+	void setIngressOptionsRequest(const IngressOptionsRequest &ingressOptionsRequest);
 	std::string getGatewayUniqueId() const;
 	void setGatewayUniqueId(const std::string &gatewayUniqueId);
 	std::string getSource() const;
@@ -44,6 +51,7 @@ public:
 	void setAcceptLanguage(const std::string &acceptLanguage);
 
 private:
+	IngressOptionsRequest ingressOptionsRequest_;
 	std::string gatewayUniqueId_;
 	std::string source_;
 	std::string type_;

mse/include/alibabacloud/mse/model/ListAlarmContactGroupsRequest.h → mse/include/alibabacloud/mse/model/AddTestRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_MSE_MODEL_LISTALARMCONTACTGROUPSREQUEST_H_
-#define ALIBABACLOUD_MSE_MODEL_LISTALARMCONTACTGROUPSREQUEST_H_
+#ifndef ALIBABACLOUD_MSE_MODEL_ADDTESTREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_ADDTESTREQUEST_H_
 
 #include <alibabacloud/mse/MseExport.h>
 #include <alibabacloud/core/RpcServiceRequest.h>
@@ -26,26 +26,29 @@
 namespace AlibabaCloud {
 namespace Mse {
 namespace Model {
-class ALIBABACLOUD_MSE_EXPORT ListAlarmContactGroupsRequest : public RpcServiceRequest {
+class ALIBABACLOUD_MSE_EXPORT AddTestRequest : public RpcServiceRequest {
 public:
-	ListAlarmContactGroupsRequest();
-	~ListAlarmContactGroupsRequest();
-	int getPageNum() const;
-	void setPageNum(int pageNum);
-	std::string getRequestPars() const;
-	void setRequestPars(const std::string &requestPars);
+	AddTestRequest();
+	~AddTestRequest();
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getOrderItem() const;
+	void setOrderItem(const std::string &orderItem);
 	int getPageSize() const;
 	void setPageSize(int pageSize);
 	std::string getAcceptLanguage() const;
 	void setAcceptLanguage(const std::string &acceptLanguage);
+	bool getDescSort() const;
+	void setDescSort(bool descSort);
 
 private:
-	int pageNum_;
-	std::string requestPars_;
+	int pageNumber_;
+	std::string orderItem_;
 	int pageSize_;
 	std::string acceptLanguage_;
+	bool descSort_;
 };
 } // namespace Model
 } // namespace Mse
 } // namespace AlibabaCloud
-#endif // !ALIBABACLOUD_MSE_MODEL_LISTALARMCONTACTGROUPSREQUEST_H_
+#endif // !ALIBABACLOUD_MSE_MODEL_ADDTESTREQUEST_H_

mse/include/alibabacloud/mse/model/AddTestResult.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_ADDTESTRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_ADDTESTRESULT_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 AddTestResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct Gateways
+					{
+						struct SlbItem
+						{
+							std::string slbId;
+							std::string slbPort;
+							std::string statusDesc;
+							std::string type;
+							std::string gatewaySlbMode;
+							std::string slbIp;
+							std::string gatewaySlbStatus;
+							std::string slbSpec;
+						};
+						struct InternetSlbItem
+						{
+							std::string slbId;
+							std::string slbPort;
+							std::string statusDesc;
+							std::string type;
+							std::string gatewaySlbMode;
+							std::string slbIp;
+							std::string gatewaySlbStatus;
+							std::string slbSpec;
+							std::string internetNetworkFlow;
+						};
+						std::string currentVersion;
+						std::vector<Gateways::SlbItem> slb;
+						std::string gmtModified;
+						std::string vswitch2;
+						std::string gatewayType;
+						bool upgrade;
+						std::string name;
+						std::string statusDesc;
+						bool armsOn;
+						std::vector<Gateways::InternetSlbItem> internetSlb;
+						int status;
+						bool mustUpgrade;
+						std::string instanceId;
+						bool ahasOn;
+						int replica;
+						std::string endDate;
+						std::string gatewayUniqueId;
+						std::string gmtCreate;
+						std::string latestVersion;
+						std::string chargeType;
+						std::string region;
+						std::string primaryUser;
+						long id;
+						std::string tag;
+						std::string spec;
+					};
+					int pageSize;
+					int pageNumber;
+					long totalSize;
+					std::vector<Gateways> result;
+				};
+
+
+				AddTestResult();
+				explicit AddTestResult(const std::string &payload);
+				~AddTestResult();
+				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_ADDTESTRESULT_H_

mse/include/alibabacloud/mse/model/CreateAlarmRuleRequest.h

@@ -1,72 +0,0 @@
-/*
- * 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_CREATEALARMRULEREQUEST_H_
-#define ALIBABACLOUD_MSE_MODEL_CREATEALARMRULEREQUEST_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 CreateAlarmRuleRequest : public RpcServiceRequest {
-public:
-	CreateAlarmRuleRequest();
-	~CreateAlarmRuleRequest();
-	int getNValue() const;
-	void setNValue(int nValue);
-	std::string getAlarmItem() const;
-	void setAlarmItem(const std::string &alarmItem);
-	std::string getClusterId() const;
-	void setClusterId(const std::string &clusterId);
-	std::string get_Operator() const;
-	void set_Operator(const std::string &_operator);
-	std::string getAlarmAliasName() const;
-	void setAlarmAliasName(const std::string &alarmAliasName);
-	std::string getInstanceId() const;
-	void setInstanceId(const std::string &instanceId);
-	std::string getContactGroupIds() const;
-	void setContactGroupIds(const std::string &contactGroupIds);
-	std::string getAcceptLanguage() const;
-	void setAcceptLanguage(const std::string &acceptLanguage);
-	std::string getAlertWay() const;
-	void setAlertWay(const std::string &alertWay);
-	std::string getAggregates() const;
-	void setAggregates(const std::string &aggregates);
-	float getValue() const;
-	void setValue(float value);
-
-private:
-	int nValue_;
-	std::string alarmItem_;
-	std::string clusterId_;
-	std::string _operator_;
-	std::string alarmAliasName_;
-	std::string instanceId_;
-	std::string contactGroupIds_;
-	std::string acceptLanguage_;
-	std::string alertWay_;
-	std::string aggregates_;
-	float value_;
-};
-} // namespace Model
-} // namespace Mse
-} // namespace AlibabaCloud
-#endif // !ALIBABACLOUD_MSE_MODEL_CREATEALARMRULEREQUEST_H_

mse/include/alibabacloud/mse/model/CreateApplicationRequest.h

@@ -38,8 +38,12 @@ public:
 	void setExtraInfo(const std::string &extraInfo);
 	std::string getAppName() const;
 	void setAppName(const std::string &appName);
+	std::string getSwitchEnable() const;
+	void setSwitchEnable(const std::string &switchEnable);
 	std::string getAcceptLanguage() const;
 	void setAcceptLanguage(const std::string &acceptLanguage);
+	std::string getSentinelEnable() const;
+	void setSentinelEnable(const std::string &sentinelEnable);
 	std::string getRegion() const;
 	void setRegion(const std::string &region);
 
@@ -48,7 +52,9 @@ private:
 	std::string source_;
 	std::string extraInfo_;
 	std::string appName_;
+	std::string switchEnable_;
 	std::string acceptLanguage_;
+	std::string sentinelEnable_;
 	std::string region_;
 };
 } // namespace Model

mse/include/alibabacloud/mse/model/CreateEngineNamespaceRequest.h

@@ -40,6 +40,8 @@ public:
 	void setName(const std::string &name);
 	std::string getAcceptLanguage() const;
 	void setAcceptLanguage(const std::string &acceptLanguage);
+	std::string getId() const;
+	void setId(const std::string &id);
 	std::string getDesc() const;
 	void setDesc(const std::string &desc);
 
@@ -49,6 +51,7 @@ private:
 	int serviceCount_;
 	std::string name_;
 	std::string acceptLanguage_;
+	std::string id_;
 	std::string desc_;
 };
 } // namespace Model

mse/include/alibabacloud/mse/model/CreateVGroupRequest.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_CREATEVGROUPREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_CREATEVGROUPREQUEST_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 CreateVGroupRequest : public RpcServiceRequest {
+public:
+	CreateVGroupRequest();
+	~CreateVGroupRequest();
+	std::string getPrimaryUser() const;
+	void setPrimaryUser(const std::string &primaryUser);
+	std::string getName() const;
+	void setName(const std::string &name);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	std::string getSeataServerUniqueId() const;
+	void setSeataServerUniqueId(const std::string &seataServerUniqueId);
+	std::string getRegion() const;
+	void setRegion(const std::string &region);
+
+private:
+	std::string primaryUser_;
+	std::string name_;
+	std::string acceptLanguage_;
+	std::string seataServerUniqueId_;
+	std::string region_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_CREATEVGROUPREQUEST_H_

mse/include/alibabacloud/mse/model/CreateAlarmRuleResult.h → mse/include/alibabacloud/mse/model/CreateVGroupResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_MSE_MODEL_CREATEALARMRULERESULT_H_
-#define ALIBABACLOUD_MSE_MODEL_CREATEALARMRULERESULT_H_
+#ifndef ALIBABACLOUD_MSE_MODEL_CREATEVGROUPRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_CREATEVGROUPRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,27 +29,31 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_MSE_EXPORT CreateAlarmRuleResult : public ServiceResult
+			class ALIBABACLOUD_MSE_EXPORT CreateVGroupResult : public ServiceResult
 			{
 			public:
 
 
-				CreateAlarmRuleResult();
-				explicit CreateAlarmRuleResult(const std::string &payload);
-				~CreateAlarmRuleResult();
+				CreateVGroupResult();
+				explicit CreateVGroupResult(const std::string &payload);
+				~CreateVGroupResult();
 				std::string getMessage()const;
-				std::string getErrorCode()const;
+				int getHttpStatusCode()const;
+				std::string getData()const;
+				int getCode()const;
 				bool getSuccess()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
 				std::string message_;
-				std::string errorCode_;
+				int httpStatusCode_;
+				std::string data_;
+				int code_;
 				bool success_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_MSE_MODEL_CREATEALARMRULERESULT_H_
+#endif // !ALIBABACLOUD_MSE_MODEL_CREATEVGROUPRESULT_H_

mse/include/alibabacloud/mse/model/DeleteGatewayDomainResult.h

@@ -38,7 +38,7 @@ namespace AlibabaCloud
 					std::string gmtCreate;
 					bool mustHttps;
 					std::string gmtModified;
-					int certIdentifier;
+					std::string certIdentifier;
 					long id;
 					long gatewayId;
 					std::string protocol;

mse/include/alibabacloud/mse/model/DeleteGatewayServiceRequest.h

@@ -0,0 +1,51 @@
+/*
+ * 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_DELETEGATEWAYSERVICEREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYSERVICEREQUEST_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 DeleteGatewayServiceRequest : public RpcServiceRequest {
+public:
+	DeleteGatewayServiceRequest();
+	~DeleteGatewayServiceRequest();
+	std::string getGatewayUniqueId() const;
+	void setGatewayUniqueId(const std::string &gatewayUniqueId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	std::string getServiceId() const;
+	void setServiceId(const std::string &serviceId);
+	long getGatewayId() const;
+	void setGatewayId(long gatewayId);
+
+private:
+	std::string gatewayUniqueId_;
+	std::string acceptLanguage_;
+	std::string serviceId_;
+	long gatewayId_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYSERVICEREQUEST_H_

mse/include/alibabacloud/mse/model/ListAlarmContactGroupsResult.h → mse/include/alibabacloud/mse/model/DeleteGatewayServiceResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_MSE_MODEL_LISTALARMCONTACTGROUPSRESULT_H_
-#define ALIBABACLOUD_MSE_MODEL_LISTALARMCONTACTGROUPSRESULT_H_
+#ifndef ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYSERVICERESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYSERVICERESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,42 +29,47 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_MSE_EXPORT ListAlarmContactGroupsResult : public ServiceResult
+			class ALIBABACLOUD_MSE_EXPORT DeleteGatewayServiceResult : public ServiceResult
 			{
 			public:
-				struct AlarmContactGroupModel
+				struct Data
 				{
-					std::string contactGroupId;
-					std::string contactGroupName;
+					std::string groupName;
+					std::string sourceType;
+					long sourceId;
+					std::string metaInfo;
+					std::string gmtModified;
+					std::string _namespace;
+					long gatewayId;
+					std::vector<std::string> ips;
+					std::string name;
+					std::string gatewayUniqueId;
+					std::string gmtCreate;
+					std::string serviceNameInRegistry;
+					long id;
 				};
 
 
-				ListAlarmContactGroupsResult();
-				explicit ListAlarmContactGroupsResult(const std::string &payload);
-				~ListAlarmContactGroupsResult();
-				std::string getHttpCode()const;
-				int getTotalCount()const;
+				DeleteGatewayServiceResult();
+				explicit DeleteGatewayServiceResult(const std::string &payload);
+				~DeleteGatewayServiceResult();
 				std::string getMessage()const;
-				int getPageSize()const;
-				int getPageNumber()const;
-				std::vector<AlarmContactGroupModel> getData()const;
-				std::string getErrorCode()const;
+				int getHttpStatusCode()const;
+				Data getData()const;
+				int getCode()const;
 				bool getSuccess()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string httpCode_;
-				int totalCount_;
 				std::string message_;
-				int pageSize_;
-				int pageNumber_;
-				std::vector<AlarmContactGroupModel> data_;
-				std::string errorCode_;
+				int httpStatusCode_;
+				Data data_;
+				int code_;
 				bool success_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_MSE_MODEL_LISTALARMCONTACTGROUPSRESULT_H_
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETEGATEWAYSERVICERESULT_H_

mse/include/alibabacloud/mse/model/DeleteSeataServerRequest.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_DELETESEATASERVERREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETESEATASERVERREQUEST_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 DeleteSeataServerRequest : public RpcServiceRequest {
+public:
+	DeleteSeataServerRequest();
+	~DeleteSeataServerRequest();
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	std::string getSeataServerUniqueId() const;
+	void setSeataServerUniqueId(const std::string &seataServerUniqueId);
+
+private:
+	std::string acceptLanguage_;
+	std::string seataServerUniqueId_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETESEATASERVERREQUEST_H_

mse/include/alibabacloud/mse/model/DeleteSeataServerResult.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_DELETESEATASERVERRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETESEATASERVERRESULT_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 DeleteSeataServerResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteSeataServerResult();
+				explicit DeleteSeataServerResult(const std::string &payload);
+				~DeleteSeataServerResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETESEATASERVERRESULT_H_

mse/include/alibabacloud/mse/model/DeleteSecurityGroupRuleRequest.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_DELETESECURITYGROUPRULEREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETESECURITYGROUPRULEREQUEST_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 DeleteSecurityGroupRuleRequest : public RpcServiceRequest {
+public:
+	DeleteSecurityGroupRuleRequest();
+	~DeleteSecurityGroupRuleRequest();
+	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);
+
+private:
+	std::string gatewayUniqueId_;
+	std::string acceptLanguage_;
+	long id_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETESECURITYGROUPRULEREQUEST_H_

mse/include/alibabacloud/mse/model/DeleteSecurityGroupRuleResult.h

@@ -0,0 +1,71 @@
+/*
+ * 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_DELETESECURITYGROUPRULERESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETESECURITYGROUPRULERESULT_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 DeleteSecurityGroupRuleResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string gatewayUniqueId;
+					std::string portRange;
+					std::string gmtCreate;
+					std::string description;
+					std::string securityGroupId;
+					std::string gmtModified;
+					std::string ipProtocol;
+					long id;
+					long gatewayId;
+				};
+
+
+				DeleteSecurityGroupRuleResult();
+				explicit DeleteSecurityGroupRuleResult(const std::string &payload);
+				~DeleteSecurityGroupRuleResult();
+				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_DELETESECURITYGROUPRULERESULT_H_

mse/include/alibabacloud/mse/model/ListAlarmItemsRequest.h → mse/include/alibabacloud/mse/model/DeleteVGroupRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_MSE_MODEL_LISTALARMITEMSREQUEST_H_
-#define ALIBABACLOUD_MSE_MODEL_LISTALARMITEMSREQUEST_H_
+#ifndef ALIBABACLOUD_MSE_MODEL_DELETEVGROUPREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETEVGROUPREQUEST_H_
 
 #include <alibabacloud/mse/MseExport.h>
 #include <alibabacloud/core/RpcServiceRequest.h>
@@ -26,20 +26,20 @@
 namespace AlibabaCloud {
 namespace Mse {
 namespace Model {
-class ALIBABACLOUD_MSE_EXPORT ListAlarmItemsRequest : public RpcServiceRequest {
+class ALIBABACLOUD_MSE_EXPORT DeleteVGroupRequest : public RpcServiceRequest {
 public:
-	ListAlarmItemsRequest();
-	~ListAlarmItemsRequest();
-	std::string getRequestPars() const;
-	void setRequestPars(const std::string &requestPars);
+	DeleteVGroupRequest();
+	~DeleteVGroupRequest();
+	std::string getName() const;
+	void setName(const std::string &name);
 	std::string getAcceptLanguage() const;
 	void setAcceptLanguage(const std::string &acceptLanguage);
 
 private:
-	std::string requestPars_;
+	std::string name_;
 	std::string acceptLanguage_;
 };
 } // namespace Model
 } // namespace Mse
 } // namespace AlibabaCloud
-#endif // !ALIBABACLOUD_MSE_MODEL_LISTALARMITEMSREQUEST_H_
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETEVGROUPREQUEST_H_

mse/include/alibabacloud/mse/model/DeleteVGroupResult.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_DELETEVGROUPRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_DELETEVGROUPRESULT_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 DeleteVGroupResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteVGroupResult();
+				explicit DeleteVGroupResult(const std::string &payload);
+				~DeleteVGroupResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_DELETEVGROUPRESULT_H_

mse/include/alibabacloud/mse/model/GetAppMessageQueueRouteRequest.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_GETAPPMESSAGEQUEUEROUTEREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_GETAPPMESSAGEQUEUEROUTEREQUEST_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 GetAppMessageQueueRouteRequest : public RpcServiceRequest {
+public:
+	GetAppMessageQueueRouteRequest();
+	~GetAppMessageQueueRouteRequest();
+	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 appId_;
+	std::string acceptLanguage_;
+	std::string region_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_GETAPPMESSAGEQUEUEROUTEREQUEST_H_

mse/include/alibabacloud/mse/model/GetAppMessageQueueRouteResult.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_GETAPPMESSAGEQUEUEROUTERESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_GETAPPMESSAGEQUEUEROUTERESULT_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 GetAppMessageQueueRouteResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string appId;
+					std::string region;
+					bool enable;
+					std::vector<std::string> tags;
+				};
+
+
+				GetAppMessageQueueRouteResult();
+				explicit GetAppMessageQueueRouteResult(const std::string &payload);
+				~GetAppMessageQueueRouteResult();
+				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_GETAPPMESSAGEQUEUEROUTERESULT_H_

mse/include/alibabacloud/mse/model/ListAlarmHistoriesRequest.h → mse/include/alibabacloud/mse/model/GetApplicationListRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_MSE_MODEL_LISTALARMHISTORIESREQUEST_H_
-#define ALIBABACLOUD_MSE_MODEL_LISTALARMHISTORIESREQUEST_H_
+#ifndef ALIBABACLOUD_MSE_MODEL_GETAPPLICATIONLISTREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_GETAPPLICATIONLISTREQUEST_H_
 
 #include <alibabacloud/mse/MseExport.h>
 #include <alibabacloud/core/RpcServiceRequest.h>
@@ -26,38 +26,44 @@
 namespace AlibabaCloud {
 namespace Mse {
 namespace Model {
-class ALIBABACLOUD_MSE_EXPORT ListAlarmHistoriesRequest : public RpcServiceRequest {
+class ALIBABACLOUD_MSE_EXPORT GetApplicationListRequest : public RpcServiceRequest {
 public:
-	ListAlarmHistoriesRequest();
-	~ListAlarmHistoriesRequest();
-	long getEndTime() const;
-	void setEndTime(long endTime);
-	std::string getAlarmMseType() const;
-	void setAlarmMseType(const std::string &alarmMseType);
-	long getStartTime() const;
-	void setStartTime(long startTime);
-	int getPageNum() const;
-	void setPageNum(int pageNum);
-	std::string getRequestPars() const;
-	void setRequestPars(const std::string &requestPars);
+	GetApplicationListRequest();
+	~GetApplicationListRequest();
+	std::string getLanguage() const;
+	void setLanguage(const std::string &language);
+	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);
 	int getPageSize() const;
 	void setPageSize(int pageSize);
+	bool getSwitchEnable() const;
+	void setSwitchEnable(bool switchEnable);
+	std::string getAppId() const;
+	void setAppId(const std::string &appId);
 	std::string getAcceptLanguage() const;
 	void setAcceptLanguage(const std::string &acceptLanguage);
-	std::string getAlarmName() const;
-	void setAlarmName(const std::string &alarmName);
+	bool getSentinelEnable() const;
+	void setSentinelEnable(bool sentinelEnable);
+	std::string getRegion() const;
+	void setRegion(const std::string &region);
 
 private:
-	long endTime_;
-	std::string alarmMseType_;
-	long startTime_;
-	int pageNum_;
-	std::string requestPars_;
+	std::string language_;
+	std::string source_;
+	int pageNumber_;
+	std::string appName_;
 	int pageSize_;
+	bool switchEnable_;
+	std::string appId_;
 	std::string acceptLanguage_;
-	std::string alarmName_;
+	bool sentinelEnable_;
+	std::string region_;
 };
 } // namespace Model
 } // namespace Mse
 } // namespace AlibabaCloud
-#endif // !ALIBABACLOUD_MSE_MODEL_LISTALARMHISTORIESREQUEST_H_
+#endif // !ALIBABACLOUD_MSE_MODEL_GETAPPLICATIONLISTREQUEST_H_

mse/include/alibabacloud/mse/model/ListAlarmHistoriesResult.h → mse/include/alibabacloud/mse/model/GetApplicationListResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_MSE_MODEL_LISTALARMHISTORIESRESULT_H_
-#define ALIBABACLOUD_MSE_MODEL_LISTALARMHISTORIESRESULT_H_
+#ifndef ALIBABACLOUD_MSE_MODEL_GETAPPLICATIONLISTRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_GETAPPLICATIONLISTRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,46 +29,51 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_MSE_EXPORT ListAlarmHistoriesResult : public ServiceResult
+			class ALIBABACLOUD_MSE_EXPORT GetApplicationListResult : public ServiceResult
 			{
 			public:
-				struct AlarmHistoryModel
+				struct Data
 				{
-					std::string alarmName;
-					std::string alarmTime;
-					std::string alarmEmail;
-					std::string alarmDingDing;
-					std::string alarmPhone;
-					std::string alarmContent;
+					struct ApplicationList
+					{
+						long status;
+						int instancesNumber;
+						std::string appId;
+						std::string language;
+						std::string userId;
+						std::string extraInfo;
+						std::string regionId;
+						std::string source;
+						std::string appName;
+						std::string licenseKey;
+					};
+					int pageSize;
+					int pageNumber;
+					int totalSize;
+					std::vector<ApplicationList> result;
 				};
 
 
-				ListAlarmHistoriesResult();
-				explicit ListAlarmHistoriesResult(const std::string &payload);
-				~ListAlarmHistoriesResult();
-				std::string getHttpCode()const;
-				int getTotalCount()const;
+				GetApplicationListResult();
+				explicit GetApplicationListResult(const std::string &payload);
+				~GetApplicationListResult();
 				std::string getMessage()const;
-				int getPageSize()const;
-				int getPageNumber()const;
-				std::vector<AlarmHistoryModel> getData()const;
-				std::string getErrorCode()const;
+				int getHttpStatusCode()const;
+				Data getData()const;
+				int getCode()const;
 				bool getSuccess()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string httpCode_;
-				int totalCount_;
 				std::string message_;
-				int pageSize_;
-				int pageNumber_;
-				std::vector<AlarmHistoryModel> data_;
-				std::string errorCode_;
+				int httpStatusCode_;
+				Data data_;
+				int code_;
 				bool success_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_MSE_MODEL_LISTALARMHISTORIESRESULT_H_
+#endif // !ALIBABACLOUD_MSE_MODEL_GETAPPLICATIONLISTRESULT_H_

mse/include/alibabacloud/mse/model/DeleteAlarmRuleRequest.h → mse/include/alibabacloud/mse/model/GetDashBoardUrlRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_MSE_MODEL_DELETEALARMRULEREQUEST_H_
-#define ALIBABACLOUD_MSE_MODEL_DELETEALARMRULEREQUEST_H_
+#ifndef ALIBABACLOUD_MSE_MODEL_GETDASHBOARDURLREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_GETDASHBOARDURLREQUEST_H_
 
 #include <alibabacloud/mse/MseExport.h>
 #include <alibabacloud/core/RpcServiceRequest.h>
@@ -26,23 +26,26 @@
 namespace AlibabaCloud {
 namespace Mse {
 namespace Model {
-class ALIBABACLOUD_MSE_EXPORT DeleteAlarmRuleRequest : public RpcServiceRequest {
+class ALIBABACLOUD_MSE_EXPORT GetDashBoardUrlRequest : public RpcServiceRequest {
 public:
-	DeleteAlarmRuleRequest();
-	~DeleteAlarmRuleRequest();
-	std::string getAlarmRuleId() const;
-	void setAlarmRuleId(const std::string &alarmRuleId);
+	GetDashBoardUrlRequest();
+	~GetDashBoardUrlRequest();
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
 	std::string getRequestPars() const;
 	void setRequestPars(const std::string &requestPars);
 	std::string getAcceptLanguage() const;
 	void setAcceptLanguage(const std::string &acceptLanguage);
 
 private:
-	std::string alarmRuleId_;
+	std::string instanceId_;
+	std::string regionId_;
 	std::string requestPars_;
 	std::string acceptLanguage_;
 };
 } // namespace Model
 } // namespace Mse
 } // namespace AlibabaCloud
-#endif // !ALIBABACLOUD_MSE_MODEL_DELETEALARMRULEREQUEST_H_
+#endif // !ALIBABACLOUD_MSE_MODEL_GETDASHBOARDURLREQUEST_H_

mse/include/alibabacloud/mse/model/DeleteAlarmRuleResult.h → mse/include/alibabacloud/mse/model/GetDashBoardUrlResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_MSE_MODEL_DELETEALARMRULERESULT_H_
-#define ALIBABACLOUD_MSE_MODEL_DELETEALARMRULERESULT_H_
+#ifndef ALIBABACLOUD_MSE_MODEL_GETDASHBOARDURLRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_GETDASHBOARDURLRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,16 +29,22 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_MSE_EXPORT DeleteAlarmRuleResult : public ServiceResult
+			class ALIBABACLOUD_MSE_EXPORT GetDashBoardUrlResult : public ServiceResult
 			{
 			public:
+				struct Data
+				{
+					std::string message;
+					std::string urlMap;
+				};
 
 
-				DeleteAlarmRuleResult();
-				explicit DeleteAlarmRuleResult(const std::string &payload);
-				~DeleteAlarmRuleResult();
+				GetDashBoardUrlResult();
+				explicit GetDashBoardUrlResult(const std::string &payload);
+				~GetDashBoardUrlResult();
 				std::string getHttpCode()const;
 				std::string getMessage()const;
+				Data getData()const;
 				std::string getErrorCode()const;
 				bool getSuccess()const;
 
@@ -47,6 +53,7 @@ namespace AlibabaCloud
 			private:
 				std::string httpCode_;
 				std::string message_;
+				Data data_;
 				std::string errorCode_;
 				bool success_;
 
@@ -54,4 +61,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_MSE_MODEL_DELETEALARMRULERESULT_H_
+#endif // !ALIBABACLOUD_MSE_MODEL_GETDASHBOARDURLRESULT_H_

mse/include/alibabacloud/mse/model/GetGatewayDomainDetailResult.h

@@ -45,7 +45,7 @@ namespace AlibabaCloud
 					std::string gatewayUniqueId;
 					std::string gmtCreate;
 					std::string sans;
-					int certIdentifier;
+					std::string certIdentifier;
 					long id;
 					std::string certName;
 					std::string protocol;

mse/include/alibabacloud/mse/model/GetGatewayOptionResult.h

@@ -45,6 +45,7 @@ namespace AlibabaCloud
 						std::string projectName;
 						bool logEnabled;
 					};
+					bool enableWaf;
 					bool disableHttp2Alpn;
 					TraceDetails traceDetails;
 					LogConfigDetails logConfigDetails;

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

@@ -145,6 +145,7 @@ namespace AlibabaCloud
 					std::string gatewayUniqueId;
 					std::string services;
 					std::string gmtCreate;
+					bool enableWaf;
 					int routeOrder;
 					long domainId;
 					Retry retry;

mse/include/alibabacloud/mse/model/ListAlarmRulesResult.h

@@ -1,73 +0,0 @@
-/*
- * 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_LISTALARMRULESRESULT_H_
-#define ALIBABACLOUD_MSE_MODEL_LISTALARMRULESRESULT_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 ListAlarmRulesResult : public ServiceResult
-			{
-			public:
-				struct AlarmRuleModel
-				{
-					std::string alarmRuleId;
-					std::string alarmName;
-					std::string alarmRuleDetail;
-					std::string createTime;
-					std::string alarmStatus;
-				};
-
-
-				ListAlarmRulesResult();
-				explicit ListAlarmRulesResult(const std::string &payload);
-				~ListAlarmRulesResult();
-				std::string getHttpCode()const;
-				int getTotalCount()const;
-				std::string getMessage()const;
-				int getPageSize()const;
-				int getPageNumber()const;
-				std::vector<AlarmRuleModel> getData()const;
-				std::string getErrorCode()const;
-				bool getSuccess()const;
-
-			protected:
-				void parse(const std::string &payload);
-			private:
-				std::string httpCode_;
-				int totalCount_;
-				std::string message_;
-				int pageSize_;
-				int pageNumber_;
-				std::vector<AlarmRuleModel> data_;
-				std::string errorCode_;
-				bool success_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_MSE_MODEL_LISTALARMRULESRESULT_H_

mse/include/alibabacloud/mse/model/ListAlarmRulesRequest.h → mse/include/alibabacloud/mse/model/ListClusterDetailFeatureRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_MSE_MODEL_LISTALARMRULESREQUEST_H_
-#define ALIBABACLOUD_MSE_MODEL_LISTALARMRULESREQUEST_H_
+#ifndef ALIBABACLOUD_MSE_MODEL_LISTCLUSTERDETAILFEATUREREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_LISTCLUSTERDETAILFEATUREREQUEST_H_
 
 #include <alibabacloud/mse/MseExport.h>
 #include <alibabacloud/core/RpcServiceRequest.h>
@@ -26,29 +26,26 @@
 namespace AlibabaCloud {
 namespace Mse {
 namespace Model {
-class ALIBABACLOUD_MSE_EXPORT ListAlarmRulesRequest : public RpcServiceRequest {
+class ALIBABACLOUD_MSE_EXPORT ListClusterDetailFeatureRequest : public RpcServiceRequest {
 public:
-	ListAlarmRulesRequest();
-	~ListAlarmRulesRequest();
-	std::string getAlarmMseType() const;
-	void setAlarmMseType(const std::string &alarmMseType);
-	int getPageNum() const;
-	void setPageNum(int pageNum);
+	ListClusterDetailFeatureRequest();
+	~ListClusterDetailFeatureRequest();
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
 	std::string getRequestPars() const;
 	void setRequestPars(const std::string &requestPars);
-	int getPageSize() const;
-	void setPageSize(int pageSize);
 	std::string getAcceptLanguage() const;
 	void setAcceptLanguage(const std::string &acceptLanguage);
 
 private:
-	std::string alarmMseType_;
-	int pageNum_;
+	std::string instanceId_;
+	std::string regionId_;
 	std::string requestPars_;
-	int pageSize_;
 	std::string acceptLanguage_;
 };
 } // namespace Model
 } // namespace Mse
 } // namespace AlibabaCloud
-#endif // !ALIBABACLOUD_MSE_MODEL_LISTALARMRULESREQUEST_H_
+#endif // !ALIBABACLOUD_MSE_MODEL_LISTCLUSTERDETAILFEATUREREQUEST_H_

mse/include/alibabacloud/mse/model/ListAlarmItemsResult.h → mse/include/alibabacloud/mse/model/ListClusterDetailFeatureResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_MSE_MODEL_LISTALARMITEMSRESULT_H_
-#define ALIBABACLOUD_MSE_MODEL_LISTALARMITEMSRESULT_H_
+#ifndef ALIBABACLOUD_MSE_MODEL_LISTCLUSTERDETAILFEATURERESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_LISTCLUSTERDETAILFEATURERESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,26 +29,25 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_MSE_EXPORT ListAlarmItemsResult : public ServiceResult
+			class ALIBABACLOUD_MSE_EXPORT ListClusterDetailFeatureResult : public ServiceResult
 			{
 			public:
-				struct AlarmItem
+				struct DataItem
 				{
-					std::string alarmDesc;
-					std::string alarmCode;
-					std::string clusterType;
+					std::string featureId;
+					std::string status;
+					std::string message;
+					std::string orderNum;
+					std::string extend;
 				};
 
 
-				ListAlarmItemsResult();
-				explicit ListAlarmItemsResult(const std::string &payload);
-				~ListAlarmItemsResult();
+				ListClusterDetailFeatureResult();
+				explicit ListClusterDetailFeatureResult(const std::string &payload);
+				~ListClusterDetailFeatureResult();
 				std::string getHttpCode()const;
-				int getTotalCount()const;
 				std::string getMessage()const;
-				int getPageSize()const;
-				int getPageNumber()const;
-				std::vector<AlarmItem> getData()const;
+				std::vector<DataItem> getData()const;
 				std::string getErrorCode()const;
 				bool getSuccess()const;
 
@@ -56,11 +55,8 @@ namespace AlibabaCloud
 				void parse(const std::string &payload);
 			private:
 				std::string httpCode_;
-				int totalCount_;
 				std::string message_;
-				int pageSize_;
-				int pageNumber_;
-				std::vector<AlarmItem> data_;
+				std::vector<DataItem> data_;
 				std::string errorCode_;
 				bool success_;
 
@@ -68,4 +64,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_MSE_MODEL_LISTALARMITEMSRESULT_H_
+#endif // !ALIBABACLOUD_MSE_MODEL_LISTCLUSTERDETAILFEATURERESULT_H_

mse/include/alibabacloud/mse/model/ListClustersResult.h

@@ -34,6 +34,7 @@ namespace AlibabaCloud
 			public:
 				struct ClusterForListModel
 				{
+					std::string mseVersion;
 					std::string internetAddress;
 					std::string instanceId;
 					std::string clusterId;

mse/include/alibabacloud/mse/model/ListGatewayDomainRequest.h

@@ -32,11 +32,14 @@ public:
 	~ListGatewayDomainRequest();
 	std::string getGatewayUniqueId() const;
 	void setGatewayUniqueId(const std::string &gatewayUniqueId);
+	std::string getType() const;
+	void setType(const std::string &type);
 	std::string getAcceptLanguage() const;
 	void setAcceptLanguage(const std::string &acceptLanguage);
 
 private:
 	std::string gatewayUniqueId_;
+	std::string type_;
 	std::string acceptLanguage_;
 };
 } // namespace Model

mse/include/alibabacloud/mse/model/ListGatewayDomainResult.h

@@ -34,7 +34,14 @@ namespace AlibabaCloud
 			public:
 				struct Domains
 				{
+					struct Comment
+					{
+						std::string status;
+					};
+					int status;
+					Comment comment;
 					std::string gmtCreate;
+					std::string type;
 					bool mustHttps;
 					std::string gmtModified;
 					std::string certIdentifier;

mse/include/alibabacloud/mse/model/ListGatewayResult.h

@@ -36,6 +36,11 @@ namespace AlibabaCloud
 				{
 					struct Gateways
 					{
+						struct InitConfig
+						{
+							bool enableWaf;
+							bool supportWaf;
+						};
 						struct SlbItem
 						{
 							std::string slbId;
@@ -66,10 +71,12 @@ namespace AlibabaCloud
 						std::string gatewayType;
 						bool upgrade;
 						std::string name;
+						std::string appVersion;
 						std::string statusDesc;
 						bool armsOn;
 						std::vector<Gateways::InternetSlbItem> internetSlb;
 						int status;
+						bool supportWasm;
 						bool mustUpgrade;
 						std::string instanceId;
 						bool ahasOn;
@@ -79,6 +86,7 @@ namespace AlibabaCloud
 						std::string gmtCreate;
 						std::string latestVersion;
 						std::string chargeType;
+						InitConfig initConfig;
 						std::string region;
 						std::string primaryUser;
 						long id;

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

@@ -33,6 +33,7 @@ public:
 		int routeOrder;
 		std::string gatewayUniqueId;
 		std::string name;
+		std::string domainName;
 		long gatewayId;
 		long domainId;
 		int status;

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

@@ -72,6 +72,10 @@ namespace AlibabaCloud
 							std::string host;
 							int code;
 						};
+						struct Comment
+						{
+							std::string status;
+						};
 						struct RouteServicesItem
 						{
 							std::string groupName;
@@ -85,6 +89,7 @@ namespace AlibabaCloud
 						};
 						int status;
 						std::string defaultServiceName;
+						Comment comment;
 						std::string domainName;
 						std::string gmtModified;
 						long defaultServiceId;
@@ -97,6 +102,8 @@ namespace AlibabaCloud
 						std::string services;
 						std::vector<std::string> domainIdList;
 						std::string gmtCreate;
+						std::string type;
+						std::string enableWaf;
 						int routeOrder;
 						long domainId;
 						std::vector<std::string> domainNameList;

mse/include/alibabacloud/mse/model/ListGatewayServiceResult.h

@@ -46,6 +46,7 @@ namespace AlibabaCloud
 						long sourceId;
 						std::string metaInfo;
 						std::string gmtModified;
+						std::string healehStatus;
 						std::string _namespace;
 						long gatewayId;
 						std::vector<std::string> ips;

mse/include/alibabacloud/mse/model/ListInstancesRequest.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_LISTINSTANCESREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_LISTINSTANCESREQUEST_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 ListInstancesRequest : public RpcServiceRequest {
+public:
+	ListInstancesRequest();
+	~ListInstancesRequest();
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	std::string getRegion() const;
+	void setRegion(const std::string &region);
+
+private:
+	std::string userId_;
+	std::string acceptLanguage_;
+	std::string region_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_LISTINSTANCESREQUEST_H_

mse/include/alibabacloud/mse/model/ListInstancesResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_MSE_MODEL_LISTINSTANCESRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_LISTINSTANCESRESULT_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 ListInstancesResult : public ServiceResult
+			{
+			public:
+				struct Instance
+				{
+					std::string dbPassword;
+					std::string podCidr;
+					std::string gmtModified;
+					std::string vpc;
+					std::string storeMode;
+					std::string appClusterId;
+					std::string name;
+					std::string appVersion;
+					bool isCreatedRedis;
+					std::string startDate;
+					std::string statusDesc;
+					long environmentId;
+					std::string vswitch;
+					std::string dbUrl;
+					std::string dbUserName;
+					long status;
+					std::string zoneId;
+					std::string instanceId;
+					std::string nameServer;
+					std::string orderId;
+					std::string securityGroup;
+					long endDate;
+					long replica;
+					std::string seataServerUniqueId;
+					std::string gmtCreate;
+					std::string imageVersion;
+					long k8sResourceId;
+					std::string primaryUser;
+					std::string region;
+					long id;
+					std::string spec;
+				};
+
+
+				ListInstancesResult();
+				explicit ListInstancesResult(const std::string &payload);
+				~ListInstancesResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::vector<Instance> getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::vector<Instance> data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_LISTINSTANCESRESULT_H_

mse/include/alibabacloud/mse/model/ListListenersByConfigResult.h

@@ -34,6 +34,7 @@ namespace AlibabaCloud
 			public:
 				struct Listener
 				{
+					std::string status;
 					std::string ip;
 					std::string md5;
 				};

mse/include/alibabacloud/mse/model/ListSecurityGroupRequest.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_LISTSECURITYGROUPREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_LISTSECURITYGROUPREQUEST_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 ListSecurityGroupRequest : public RpcServiceRequest {
+public:
+	ListSecurityGroupRequest();
+	~ListSecurityGroupRequest();
+	std::string getGatewayUniqueId() const;
+	void setGatewayUniqueId(const std::string &gatewayUniqueId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	std::string gatewayUniqueId_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_LISTSECURITYGROUPREQUEST_H_

mse/include/alibabacloud/mse/model/ListSecurityGroupResult.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_LISTSECURITYGROUPRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_LISTSECURITYGROUPRESULT_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 ListSecurityGroupResult : public ServiceResult
+			{
+			public:
+				struct Sgs
+				{
+					std::string securityGroupName;
+					std::string vpcId;
+					std::string securityGroupId;
+					std::string securityGroupType;
+				};
+
+
+				ListSecurityGroupResult();
+				explicit ListSecurityGroupResult(const std::string &payload);
+				~ListSecurityGroupResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::vector<Sgs> getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::vector<Sgs> data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_LISTSECURITYGROUPRESULT_H_

mse/include/alibabacloud/mse/model/ListSecurityGroupRuleRequest.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_LISTSECURITYGROUPRULEREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_LISTSECURITYGROUPRULEREQUEST_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 ListSecurityGroupRuleRequest : public RpcServiceRequest {
+public:
+	ListSecurityGroupRuleRequest();
+	~ListSecurityGroupRuleRequest();
+	std::string getGatewayUniqueId() const;
+	void setGatewayUniqueId(const std::string &gatewayUniqueId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	std::string gatewayUniqueId_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_LISTSECURITYGROUPRULEREQUEST_H_

mse/include/alibabacloud/mse/model/ListSecurityGroupRuleResult.h

@@ -0,0 +1,71 @@
+/*
+ * 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_LISTSECURITYGROUPRULERESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_LISTSECURITYGROUPRULERESULT_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 ListSecurityGroupRuleResult : public ServiceResult
+			{
+			public:
+				struct Rules
+				{
+					std::string gatewayUniqueId;
+					std::string portRange;
+					std::string gmtCreate;
+					std::string description;
+					std::string securityGroupId;
+					std::string gmtModified;
+					std::string ipProtocol;
+					std::string id;
+					long gatewayId;
+				};
+
+
+				ListSecurityGroupRuleResult();
+				explicit ListSecurityGroupRuleResult(const std::string &payload);
+				~ListSecurityGroupRuleResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::vector<Rules> getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::vector<Rules> data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_LISTSECURITYGROUPRULERESULT_H_

mse/include/alibabacloud/mse/model/ListServiceSourceResult.h

@@ -34,8 +34,15 @@ namespace AlibabaCloud
 			public:
 				struct Sources
 				{
+					struct IngressOptions
+					{
+						std::string ingressClass;
+						std::string watchNamespace;
+						bool enableIngress;
+					};
 					std::string type;
 					std::string gmtCreate;
+					IngressOptions ingressOptions;
 					std::string sourceUniqueId;
 					std::string address;
 					std::string gmtModified;

mse/include/alibabacloud/mse/model/PullServicesRequest.h

@@ -30,8 +30,6 @@ class ALIBABACLOUD_MSE_EXPORT PullServicesRequest : public RpcServiceRequest {
 public:
 	PullServicesRequest();
 	~PullServicesRequest();
-	std::string getSourceId() const;
-	void setSourceId(const std::string &sourceId);
 	std::string getGatewayUniqueId() const;
 	void setGatewayUniqueId(const std::string &gatewayUniqueId);
 	std::string getAcceptLanguage() const;
@@ -40,7 +38,6 @@ public:
 	void setSourceType(const std::string &sourceType);
 
 private:
-	std::string sourceId_;
 	std::string gatewayUniqueId_;
 	std::string acceptLanguage_;
 	std::string sourceType_;

mse/include/alibabacloud/mse/model/PullServicesResult.h

@@ -44,6 +44,7 @@ namespace AlibabaCloud
 					};
 					std::string groupName;
 					std::vector<PullServices::ServicesItem> services;
+					std::string namespaceShowName;
 					std::string _namespace;
 				};
 

mse/include/alibabacloud/mse/model/QueryClusterDetailRequest.h

@@ -30,6 +30,8 @@ class ALIBABACLOUD_MSE_EXPORT QueryClusterDetailRequest : public RpcServiceReque
 public:
 	QueryClusterDetailRequest();
 	~QueryClusterDetailRequest();
+	bool getAclSwitch() const;
+	void setAclSwitch(bool aclSwitch);
 	std::string getOrderId() const;
 	void setOrderId(const std::string &orderId);
 	std::string getClusterId() const;
@@ -40,6 +42,7 @@ public:
 	void setAcceptLanguage(const std::string &acceptLanguage);
 
 private:
+	bool aclSwitch_;
 	std::string orderId_;
 	std::string clusterId_;
 	std::string instanceId_;

mse/include/alibabacloud/mse/model/QueryClusterDetailResult.h

@@ -41,6 +41,7 @@ namespace AlibabaCloud
 						std::string internetIp;
 						std::string creationTimestamp;
 						std::string singleTunnelVip;
+						std::string zone;
 						std::string ip;
 						std::string healthStatus;
 					};

mse/include/alibabacloud/mse/model/QueryUserVpcRequest.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_QUERYUSERVPCREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_QUERYUSERVPCREQUEST_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 QueryUserVpcRequest : public RpcServiceRequest {
+public:
+	QueryUserVpcRequest();
+	~QueryUserVpcRequest();
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	std::string getRegion() const;
+	void setRegion(const std::string &region);
+
+private:
+	std::string userId_;
+	std::string acceptLanguage_;
+	std::string region_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_QUERYUSERVPCREQUEST_H_

mse/include/alibabacloud/mse/model/QueryUserVpcResult.h

@@ -0,0 +1,71 @@
+/*
+ * 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_QUERYUSERVPCRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_QUERYUSERVPCRESULT_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 QueryUserVpcResult : public ServiceResult
+			{
+			public:
+				struct Vpcs
+				{
+					struct VSwitchListItem
+					{
+						std::string zoneId;
+						std::string vswitchName;
+						std::string vswitchId;
+					};
+					std::string vpcId;
+					std::vector<Vpcs::VSwitchListItem> vSwitchList;
+					std::string vpcName;
+				};
+
+
+				QueryUserVpcResult();
+				explicit QueryUserVpcResult(const std::string &payload);
+				~QueryUserVpcResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::vector<Vpcs> getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::vector<Vpcs> data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_QUERYUSERVPCRESULT_H_

mse/include/alibabacloud/mse/model/QueryZnodeDetailRequest.h

@@ -34,6 +34,8 @@ public:
 	void setClusterId(const std::string &clusterId);
 	std::string getPath() const;
 	void setPath(const std::string &path);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
 	std::string getRequestPars() const;
 	void setRequestPars(const std::string &requestPars);
 	std::string getAcceptLanguage() const;
@@ -42,6 +44,7 @@ public:
 private:
 	std::string clusterId_;
 	std::string path_;
+	std::string instanceId_;
 	std::string requestPars_;
 	std::string acceptLanguage_;
 };

mse/include/alibabacloud/mse/model/RestartSeataServerRequest.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_RESTARTSEATASERVERREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_RESTARTSEATASERVERREQUEST_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 RestartSeataServerRequest : public RpcServiceRequest {
+public:
+	RestartSeataServerRequest();
+	~RestartSeataServerRequest();
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	std::string getSeataServerUniqueId() const;
+	void setSeataServerUniqueId(const std::string &seataServerUniqueId);
+
+private:
+	std::string acceptLanguage_;
+	std::string seataServerUniqueId_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_RESTARTSEATASERVERREQUEST_H_

mse/include/alibabacloud/mse/model/RestartSeataServerResult.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_RESTARTSEATASERVERRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_RESTARTSEATASERVERRESULT_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 RestartSeataServerResult : public ServiceResult
+			{
+			public:
+
+
+				RestartSeataServerResult();
+				explicit RestartSeataServerResult(const std::string &payload);
+				~RestartSeataServerResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_RESTARTSEATASERVERRESULT_H_

mse/include/alibabacloud/mse/model/UpdateGatewayOptionRequest.h

@@ -29,6 +29,7 @@ namespace Model {
 class ALIBABACLOUD_MSE_EXPORT UpdateGatewayOptionRequest : public RpcServiceRequest {
 public:
 	struct GatewayOption {
+		bool enableWaf;
 		bool enableHardwareAcceleration;
 		bool disableHttp2Alpn;
 		struct LogConfigDetails {

mse/include/alibabacloud/mse/model/UpdateGatewayOptionResult.h

@@ -45,6 +45,7 @@ namespace AlibabaCloud
 						std::string projectName;
 						bool logEnabled;
 					};
+					bool enableWaf;
 					bool disableHttp2Alpn;
 					TraceDetails traceDetails;
 					LogConfigDetails logConfigDetails;

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

@@ -84,6 +84,8 @@ public:
 	void setGatewayId(long gatewayId);
 	int getRouteOrder() const;
 	void setRouteOrder(int routeOrder);
+	bool getEnableWaf() const;
+	void setEnableWaf(bool enableWaf);
 	std::vector<Services> getServices() const;
 	void setServices(const std::vector<Services> &services);
 	Predicates getPredicates() const;
@@ -104,6 +106,7 @@ private:
 	long id_;
 	long gatewayId_;
 	int routeOrder_;
+	bool enableWaf_;
 	std::vector<Services> services_;
 	Predicates predicates_;
 	RedirectJSON redirectJSON_;

mse/include/alibabacloud/mse/model/UpdateGatewayRouteWafStatusRequest.h

@@ -0,0 +1,51 @@
+/*
+ * 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_UPDATEGATEWAYROUTEWAFSTATUSREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTEWAFSTATUSREQUEST_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 UpdateGatewayRouteWafStatusRequest : public RpcServiceRequest {
+public:
+	UpdateGatewayRouteWafStatusRequest();
+	~UpdateGatewayRouteWafStatusRequest();
+	bool getEnableWaf() const;
+	void setEnableWaf(bool enableWaf);
+	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:
+	bool enableWaf_;
+	std::string gatewayUniqueId_;
+	long routeId_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTEWAFSTATUSREQUEST_H_

mse/include/alibabacloud/mse/model/UpdateGatewayRouteWafStatusResult.h

@@ -0,0 +1,181 @@
+/*
+ * 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_UPDATEGATEWAYROUTEWAFSTATUSRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYROUTEWAFSTATUSRESULT_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 UpdateGatewayRouteWafStatusResult : 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;
+					bool enableWaf;
+					int routeOrder;
+					long domainId;
+					Retry retry;
+					long id;
+					HTTPRewrite hTTPRewrite;
+					std::string predicates;
+					std::vector<RouteServicesItem> routeServices;
+				};
+
+
+				UpdateGatewayRouteWafStatusResult();
+				explicit UpdateGatewayRouteWafStatusResult(const std::string &payload);
+				~UpdateGatewayRouteWafStatusResult();
+				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_UPDATEGATEWAYROUTEWAFSTATUSRESULT_H_

mse/include/alibabacloud/mse/model/UpdateGatewayServiceTrafficPolicyRequest.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_UPDATEGATEWAYSERVICETRAFFICPOLICYREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYSERVICETRAFFICPOLICYREQUEST_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 UpdateGatewayServiceTrafficPolicyRequest : public RpcServiceRequest {
+public:
+	struct GatewayTrafficPolicy {
+		struct TlsSetting {
+			std::string tlsMode;
+			std::string caCertContent;
+			std::string certId;
+			std::string sni;
+		};
+		TlsSetting tlsSetting;
+		struct LoadBalancerSettings {
+			std::string loadbalancerType;
+			struct ConsistentHashLBConfig {
+				struct HttpCookie {
+					std::string path;
+					std::string name;
+					std::string tTL;
+				};
+				HttpCookie httpCookie;
+				std::string parameterName;
+				std::string consistentHashLBType;
+			};
+			ConsistentHashLBConfig consistentHashLBConfig;
+		};
+		LoadBalancerSettings loadBalancerSettings;
+	};
+	UpdateGatewayServiceTrafficPolicyRequest();
+	~UpdateGatewayServiceTrafficPolicyRequest();
+	std::string getGatewayUniqueId() const;
+	void setGatewayUniqueId(const std::string &gatewayUniqueId);
+	GatewayTrafficPolicy getGatewayTrafficPolicy() const;
+	void setGatewayTrafficPolicy(const GatewayTrafficPolicy &gatewayTrafficPolicy);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+	long getServiceId() const;
+	void setServiceId(long serviceId);
+	long getGatewayId() const;
+	void setGatewayId(long gatewayId);
+
+private:
+	std::string gatewayUniqueId_;
+	GatewayTrafficPolicy gatewayTrafficPolicy_;
+	std::string acceptLanguage_;
+	long serviceId_;
+	long gatewayId_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYSERVICETRAFFICPOLICYREQUEST_H_

mse/include/alibabacloud/mse/model/UpdateGatewayServiceTrafficPolicyResult.h

@@ -0,0 +1,99 @@
+/*
+ * 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_UPDATEGATEWAYSERVICETRAFFICPOLICYRESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_UPDATEGATEWAYSERVICETRAFFICPOLICYRESULT_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 UpdateGatewayServiceTrafficPolicyResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct GatewayTrafficPolicy
+					{
+						struct TlsSetting
+						{
+							std::string certId;
+							std::string caCertContent;
+							std::string tlsMode;
+							std::string sni;
+						};
+						struct LoadBalancerSettings
+						{
+							struct ConsistentHashLBConfig
+							{
+								struct HttpCookie
+								{
+									std::string path;
+									std::string tTL;
+									std::string name;
+								};
+								std::string consistentHashLBType;
+								std::string parameterName;
+								HttpCookie httpCookie;
+							};
+							ConsistentHashLBConfig consistentHashLBConfig;
+							std::string loadbalancerType;
+						};
+						TlsSetting tlsSetting;
+						LoadBalancerSettings loadBalancerSettings;
+					};
+					std::string groupName;
+					std::string gatewayUniqueId;
+					std::string sourceType;
+					std::string metaInfo;
+					std::string _namespace;
+					long id;
+					GatewayTrafficPolicy gatewayTrafficPolicy;
+					std::string name;
+				};
+
+
+				UpdateGatewayServiceTrafficPolicyResult();
+				explicit UpdateGatewayServiceTrafficPolicyResult(const std::string &payload);
+				~UpdateGatewayServiceTrafficPolicyResult();
+				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_UPDATEGATEWAYSERVICETRAFFICPOLICYRESULT_H_

mse/include/alibabacloud/mse/model/UpdateMessageQueueRouteRequest.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_UPDATEMESSAGEQUEUEROUTEREQUEST_H_
+#define ALIBABACLOUD_MSE_MODEL_UPDATEMESSAGEQUEUEROUTEREQUEST_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 UpdateMessageQueueRouteRequest : public RpcServiceRequest {
+public:
+	UpdateMessageQueueRouteRequest();
+	~UpdateMessageQueueRouteRequest();
+	std::vector<std::string> getTags() const;
+	void setTags(const std::vector<std::string> &tags);
+	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::vector<std::string> tags_;
+	bool enable_;
+	std::string appId_;
+	std::string acceptLanguage_;
+	std::string region_;
+};
+} // namespace Model
+} // namespace Mse
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSE_MODEL_UPDATEMESSAGEQUEUEROUTEREQUEST_H_

mse/include/alibabacloud/mse/model/UpdateMessageQueueRouteResult.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_UPDATEMESSAGEQUEUEROUTERESULT_H_
+#define ALIBABACLOUD_MSE_MODEL_UPDATEMESSAGEQUEUEROUTERESULT_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 UpdateMessageQueueRouteResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateMessageQueueRouteResult();
+				explicit UpdateMessageQueueRouteResult(const std::string &payload);
+				~UpdateMessageQueueRouteResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getData()const;
+				int getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string data_;
+				int code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSE_MODEL_UPDATEMESSAGEQUEUEROUTERESULT_H_

mse/src/model/AddGatewayRouteRequest.cc

@@ -79,6 +79,15 @@ void AddGatewayRouteRequest::setRouteOrder(int routeOrder) {
   setParameter(std::string("RouteOrder"), std::to_string(routeOrder));
 }
 
+bool AddGatewayRouteRequest::getEnableWaf() const {
+  return enableWaf_;
+}
+
+void AddGatewayRouteRequest::setEnableWaf(bool enableWaf) {
+  enableWaf_ = enableWaf;
+  setParameter(std::string("EnableWaf"), enableWaf ? "true" : "false");
+}
+
 std::vector<AddGatewayRouteRequest::Services> AddGatewayRouteRequest::getServices() const {
   return services_;
 }

mse/src/model/AddSSLCertRequest.cc

@@ -20,7 +20,7 @@ using AlibabaCloud::Mse::Model::AddSSLCertRequest;
 
 AddSSLCertRequest::AddSSLCertRequest()
     : RpcServiceRequest("mse", "2019-05-31", "AddSSLCert") {
-  setMethod(HttpRequest::Method::Get);
+  setMethod(HttpRequest::Method::Post);
 }
 
 AddSSLCertRequest::~AddSSLCertRequest() {}

mse/src/model/AddSeataServerRequest.cc

@@ -0,0 +1,99 @@
+/*
+ * 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/AddSeataServerRequest.h>
+
+using AlibabaCloud::Mse::Model::AddSeataServerRequest;
+
+AddSeataServerRequest::AddSeataServerRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "AddSeataServer") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AddSeataServerRequest::~AddSeataServerRequest() {}
+
+int AddSeataServerRequest::getReplica() const {
+  return replica_;
+}
+
+void AddSeataServerRequest::setReplica(int replica) {
+  replica_ = replica;
+  setParameter(std::string("Replica"), std::to_string(replica));
+}
+
+std::string AddSeataServerRequest::getPrimaryUser() const {
+  return primaryUser_;
+}
+
+void AddSeataServerRequest::setPrimaryUser(const std::string &primaryUser) {
+  primaryUser_ = primaryUser;
+  setParameter(std::string("PrimaryUser"), primaryUser);
+}
+
+std::string AddSeataServerRequest::getVpc() const {
+  return vpc_;
+}
+
+void AddSeataServerRequest::setVpc(const std::string &vpc) {
+  vpc_ = vpc;
+  setParameter(std::string("Vpc"), vpc);
+}
+
+std::string AddSeataServerRequest::getVswitch() const {
+  return vswitch_;
+}
+
+void AddSeataServerRequest::setVswitch(const std::string &vswitch) {
+  vswitch_ = vswitch;
+  setParameter(std::string("Vswitch"), vswitch);
+}
+
+std::string AddSeataServerRequest::getName() const {
+  return name_;
+}
+
+void AddSeataServerRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+std::string AddSeataServerRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void AddSeataServerRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+
+std::string AddSeataServerRequest::getZoneId() const {
+  return zoneId_;
+}
+
+void AddSeataServerRequest::setZoneId(const std::string &zoneId) {
+  zoneId_ = zoneId;
+  setParameter(std::string("ZoneId"), zoneId);
+}
+
+std::string AddSeataServerRequest::getRegion() const {
+  return region_;
+}
+
+void AddSeataServerRequest::setRegion(const std::string &region) {
+  region_ = region;
+  setParameter(std::string("Region"), region);
+}
+

mse/src/model/AddSeataServerResult.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/AddSeataServerResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+AddSeataServerResult::AddSeataServerResult() :
+	ServiceResult()
+{}
+
+AddSeataServerResult::AddSeataServerResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AddSeataServerResult::~AddSeataServerResult()
+{}
+
+void AddSeataServerResult::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();
+
+}
+
+std::string AddSeataServerResult::getMessage()const
+{
+	return message_;
+}
+
+int AddSeataServerResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string AddSeataServerResult::getData()const
+{
+	return data_;
+}
+
+int AddSeataServerResult::getCode()const
+{
+	return code_;
+}
+
+bool AddSeataServerResult::getSuccess()const
+{
+	return success_;
+}
+

mse/src/model/AddSecurityGroupRuleRequest.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/AddSecurityGroupRuleRequest.h>
+
+using AlibabaCloud::Mse::Model::AddSecurityGroupRuleRequest;
+
+AddSecurityGroupRuleRequest::AddSecurityGroupRuleRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "AddSecurityGroupRule") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AddSecurityGroupRuleRequest::~AddSecurityGroupRuleRequest() {}
+
+std::string AddSecurityGroupRuleRequest::getPortRange() const {
+  return portRange_;
+}
+
+void AddSecurityGroupRuleRequest::setPortRange(const std::string &portRange) {
+  portRange_ = portRange;
+  setParameter(std::string("PortRange"), portRange);
+}
+
+std::string AddSecurityGroupRuleRequest::getGatewayUniqueId() const {
+  return gatewayUniqueId_;
+}
+
+void AddSecurityGroupRuleRequest::setGatewayUniqueId(const std::string &gatewayUniqueId) {
+  gatewayUniqueId_ = gatewayUniqueId;
+  setParameter(std::string("GatewayUniqueId"), gatewayUniqueId);
+}
+
+std::string AddSecurityGroupRuleRequest::getSecurityGroupId() const {
+  return securityGroupId_;
+}
+
+void AddSecurityGroupRuleRequest::setSecurityGroupId(const std::string &securityGroupId) {
+  securityGroupId_ = securityGroupId;
+  setParameter(std::string("SecurityGroupId"), securityGroupId);
+}
+
+std::string AddSecurityGroupRuleRequest::getDescription() const {
+  return description_;
+}
+
+void AddSecurityGroupRuleRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+std::string AddSecurityGroupRuleRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void AddSecurityGroupRuleRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+

mse/src/model/AddSecurityGroupRuleResult.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/AddSecurityGroupRuleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+AddSecurityGroupRuleResult::AddSecurityGroupRuleResult() :
+	ServiceResult()
+{}
+
+AddSecurityGroupRuleResult::AddSecurityGroupRuleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AddSecurityGroupRuleResult::~AddSecurityGroupRuleResult()
+{}
+
+void AddSecurityGroupRuleResult::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();
+
+}
+
+std::string AddSecurityGroupRuleResult::getMessage()const
+{
+	return message_;
+}
+
+int AddSecurityGroupRuleResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string AddSecurityGroupRuleResult::getData()const
+{
+	return data_;
+}
+
+int AddSecurityGroupRuleResult::getCode()const
+{
+	return code_;
+}
+
+bool AddSecurityGroupRuleResult::getSuccess()const
+{
+	return success_;
+}
+

mse/src/model/AddServiceSourceRequest.cc

@@ -25,6 +25,17 @@ AddServiceSourceRequest::AddServiceSourceRequest()
 
 AddServiceSourceRequest::~AddServiceSourceRequest() {}
 
+AddServiceSourceRequest::IngressOptionsRequest AddServiceSourceRequest::getIngressOptionsRequest() const {
+  return ingressOptionsRequest_;
+}
+
+void AddServiceSourceRequest::setIngressOptionsRequest(const AddServiceSourceRequest::IngressOptionsRequest &ingressOptionsRequest) {
+  ingressOptionsRequest_ = ingressOptionsRequest;
+  setParameter(std::string("IngressOptionsRequest") + ".EnableIngress", ingressOptionsRequest.enableIngress ? "true" : "false");
+  setParameter(std::string("IngressOptionsRequest") + ".WatchNamespace", ingressOptionsRequest.watchNamespace);
+  setParameter(std::string("IngressOptionsRequest") + ".IngressClass", ingressOptionsRequest.ingressClass);
+}
+
 std::string AddServiceSourceRequest::getGatewayUniqueId() const {
   return gatewayUniqueId_;
 }

mse/src/model/AddTestRequest.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/AddTestRequest.h>
+
+using AlibabaCloud::Mse::Model::AddTestRequest;
+
+AddTestRequest::AddTestRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "AddTest") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AddTestRequest::~AddTestRequest() {}
+
+int AddTestRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void AddTestRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string AddTestRequest::getOrderItem() const {
+  return orderItem_;
+}
+
+void AddTestRequest::setOrderItem(const std::string &orderItem) {
+  orderItem_ = orderItem;
+  setParameter(std::string("OrderItem"), orderItem);
+}
+
+int AddTestRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void AddTestRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string AddTestRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void AddTestRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+
+bool AddTestRequest::getDescSort() const {
+  return descSort_;
+}
+
+void AddTestRequest::setDescSort(bool descSort) {
+  descSort_ = descSort;
+  setParameter(std::string("DescSort"), descSort ? "true" : "false");
+}
+

mse/src/model/AddTestResult.cc

@@ -0,0 +1,182 @@
+/*
+ * 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/AddTestResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+AddTestResult::AddTestResult() :
+	ServiceResult()
+{}
+
+AddTestResult::AddTestResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AddTestResult::~AddTestResult()
+{}
+
+void AddTestResult::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"]["Gateways"];
+	for (auto dataNodeResultGateways : allResultNode)
+	{
+		Data::Gateways gatewaysObject;
+		if(!dataNodeResultGateways["Id"].isNull())
+			gatewaysObject.id = std::stol(dataNodeResultGateways["Id"].asString());
+		if(!dataNodeResultGateways["Name"].isNull())
+			gatewaysObject.name = dataNodeResultGateways["Name"].asString();
+		if(!dataNodeResultGateways["GatewayUniqueId"].isNull())
+			gatewaysObject.gatewayUniqueId = dataNodeResultGateways["GatewayUniqueId"].asString();
+		if(!dataNodeResultGateways["GatewayType"].isNull())
+			gatewaysObject.gatewayType = dataNodeResultGateways["GatewayType"].asString();
+		if(!dataNodeResultGateways["Region"].isNull())
+			gatewaysObject.region = dataNodeResultGateways["Region"].asString();
+		if(!dataNodeResultGateways["PrimaryUser"].isNull())
+			gatewaysObject.primaryUser = dataNodeResultGateways["PrimaryUser"].asString();
+		if(!dataNodeResultGateways["Status"].isNull())
+			gatewaysObject.status = std::stoi(dataNodeResultGateways["Status"].asString());
+		if(!dataNodeResultGateways["AhasOn"].isNull())
+			gatewaysObject.ahasOn = dataNodeResultGateways["AhasOn"].asString() == "true";
+		if(!dataNodeResultGateways["ArmsOn"].isNull())
+			gatewaysObject.armsOn = dataNodeResultGateways["ArmsOn"].asString() == "true";
+		if(!dataNodeResultGateways["Spec"].isNull())
+			gatewaysObject.spec = dataNodeResultGateways["Spec"].asString();
+		if(!dataNodeResultGateways["Replica"].isNull())
+			gatewaysObject.replica = std::stoi(dataNodeResultGateways["Replica"].asString());
+		if(!dataNodeResultGateways["GmtCreate"].isNull())
+			gatewaysObject.gmtCreate = dataNodeResultGateways["GmtCreate"].asString();
+		if(!dataNodeResultGateways["GmtModified"].isNull())
+			gatewaysObject.gmtModified = dataNodeResultGateways["GmtModified"].asString();
+		if(!dataNodeResultGateways["StatusDesc"].isNull())
+			gatewaysObject.statusDesc = dataNodeResultGateways["StatusDesc"].asString();
+		if(!dataNodeResultGateways["Upgrade"].isNull())
+			gatewaysObject.upgrade = dataNodeResultGateways["Upgrade"].asString() == "true";
+		if(!dataNodeResultGateways["MustUpgrade"].isNull())
+			gatewaysObject.mustUpgrade = dataNodeResultGateways["MustUpgrade"].asString() == "true";
+		if(!dataNodeResultGateways["CurrentVersion"].isNull())
+			gatewaysObject.currentVersion = dataNodeResultGateways["CurrentVersion"].asString();
+		if(!dataNodeResultGateways["LatestVersion"].isNull())
+			gatewaysObject.latestVersion = dataNodeResultGateways["LatestVersion"].asString();
+		if(!dataNodeResultGateways["Vswitch2"].isNull())
+			gatewaysObject.vswitch2 = dataNodeResultGateways["Vswitch2"].asString();
+		if(!dataNodeResultGateways["InstanceId"].isNull())
+			gatewaysObject.instanceId = dataNodeResultGateways["InstanceId"].asString();
+		if(!dataNodeResultGateways["ChargeType"].isNull())
+			gatewaysObject.chargeType = dataNodeResultGateways["ChargeType"].asString();
+		if(!dataNodeResultGateways["EndDate"].isNull())
+			gatewaysObject.endDate = dataNodeResultGateways["EndDate"].asString();
+		if(!dataNodeResultGateways["Tag"].isNull())
+			gatewaysObject.tag = dataNodeResultGateways["Tag"].asString();
+		auto allSlbNode = dataNodeResultGateways["Slb"]["slbItem"];
+		for (auto dataNodeResultGatewaysSlbslbItem : allSlbNode)
+		{
+			Data::Gateways::SlbItem slbObject;
+			if(!dataNodeResultGatewaysSlbslbItem["SlbIp"].isNull())
+				slbObject.slbIp = dataNodeResultGatewaysSlbslbItem["SlbIp"].asString();
+			if(!dataNodeResultGatewaysSlbslbItem["SlbPort"].isNull())
+				slbObject.slbPort = dataNodeResultGatewaysSlbslbItem["SlbPort"].asString();
+			if(!dataNodeResultGatewaysSlbslbItem["SlbSpec"].isNull())
+				slbObject.slbSpec = dataNodeResultGatewaysSlbslbItem["SlbSpec"].asString();
+			if(!dataNodeResultGatewaysSlbslbItem["Type"].isNull())
+				slbObject.type = dataNodeResultGatewaysSlbslbItem["Type"].asString();
+			if(!dataNodeResultGatewaysSlbslbItem["GatewaySlbStatus"].isNull())
+				slbObject.gatewaySlbStatus = dataNodeResultGatewaysSlbslbItem["GatewaySlbStatus"].asString();
+			if(!dataNodeResultGatewaysSlbslbItem["StatusDesc"].isNull())
+				slbObject.statusDesc = dataNodeResultGatewaysSlbslbItem["StatusDesc"].asString();
+			if(!dataNodeResultGatewaysSlbslbItem["GatewaySlbMode"].isNull())
+				slbObject.gatewaySlbMode = dataNodeResultGatewaysSlbslbItem["GatewaySlbMode"].asString();
+			if(!dataNodeResultGatewaysSlbslbItem["SlbId"].isNull())
+				slbObject.slbId = dataNodeResultGatewaysSlbslbItem["SlbId"].asString();
+			gatewaysObject.slb.push_back(slbObject);
+		}
+		auto allInternetSlbNode = dataNodeResultGateways["InternetSlb"]["internetSlbItem"];
+		for (auto dataNodeResultGatewaysInternetSlbinternetSlbItem : allInternetSlbNode)
+		{
+			Data::Gateways::InternetSlbItem internetSlbObject;
+			if(!dataNodeResultGatewaysInternetSlbinternetSlbItem["SlbIp"].isNull())
+				internetSlbObject.slbIp = dataNodeResultGatewaysInternetSlbinternetSlbItem["SlbIp"].asString();
+			if(!dataNodeResultGatewaysInternetSlbinternetSlbItem["SlbPort"].isNull())
+				internetSlbObject.slbPort = dataNodeResultGatewaysInternetSlbinternetSlbItem["SlbPort"].asString();
+			if(!dataNodeResultGatewaysInternetSlbinternetSlbItem["SlbSpec"].isNull())
+				internetSlbObject.slbSpec = dataNodeResultGatewaysInternetSlbinternetSlbItem["SlbSpec"].asString();
+			if(!dataNodeResultGatewaysInternetSlbinternetSlbItem["Type"].isNull())
+				internetSlbObject.type = dataNodeResultGatewaysInternetSlbinternetSlbItem["Type"].asString();
+			if(!dataNodeResultGatewaysInternetSlbinternetSlbItem["InternetNetworkFlow"].isNull())
+				internetSlbObject.internetNetworkFlow = dataNodeResultGatewaysInternetSlbinternetSlbItem["InternetNetworkFlow"].asString();
+			if(!dataNodeResultGatewaysInternetSlbinternetSlbItem["GatewaySlbStatus"].isNull())
+				internetSlbObject.gatewaySlbStatus = dataNodeResultGatewaysInternetSlbinternetSlbItem["GatewaySlbStatus"].asString();
+			if(!dataNodeResultGatewaysInternetSlbinternetSlbItem["StatusDesc"].isNull())
+				internetSlbObject.statusDesc = dataNodeResultGatewaysInternetSlbinternetSlbItem["StatusDesc"].asString();
+			if(!dataNodeResultGatewaysInternetSlbinternetSlbItem["GatewaySlbMode"].isNull())
+				internetSlbObject.gatewaySlbMode = dataNodeResultGatewaysInternetSlbinternetSlbItem["GatewaySlbMode"].asString();
+			if(!dataNodeResultGatewaysInternetSlbinternetSlbItem["SlbId"].isNull())
+				internetSlbObject.slbId = dataNodeResultGatewaysInternetSlbinternetSlbItem["SlbId"].asString();
+			gatewaysObject.internetSlb.push_back(internetSlbObject);
+		}
+		data_.result.push_back(gatewaysObject);
+	}
+	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 AddTestResult::getMessage()const
+{
+	return message_;
+}
+
+int AddTestResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+AddTestResult::Data AddTestResult::getData()const
+{
+	return data_;
+}
+
+int AddTestResult::getCode()const
+{
+	return code_;
+}
+
+bool AddTestResult::getSuccess()const
+{
+	return success_;
+}
+

mse/src/model/ApplyGatewayRouteRequest.cc

@@ -20,7 +20,7 @@ using AlibabaCloud::Mse::Model::ApplyGatewayRouteRequest;
 
 ApplyGatewayRouteRequest::ApplyGatewayRouteRequest()
     : RpcServiceRequest("mse", "2019-05-31", "ApplyGatewayRoute") {
-  setMethod(HttpRequest::Method::Get);
+  setMethod(HttpRequest::Method::Post);
 }
 
 ApplyGatewayRouteRequest::~ApplyGatewayRouteRequest() {}

mse/src/model/CreateAlarmRuleRequest.cc

@@ -1,126 +0,0 @@
-/*
- * 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/CreateAlarmRuleRequest.h>
-
-using AlibabaCloud::Mse::Model::CreateAlarmRuleRequest;
-
-CreateAlarmRuleRequest::CreateAlarmRuleRequest()
-    : RpcServiceRequest("mse", "2019-05-31", "CreateAlarmRule") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-CreateAlarmRuleRequest::~CreateAlarmRuleRequest() {}
-
-int CreateAlarmRuleRequest::getNValue() const {
-  return nValue_;
-}
-
-void CreateAlarmRuleRequest::setNValue(int nValue) {
-  nValue_ = nValue;
-  setParameter(std::string("NValue"), std::to_string(nValue));
-}
-
-std::string CreateAlarmRuleRequest::getAlarmItem() const {
-  return alarmItem_;
-}
-
-void CreateAlarmRuleRequest::setAlarmItem(const std::string &alarmItem) {
-  alarmItem_ = alarmItem;
-  setParameter(std::string("AlarmItem"), alarmItem);
-}
-
-std::string CreateAlarmRuleRequest::getClusterId() const {
-  return clusterId_;
-}
-
-void CreateAlarmRuleRequest::setClusterId(const std::string &clusterId) {
-  clusterId_ = clusterId;
-  setParameter(std::string("ClusterId"), clusterId);
-}
-
-std::string CreateAlarmRuleRequest::get_Operator() const {
-  return _operator_;
-}
-
-void CreateAlarmRuleRequest::set_Operator(const std::string &_operator) {
-  _operator_ = _operator;
-  setParameter(std::string("Operator"), _operator);
-}
-
-std::string CreateAlarmRuleRequest::getAlarmAliasName() const {
-  return alarmAliasName_;
-}
-
-void CreateAlarmRuleRequest::setAlarmAliasName(const std::string &alarmAliasName) {
-  alarmAliasName_ = alarmAliasName;
-  setParameter(std::string("AlarmAliasName"), alarmAliasName);
-}
-
-std::string CreateAlarmRuleRequest::getInstanceId() const {
-  return instanceId_;
-}
-
-void CreateAlarmRuleRequest::setInstanceId(const std::string &instanceId) {
-  instanceId_ = instanceId;
-  setParameter(std::string("InstanceId"), instanceId);
-}
-
-std::string CreateAlarmRuleRequest::getContactGroupIds() const {
-  return contactGroupIds_;
-}
-
-void CreateAlarmRuleRequest::setContactGroupIds(const std::string &contactGroupIds) {
-  contactGroupIds_ = contactGroupIds;
-  setParameter(std::string("ContactGroupIds"), contactGroupIds);
-}
-
-std::string CreateAlarmRuleRequest::getAcceptLanguage() const {
-  return acceptLanguage_;
-}
-
-void CreateAlarmRuleRequest::setAcceptLanguage(const std::string &acceptLanguage) {
-  acceptLanguage_ = acceptLanguage;
-  setParameter(std::string("AcceptLanguage"), acceptLanguage);
-}
-
-std::string CreateAlarmRuleRequest::getAlertWay() const {
-  return alertWay_;
-}
-
-void CreateAlarmRuleRequest::setAlertWay(const std::string &alertWay) {
-  alertWay_ = alertWay;
-  setParameter(std::string("AlertWay"), alertWay);
-}
-
-std::string CreateAlarmRuleRequest::getAggregates() const {
-  return aggregates_;
-}
-
-void CreateAlarmRuleRequest::setAggregates(const std::string &aggregates) {
-  aggregates_ = aggregates;
-  setParameter(std::string("Aggregates"), aggregates);
-}
-
-float CreateAlarmRuleRequest::getValue() const {
-  return value_;
-}
-
-void CreateAlarmRuleRequest::setValue(float value) {
-  value_ = value;
-  setParameter(std::string("Value"), std::to_string(value));
-}
-

mse/src/model/CreateApplicationRequest.cc

@@ -61,6 +61,15 @@ void CreateApplicationRequest::setAppName(const std::string &appName) {
   setParameter(std::string("AppName"), appName);
 }
 
+std::string CreateApplicationRequest::getSwitchEnable() const {
+  return switchEnable_;
+}
+
+void CreateApplicationRequest::setSwitchEnable(const std::string &switchEnable) {
+  switchEnable_ = switchEnable;
+  setParameter(std::string("SwitchEnable"), switchEnable);
+}
+
 std::string CreateApplicationRequest::getAcceptLanguage() const {
   return acceptLanguage_;
 }
@@ -70,6 +79,15 @@ void CreateApplicationRequest::setAcceptLanguage(const std::string &acceptLangua
   setParameter(std::string("AcceptLanguage"), acceptLanguage);
 }
 
+std::string CreateApplicationRequest::getSentinelEnable() const {
+  return sentinelEnable_;
+}
+
+void CreateApplicationRequest::setSentinelEnable(const std::string &sentinelEnable) {
+  sentinelEnable_ = sentinelEnable;
+  setParameter(std::string("SentinelEnable"), sentinelEnable);
+}
+
 std::string CreateApplicationRequest::getRegion() const {
   return region_;
 }

mse/src/model/CreateEngineNamespaceRequest.cc

@@ -70,6 +70,15 @@ void CreateEngineNamespaceRequest::setAcceptLanguage(const std::string &acceptLa
   setParameter(std::string("AcceptLanguage"), acceptLanguage);
 }
 
+std::string CreateEngineNamespaceRequest::getId() const {
+  return id_;
+}
+
+void CreateEngineNamespaceRequest::setId(const std::string &id) {
+  id_ = id;
+  setParameter(std::string("Id"), id);
+}
+
 std::string CreateEngineNamespaceRequest::getDesc() const {
   return desc_;
 }

mse/src/model/CreateVGroupRequest.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/CreateVGroupRequest.h>
+
+using AlibabaCloud::Mse::Model::CreateVGroupRequest;
+
+CreateVGroupRequest::CreateVGroupRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "CreateVGroup") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateVGroupRequest::~CreateVGroupRequest() {}
+
+std::string CreateVGroupRequest::getPrimaryUser() const {
+  return primaryUser_;
+}
+
+void CreateVGroupRequest::setPrimaryUser(const std::string &primaryUser) {
+  primaryUser_ = primaryUser;
+  setParameter(std::string("PrimaryUser"), primaryUser);
+}
+
+std::string CreateVGroupRequest::getName() const {
+  return name_;
+}
+
+void CreateVGroupRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+std::string CreateVGroupRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void CreateVGroupRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+
+std::string CreateVGroupRequest::getSeataServerUniqueId() const {
+  return seataServerUniqueId_;
+}
+
+void CreateVGroupRequest::setSeataServerUniqueId(const std::string &seataServerUniqueId) {
+  seataServerUniqueId_ = seataServerUniqueId;
+  setParameter(std::string("SeataServerUniqueId"), seataServerUniqueId);
+}
+
+std::string CreateVGroupRequest::getRegion() const {
+  return region_;
+}
+
+void CreateVGroupRequest::setRegion(const std::string &region) {
+  region_ = region;
+  setParameter(std::string("Region"), region);
+}
+

mse/src/model/CreateAlarmRuleResult.cc → mse/src/model/CreateVGroupResult.cc

@@ -14,51 +14,65 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/mse/model/CreateAlarmRuleResult.h>
+#include <alibabacloud/mse/model/CreateVGroupResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Mse;
 using namespace AlibabaCloud::Mse::Model;
 
-CreateAlarmRuleResult::CreateAlarmRuleResult() :
+CreateVGroupResult::CreateVGroupResult() :
 	ServiceResult()
 {}
 
-CreateAlarmRuleResult::CreateAlarmRuleResult(const std::string &payload) :
+CreateVGroupResult::CreateVGroupResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-CreateAlarmRuleResult::~CreateAlarmRuleResult()
+CreateVGroupResult::~CreateVGroupResult()
 {}
 
-void CreateAlarmRuleResult::parse(const std::string &payload)
+void CreateVGroupResult::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["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].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();
 
 }
 
-std::string CreateAlarmRuleResult::getMessage()const
+std::string CreateVGroupResult::getMessage()const
 {
 	return message_;
 }
 
-std::string CreateAlarmRuleResult::getErrorCode()const
+int CreateVGroupResult::getHttpStatusCode()const
 {
-	return errorCode_;
+	return httpStatusCode_;
 }
 
-bool CreateAlarmRuleResult::getSuccess()const
+std::string CreateVGroupResult::getData()const
+{
+	return data_;
+}
+
+int CreateVGroupResult::getCode()const
+{
+	return code_;
+}
+
+bool CreateVGroupResult::getSuccess()const
 {
 	return success_;
 }

mse/src/model/DeleteAlarmRuleRequest.cc

@@ -1,54 +0,0 @@
-/*
- * 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/DeleteAlarmRuleRequest.h>
-
-using AlibabaCloud::Mse::Model::DeleteAlarmRuleRequest;
-
-DeleteAlarmRuleRequest::DeleteAlarmRuleRequest()
-    : RpcServiceRequest("mse", "2019-05-31", "DeleteAlarmRule") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-DeleteAlarmRuleRequest::~DeleteAlarmRuleRequest() {}
-
-std::string DeleteAlarmRuleRequest::getAlarmRuleId() const {
-  return alarmRuleId_;
-}
-
-void DeleteAlarmRuleRequest::setAlarmRuleId(const std::string &alarmRuleId) {
-  alarmRuleId_ = alarmRuleId;
-  setParameter(std::string("AlarmRuleId"), alarmRuleId);
-}
-
-std::string DeleteAlarmRuleRequest::getRequestPars() const {
-  return requestPars_;
-}
-
-void DeleteAlarmRuleRequest::setRequestPars(const std::string &requestPars) {
-  requestPars_ = requestPars;
-  setParameter(std::string("RequestPars"), requestPars);
-}
-
-std::string DeleteAlarmRuleRequest::getAcceptLanguage() const {
-  return acceptLanguage_;
-}
-
-void DeleteAlarmRuleRequest::setAcceptLanguage(const std::string &acceptLanguage) {
-  acceptLanguage_ = acceptLanguage;
-  setParameter(std::string("AcceptLanguage"), acceptLanguage);
-}
-

mse/src/model/DeleteAuthResourceRequest.cc

@@ -20,7 +20,7 @@ using AlibabaCloud::Mse::Model::DeleteAuthResourceRequest;
 
 DeleteAuthResourceRequest::DeleteAuthResourceRequest()
     : RpcServiceRequest("mse", "2019-05-31", "DeleteAuthResource") {
-  setMethod(HttpRequest::Method::Get);
+  setMethod(HttpRequest::Method::Post);
 }
 
 DeleteAuthResourceRequest::~DeleteAuthResourceRequest() {}

mse/src/model/DeleteGatewayDomainRequest.cc

@@ -20,7 +20,7 @@ using AlibabaCloud::Mse::Model::DeleteGatewayDomainRequest;
 
 DeleteGatewayDomainRequest::DeleteGatewayDomainRequest()
     : RpcServiceRequest("mse", "2019-05-31", "DeleteGatewayDomain") {
-  setMethod(HttpRequest::Method::Get);
+  setMethod(HttpRequest::Method::Post);
 }
 
 DeleteGatewayDomainRequest::~DeleteGatewayDomainRequest() {}

mse/src/model/DeleteGatewayDomainResult.cc

@@ -53,7 +53,7 @@ void DeleteGatewayDomainResult::parse(const std::string &payload)
 	if(!dataNode["MustHttps"].isNull())
 		data_.mustHttps = dataNode["MustHttps"].asString() == "true";
 	if(!dataNode["CertIdentifier"].isNull())
-		data_.certIdentifier = std::stoi(dataNode["CertIdentifier"].asString());
+		data_.certIdentifier = dataNode["CertIdentifier"].asString();
 	if(!dataNode["GmtCreate"].isNull())
 		data_.gmtCreate = dataNode["GmtCreate"].asString();
 	if(!dataNode["GmtModified"].isNull())

mse/src/model/DeleteGatewayRequest.cc

@@ -20,7 +20,7 @@ using AlibabaCloud::Mse::Model::DeleteGatewayRequest;
 
 DeleteGatewayRequest::DeleteGatewayRequest()
     : RpcServiceRequest("mse", "2019-05-31", "DeleteGateway") {
-  setMethod(HttpRequest::Method::Get);
+  setMethod(HttpRequest::Method::Post);
 }
 
 DeleteGatewayRequest::~DeleteGatewayRequest() {}

mse/src/model/DeleteGatewayRouteRequest.cc

@@ -20,7 +20,7 @@ using AlibabaCloud::Mse::Model::DeleteGatewayRouteRequest;
 
 DeleteGatewayRouteRequest::DeleteGatewayRouteRequest()
     : RpcServiceRequest("mse", "2019-05-31", "DeleteGatewayRoute") {
-  setMethod(HttpRequest::Method::Get);
+  setMethod(HttpRequest::Method::Post);
 }
 
 DeleteGatewayRouteRequest::~DeleteGatewayRouteRequest() {}

mse/src/model/DeleteGatewayServiceRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/mse/model/DeleteGatewayServiceRequest.h>
+
+using AlibabaCloud::Mse::Model::DeleteGatewayServiceRequest;
+
+DeleteGatewayServiceRequest::DeleteGatewayServiceRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "DeleteGatewayService") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteGatewayServiceRequest::~DeleteGatewayServiceRequest() {}
+
+std::string DeleteGatewayServiceRequest::getGatewayUniqueId() const {
+  return gatewayUniqueId_;
+}
+
+void DeleteGatewayServiceRequest::setGatewayUniqueId(const std::string &gatewayUniqueId) {
+  gatewayUniqueId_ = gatewayUniqueId;
+  setParameter(std::string("GatewayUniqueId"), gatewayUniqueId);
+}
+
+std::string DeleteGatewayServiceRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void DeleteGatewayServiceRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+
+std::string DeleteGatewayServiceRequest::getServiceId() const {
+  return serviceId_;
+}
+
+void DeleteGatewayServiceRequest::setServiceId(const std::string &serviceId) {
+  serviceId_ = serviceId;
+  setParameter(std::string("ServiceId"), serviceId);
+}
+
+long DeleteGatewayServiceRequest::getGatewayId() const {
+  return gatewayId_;
+}
+
+void DeleteGatewayServiceRequest::setGatewayId(long gatewayId) {
+  gatewayId_ = gatewayId;
+  setParameter(std::string("GatewayId"), std::to_string(gatewayId));
+}
+

mse/src/model/DeleteGatewayServiceResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/mse/model/DeleteGatewayServiceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+DeleteGatewayServiceResult::DeleteGatewayServiceResult() :
+	ServiceResult()
+{}
+
+DeleteGatewayServiceResult::DeleteGatewayServiceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteGatewayServiceResult::~DeleteGatewayServiceResult()
+{}
+
+void DeleteGatewayServiceResult::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["SourceType"].isNull())
+		data_.sourceType = dataNode["SourceType"].asString();
+	if(!dataNode["Namespace"].isNull())
+		data_._namespace = dataNode["Namespace"].asString();
+	if(!dataNode["GroupName"].isNull())
+		data_.groupName = dataNode["GroupName"].asString();
+	if(!dataNode["SourceId"].isNull())
+		data_.sourceId = std::stol(dataNode["SourceId"].asString());
+	if(!dataNode["ServiceNameInRegistry"].isNull())
+		data_.serviceNameInRegistry = dataNode["ServiceNameInRegistry"].asString();
+	if(!dataNode["MetaInfo"].isNull())
+		data_.metaInfo = dataNode["MetaInfo"].asString();
+	if(!dataNode["GmtCreate"].isNull())
+		data_.gmtCreate = dataNode["GmtCreate"].asString();
+	if(!dataNode["GmtModified"].isNull())
+		data_.gmtModified = dataNode["GmtModified"].asString();
+		auto allIps = dataNode["Ips"]["Ips"];
+		for (auto value : allIps)
+			data_.ips.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 DeleteGatewayServiceResult::getMessage()const
+{
+	return message_;
+}
+
+int DeleteGatewayServiceResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+DeleteGatewayServiceResult::Data DeleteGatewayServiceResult::getData()const
+{
+	return data_;
+}
+
+int DeleteGatewayServiceResult::getCode()const
+{
+	return code_;
+}
+
+bool DeleteGatewayServiceResult::getSuccess()const
+{
+	return success_;
+}
+

mse/src/model/DeleteGatewaySlbRequest.cc

@@ -20,7 +20,7 @@ using AlibabaCloud::Mse::Model::DeleteGatewaySlbRequest;
 
 DeleteGatewaySlbRequest::DeleteGatewaySlbRequest()
     : RpcServiceRequest("mse", "2019-05-31", "DeleteGatewaySlb") {
-  setMethod(HttpRequest::Method::Get);
+  setMethod(HttpRequest::Method::Post);
 }
 
 DeleteGatewaySlbRequest::~DeleteGatewaySlbRequest() {}

mse/src/model/DeleteSeataServerRequest.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/DeleteSeataServerRequest.h>
+
+using AlibabaCloud::Mse::Model::DeleteSeataServerRequest;
+
+DeleteSeataServerRequest::DeleteSeataServerRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "DeleteSeataServer") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteSeataServerRequest::~DeleteSeataServerRequest() {}
+
+std::string DeleteSeataServerRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void DeleteSeataServerRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+
+std::string DeleteSeataServerRequest::getSeataServerUniqueId() const {
+  return seataServerUniqueId_;
+}
+
+void DeleteSeataServerRequest::setSeataServerUniqueId(const std::string &seataServerUniqueId) {
+  seataServerUniqueId_ = seataServerUniqueId;
+  setParameter(std::string("SeataServerUniqueId"), seataServerUniqueId);
+}
+

mse/src/model/DeleteSeataServerResult.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/DeleteSeataServerResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+DeleteSeataServerResult::DeleteSeataServerResult() :
+	ServiceResult()
+{}
+
+DeleteSeataServerResult::DeleteSeataServerResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteSeataServerResult::~DeleteSeataServerResult()
+{}
+
+void DeleteSeataServerResult::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();
+
+}
+
+std::string DeleteSeataServerResult::getMessage()const
+{
+	return message_;
+}
+
+int DeleteSeataServerResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string DeleteSeataServerResult::getData()const
+{
+	return data_;
+}
+
+int DeleteSeataServerResult::getCode()const
+{
+	return code_;
+}
+
+bool DeleteSeataServerResult::getSuccess()const
+{
+	return success_;
+}
+

mse/src/model/DeleteSecurityGroupRuleRequest.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/DeleteSecurityGroupRuleRequest.h>
+
+using AlibabaCloud::Mse::Model::DeleteSecurityGroupRuleRequest;
+
+DeleteSecurityGroupRuleRequest::DeleteSecurityGroupRuleRequest()
+    : RpcServiceRequest("mse", "2019-05-31", "DeleteSecurityGroupRule") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteSecurityGroupRuleRequest::~DeleteSecurityGroupRuleRequest() {}
+
+std::string DeleteSecurityGroupRuleRequest::getGatewayUniqueId() const {
+  return gatewayUniqueId_;
+}
+
+void DeleteSecurityGroupRuleRequest::setGatewayUniqueId(const std::string &gatewayUniqueId) {
+  gatewayUniqueId_ = gatewayUniqueId;
+  setParameter(std::string("GatewayUniqueId"), gatewayUniqueId);
+}
+
+std::string DeleteSecurityGroupRuleRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void DeleteSecurityGroupRuleRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+
+long DeleteSecurityGroupRuleRequest::getId() const {
+  return id_;
+}
+
+void DeleteSecurityGroupRuleRequest::setId(long id) {
+  id_ = id;
+  setParameter(std::string("Id"), std::to_string(id));
+}
+

mse/src/model/DeleteSecurityGroupRuleResult.cc

@@ -0,0 +1,96 @@
+/*
+ * 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/DeleteSecurityGroupRuleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mse;
+using namespace AlibabaCloud::Mse::Model;
+
+DeleteSecurityGroupRuleResult::DeleteSecurityGroupRuleResult() :
+	ServiceResult()
+{}
+
+DeleteSecurityGroupRuleResult::DeleteSecurityGroupRuleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteSecurityGroupRuleResult::~DeleteSecurityGroupRuleResult()
+{}
+
+void DeleteSecurityGroupRuleResult::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["SecurityGroupId"].isNull())
+		data_.securityGroupId = dataNode["SecurityGroupId"].asString();
+	if(!dataNode["GatewayUniqueId"].isNull())
+		data_.gatewayUniqueId = dataNode["GatewayUniqueId"].asString();
+	if(!dataNode["PortRange"].isNull())
+		data_.portRange = dataNode["PortRange"].asString();
+	if(!dataNode["IpProtocol"].isNull())
+		data_.ipProtocol = dataNode["IpProtocol"].asString();
+	if(!dataNode["GatewayId"].isNull())
+		data_.gatewayId = std::stol(dataNode["GatewayId"].asString());
+	if(!dataNode["GmtCreate"].isNull())
+		data_.gmtCreate = dataNode["GmtCreate"].asString();
+	if(!dataNode["GmtModified"].isNull())
+		data_.gmtModified = dataNode["GmtModified"].asString();
+	if(!dataNode["Description"].isNull())
+		data_.description = dataNode["Description"].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 DeleteSecurityGroupRuleResult::getMessage()const
+{
+	return message_;
+}
+
+int DeleteSecurityGroupRuleResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+DeleteSecurityGroupRuleResult::Data DeleteSecurityGroupRuleResult::getData()const
+{
+	return data_;
+}
+
+int DeleteSecurityGroupRuleResult::getCode()const
+{
+	return code_;
+}
+
+bool DeleteSecurityGroupRuleResult::getSuccess()const
+{
+	return success_;
+}
+