Edit GetTrace api.

CHANGELOG

@@ -1,3 +1,7 @@
+2021-03-18 Version: 1.36.642
+- Edit GetTrace api.
+- Edit GetMultipleTrace api.
+
 2021-03-18 Version: 1.36.641
 - Generated 2020-05-18 for `dataworks-public`.
 

VERSION

@@ -1 +1 @@
-1.36.641
+1.36.642

arms/CMakeLists.txt

@@ -31,12 +31,16 @@ set(arms_public_header_model
 	include/alibabacloud/arms/model/CheckDataConsistencyResult.h
 	include/alibabacloud/arms/model/CheckServiceLinkedRoleForDeletingRequest.h
 	include/alibabacloud/arms/model/CheckServiceLinkedRoleForDeletingResult.h
+	include/alibabacloud/arms/model/CheckServiceStatusRequest.h
+	include/alibabacloud/arms/model/CheckServiceStatusResult.h
 	include/alibabacloud/arms/model/ConfigAppRequest.h
 	include/alibabacloud/arms/model/ConfigAppResult.h
 	include/alibabacloud/arms/model/CreateAlertContactRequest.h
 	include/alibabacloud/arms/model/CreateAlertContactResult.h
 	include/alibabacloud/arms/model/CreateAlertContactGroupRequest.h
 	include/alibabacloud/arms/model/CreateAlertContactGroupResult.h
+	include/alibabacloud/arms/model/CreateDispatchRuleRequest.h
+	include/alibabacloud/arms/model/CreateDispatchRuleResult.h
 	include/alibabacloud/arms/model/CreateRetcodeAppRequest.h
 	include/alibabacloud/arms/model/CreateRetcodeAppResult.h
 	include/alibabacloud/arms/model/CreateWehookRequest.h
@@ -47,6 +51,8 @@ set(arms_public_header_model
 	include/alibabacloud/arms/model/DeleteAlertContactGroupResult.h
 	include/alibabacloud/arms/model/DeleteAlertRulesRequest.h
 	include/alibabacloud/arms/model/DeleteAlertRulesResult.h
+	include/alibabacloud/arms/model/DeleteDispatchRuleRequest.h
+	include/alibabacloud/arms/model/DeleteDispatchRuleResult.h
 	include/alibabacloud/arms/model/DeleteRetcodeAppRequest.h
 	include/alibabacloud/arms/model/DeleteRetcodeAppResult.h
 	include/alibabacloud/arms/model/DeleteScenarioRequest.h
@@ -91,16 +97,22 @@ set(arms_public_header_model
 	include/alibabacloud/arms/model/ListClusterFromGrafanaResult.h
 	include/alibabacloud/arms/model/ListDashboardsRequest.h
 	include/alibabacloud/arms/model/ListDashboardsResult.h
+	include/alibabacloud/arms/model/ListDispatchRuleRequest.h
+	include/alibabacloud/arms/model/ListDispatchRuleResult.h
 	include/alibabacloud/arms/model/ListPromClustersRequest.h
 	include/alibabacloud/arms/model/ListPromClustersResult.h
 	include/alibabacloud/arms/model/ListRetcodeAppsRequest.h
 	include/alibabacloud/arms/model/ListRetcodeAppsResult.h
 	include/alibabacloud/arms/model/ListScenarioRequest.h
 	include/alibabacloud/arms/model/ListScenarioResult.h
+	include/alibabacloud/arms/model/ListServerlessTopNAppsRequest.h
+	include/alibabacloud/arms/model/ListServerlessTopNAppsResult.h
 	include/alibabacloud/arms/model/ListTraceAppsRequest.h
 	include/alibabacloud/arms/model/ListTraceAppsResult.h
 	include/alibabacloud/arms/model/OpenArmsServiceRequest.h
 	include/alibabacloud/arms/model/OpenArmsServiceResult.h
+	include/alibabacloud/arms/model/OpenVClusterRequest.h
+	include/alibabacloud/arms/model/OpenVClusterResult.h
 	include/alibabacloud/arms/model/QueryDatasetRequest.h
 	include/alibabacloud/arms/model/QueryDatasetResult.h
 	include/alibabacloud/arms/model/QueryMetricRequest.h
@@ -145,6 +157,8 @@ set(arms_public_header_model
 	include/alibabacloud/arms/model/UpdateAlertContactGroupResult.h
 	include/alibabacloud/arms/model/UpdateAlertRuleRequest.h
 	include/alibabacloud/arms/model/UpdateAlertRuleResult.h
+	include/alibabacloud/arms/model/UpdateDispatchRuleRequest.h
+	include/alibabacloud/arms/model/UpdateDispatchRuleResult.h
 	include/alibabacloud/arms/model/UpdateWebhookRequest.h
 	include/alibabacloud/arms/model/UpdateWebhookResult.h )
 
@@ -160,12 +174,16 @@ set(arms_src
 	src/model/CheckDataConsistencyResult.cc
 	src/model/CheckServiceLinkedRoleForDeletingRequest.cc
 	src/model/CheckServiceLinkedRoleForDeletingResult.cc
+	src/model/CheckServiceStatusRequest.cc
+	src/model/CheckServiceStatusResult.cc
 	src/model/ConfigAppRequest.cc
 	src/model/ConfigAppResult.cc
 	src/model/CreateAlertContactRequest.cc
 	src/model/CreateAlertContactResult.cc
 	src/model/CreateAlertContactGroupRequest.cc
 	src/model/CreateAlertContactGroupResult.cc
+	src/model/CreateDispatchRuleRequest.cc
+	src/model/CreateDispatchRuleResult.cc
 	src/model/CreateRetcodeAppRequest.cc
 	src/model/CreateRetcodeAppResult.cc
 	src/model/CreateWehookRequest.cc
@@ -176,6 +194,8 @@ set(arms_src
 	src/model/DeleteAlertContactGroupResult.cc
 	src/model/DeleteAlertRulesRequest.cc
 	src/model/DeleteAlertRulesResult.cc
+	src/model/DeleteDispatchRuleRequest.cc
+	src/model/DeleteDispatchRuleResult.cc
 	src/model/DeleteRetcodeAppRequest.cc
 	src/model/DeleteRetcodeAppResult.cc
 	src/model/DeleteScenarioRequest.cc
@@ -220,16 +240,22 @@ set(arms_src
 	src/model/ListClusterFromGrafanaResult.cc
 	src/model/ListDashboardsRequest.cc
 	src/model/ListDashboardsResult.cc
+	src/model/ListDispatchRuleRequest.cc
+	src/model/ListDispatchRuleResult.cc
 	src/model/ListPromClustersRequest.cc
 	src/model/ListPromClustersResult.cc
 	src/model/ListRetcodeAppsRequest.cc
 	src/model/ListRetcodeAppsResult.cc
 	src/model/ListScenarioRequest.cc
 	src/model/ListScenarioResult.cc
+	src/model/ListServerlessTopNAppsRequest.cc
+	src/model/ListServerlessTopNAppsResult.cc
 	src/model/ListTraceAppsRequest.cc
 	src/model/ListTraceAppsResult.cc
 	src/model/OpenArmsServiceRequest.cc
 	src/model/OpenArmsServiceResult.cc
+	src/model/OpenVClusterRequest.cc
+	src/model/OpenVClusterResult.cc
 	src/model/QueryDatasetRequest.cc
 	src/model/QueryDatasetResult.cc
 	src/model/QueryMetricRequest.cc
@@ -274,6 +300,8 @@ set(arms_src
 	src/model/UpdateAlertContactGroupResult.cc
 	src/model/UpdateAlertRuleRequest.cc
 	src/model/UpdateAlertRuleResult.cc
+	src/model/UpdateDispatchRuleRequest.cc
+	src/model/UpdateDispatchRuleResult.cc
 	src/model/UpdateWebhookRequest.cc
 	src/model/UpdateWebhookResult.cc )
 

arms/include/alibabacloud/arms/ARMSClient.h

@@ -32,12 +32,16 @@
 #include "model/CheckDataConsistencyResult.h"
 #include "model/CheckServiceLinkedRoleForDeletingRequest.h"
 #include "model/CheckServiceLinkedRoleForDeletingResult.h"
+#include "model/CheckServiceStatusRequest.h"
+#include "model/CheckServiceStatusResult.h"
 #include "model/ConfigAppRequest.h"
 #include "model/ConfigAppResult.h"
 #include "model/CreateAlertContactRequest.h"
 #include "model/CreateAlertContactResult.h"
 #include "model/CreateAlertContactGroupRequest.h"
 #include "model/CreateAlertContactGroupResult.h"
+#include "model/CreateDispatchRuleRequest.h"
+#include "model/CreateDispatchRuleResult.h"
 #include "model/CreateRetcodeAppRequest.h"
 #include "model/CreateRetcodeAppResult.h"
 #include "model/CreateWehookRequest.h"
@@ -48,6 +52,8 @@
 #include "model/DeleteAlertContactGroupResult.h"
 #include "model/DeleteAlertRulesRequest.h"
 #include "model/DeleteAlertRulesResult.h"
+#include "model/DeleteDispatchRuleRequest.h"
+#include "model/DeleteDispatchRuleResult.h"
 #include "model/DeleteRetcodeAppRequest.h"
 #include "model/DeleteRetcodeAppResult.h"
 #include "model/DeleteScenarioRequest.h"
@@ -92,16 +98,22 @@
 #include "model/ListClusterFromGrafanaResult.h"
 #include "model/ListDashboardsRequest.h"
 #include "model/ListDashboardsResult.h"
+#include "model/ListDispatchRuleRequest.h"
+#include "model/ListDispatchRuleResult.h"
 #include "model/ListPromClustersRequest.h"
 #include "model/ListPromClustersResult.h"
 #include "model/ListRetcodeAppsRequest.h"
 #include "model/ListRetcodeAppsResult.h"
 #include "model/ListScenarioRequest.h"
 #include "model/ListScenarioResult.h"
+#include "model/ListServerlessTopNAppsRequest.h"
+#include "model/ListServerlessTopNAppsResult.h"
 #include "model/ListTraceAppsRequest.h"
 #include "model/ListTraceAppsResult.h"
 #include "model/OpenArmsServiceRequest.h"
 #include "model/OpenArmsServiceResult.h"
+#include "model/OpenVClusterRequest.h"
+#include "model/OpenVClusterResult.h"
 #include "model/QueryDatasetRequest.h"
 #include "model/QueryDatasetResult.h"
 #include "model/QueryMetricRequest.h"
@@ -146,6 +158,8 @@
 #include "model/UpdateAlertContactGroupResult.h"
 #include "model/UpdateAlertRuleRequest.h"
 #include "model/UpdateAlertRuleResult.h"
+#include "model/UpdateDispatchRuleRequest.h"
+#include "model/UpdateDispatchRuleResult.h"
 #include "model/UpdateWebhookRequest.h"
 #include "model/UpdateWebhookResult.h"
 
@@ -172,6 +186,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CheckServiceLinkedRoleForDeletingResult> CheckServiceLinkedRoleForDeletingOutcome;
 			typedef std::future<CheckServiceLinkedRoleForDeletingOutcome> CheckServiceLinkedRoleForDeletingOutcomeCallable;
 			typedef std::function<void(const ARMSClient*, const Model::CheckServiceLinkedRoleForDeletingRequest&, const CheckServiceLinkedRoleForDeletingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckServiceLinkedRoleForDeletingAsyncHandler;
+			typedef Outcome<Error, Model::CheckServiceStatusResult> CheckServiceStatusOutcome;
+			typedef std::future<CheckServiceStatusOutcome> CheckServiceStatusOutcomeCallable;
+			typedef std::function<void(const ARMSClient*, const Model::CheckServiceStatusRequest&, const CheckServiceStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckServiceStatusAsyncHandler;
 			typedef Outcome<Error, Model::ConfigAppResult> ConfigAppOutcome;
 			typedef std::future<ConfigAppOutcome> ConfigAppOutcomeCallable;
 			typedef std::function<void(const ARMSClient*, const Model::ConfigAppRequest&, const ConfigAppOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ConfigAppAsyncHandler;
@@ -181,6 +198,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateAlertContactGroupResult> CreateAlertContactGroupOutcome;
 			typedef std::future<CreateAlertContactGroupOutcome> CreateAlertContactGroupOutcomeCallable;
 			typedef std::function<void(const ARMSClient*, const Model::CreateAlertContactGroupRequest&, const CreateAlertContactGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAlertContactGroupAsyncHandler;
+			typedef Outcome<Error, Model::CreateDispatchRuleResult> CreateDispatchRuleOutcome;
+			typedef std::future<CreateDispatchRuleOutcome> CreateDispatchRuleOutcomeCallable;
+			typedef std::function<void(const ARMSClient*, const Model::CreateDispatchRuleRequest&, const CreateDispatchRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDispatchRuleAsyncHandler;
 			typedef Outcome<Error, Model::CreateRetcodeAppResult> CreateRetcodeAppOutcome;
 			typedef std::future<CreateRetcodeAppOutcome> CreateRetcodeAppOutcomeCallable;
 			typedef std::function<void(const ARMSClient*, const Model::CreateRetcodeAppRequest&, const CreateRetcodeAppOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRetcodeAppAsyncHandler;
@@ -196,6 +216,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteAlertRulesResult> DeleteAlertRulesOutcome;
 			typedef std::future<DeleteAlertRulesOutcome> DeleteAlertRulesOutcomeCallable;
 			typedef std::function<void(const ARMSClient*, const Model::DeleteAlertRulesRequest&, const DeleteAlertRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAlertRulesAsyncHandler;
+			typedef Outcome<Error, Model::DeleteDispatchRuleResult> DeleteDispatchRuleOutcome;
+			typedef std::future<DeleteDispatchRuleOutcome> DeleteDispatchRuleOutcomeCallable;
+			typedef std::function<void(const ARMSClient*, const Model::DeleteDispatchRuleRequest&, const DeleteDispatchRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDispatchRuleAsyncHandler;
 			typedef Outcome<Error, Model::DeleteRetcodeAppResult> DeleteRetcodeAppOutcome;
 			typedef std::future<DeleteRetcodeAppOutcome> DeleteRetcodeAppOutcomeCallable;
 			typedef std::function<void(const ARMSClient*, const Model::DeleteRetcodeAppRequest&, const DeleteRetcodeAppOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteRetcodeAppAsyncHandler;
@@ -262,6 +285,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListDashboardsResult> ListDashboardsOutcome;
 			typedef std::future<ListDashboardsOutcome> ListDashboardsOutcomeCallable;
 			typedef std::function<void(const ARMSClient*, const Model::ListDashboardsRequest&, const ListDashboardsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDashboardsAsyncHandler;
+			typedef Outcome<Error, Model::ListDispatchRuleResult> ListDispatchRuleOutcome;
+			typedef std::future<ListDispatchRuleOutcome> ListDispatchRuleOutcomeCallable;
+			typedef std::function<void(const ARMSClient*, const Model::ListDispatchRuleRequest&, const ListDispatchRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDispatchRuleAsyncHandler;
 			typedef Outcome<Error, Model::ListPromClustersResult> ListPromClustersOutcome;
 			typedef std::future<ListPromClustersOutcome> ListPromClustersOutcomeCallable;
 			typedef std::function<void(const ARMSClient*, const Model::ListPromClustersRequest&, const ListPromClustersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListPromClustersAsyncHandler;
@@ -271,12 +297,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListScenarioResult> ListScenarioOutcome;
 			typedef std::future<ListScenarioOutcome> ListScenarioOutcomeCallable;
 			typedef std::function<void(const ARMSClient*, const Model::ListScenarioRequest&, const ListScenarioOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListScenarioAsyncHandler;
+			typedef Outcome<Error, Model::ListServerlessTopNAppsResult> ListServerlessTopNAppsOutcome;
+			typedef std::future<ListServerlessTopNAppsOutcome> ListServerlessTopNAppsOutcomeCallable;
+			typedef std::function<void(const ARMSClient*, const Model::ListServerlessTopNAppsRequest&, const ListServerlessTopNAppsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListServerlessTopNAppsAsyncHandler;
 			typedef Outcome<Error, Model::ListTraceAppsResult> ListTraceAppsOutcome;
 			typedef std::future<ListTraceAppsOutcome> ListTraceAppsOutcomeCallable;
 			typedef std::function<void(const ARMSClient*, const Model::ListTraceAppsRequest&, const ListTraceAppsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTraceAppsAsyncHandler;
 			typedef Outcome<Error, Model::OpenArmsServiceResult> OpenArmsServiceOutcome;
 			typedef std::future<OpenArmsServiceOutcome> OpenArmsServiceOutcomeCallable;
 			typedef std::function<void(const ARMSClient*, const Model::OpenArmsServiceRequest&, const OpenArmsServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> OpenArmsServiceAsyncHandler;
+			typedef Outcome<Error, Model::OpenVClusterResult> OpenVClusterOutcome;
+			typedef std::future<OpenVClusterOutcome> OpenVClusterOutcomeCallable;
+			typedef std::function<void(const ARMSClient*, const Model::OpenVClusterRequest&, const OpenVClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> OpenVClusterAsyncHandler;
 			typedef Outcome<Error, Model::QueryDatasetResult> QueryDatasetOutcome;
 			typedef std::future<QueryDatasetOutcome> QueryDatasetOutcomeCallable;
 			typedef std::function<void(const ARMSClient*, const Model::QueryDatasetRequest&, const QueryDatasetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryDatasetAsyncHandler;
@@ -343,6 +375,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateAlertRuleResult> UpdateAlertRuleOutcome;
 			typedef std::future<UpdateAlertRuleOutcome> UpdateAlertRuleOutcomeCallable;
 			typedef std::function<void(const ARMSClient*, const Model::UpdateAlertRuleRequest&, const UpdateAlertRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAlertRuleAsyncHandler;
+			typedef Outcome<Error, Model::UpdateDispatchRuleResult> UpdateDispatchRuleOutcome;
+			typedef std::future<UpdateDispatchRuleOutcome> UpdateDispatchRuleOutcomeCallable;
+			typedef std::function<void(const ARMSClient*, const Model::UpdateDispatchRuleRequest&, const UpdateDispatchRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateDispatchRuleAsyncHandler;
 			typedef Outcome<Error, Model::UpdateWebhookResult> UpdateWebhookOutcome;
 			typedef std::future<UpdateWebhookOutcome> UpdateWebhookOutcomeCallable;
 			typedef std::function<void(const ARMSClient*, const Model::UpdateWebhookRequest&, const UpdateWebhookOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateWebhookAsyncHandler;
@@ -366,6 +401,9 @@ namespace AlibabaCloud
 			CheckServiceLinkedRoleForDeletingOutcome checkServiceLinkedRoleForDeleting(const Model::CheckServiceLinkedRoleForDeletingRequest &request)const;
 			void checkServiceLinkedRoleForDeletingAsync(const Model::CheckServiceLinkedRoleForDeletingRequest& request, const CheckServiceLinkedRoleForDeletingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CheckServiceLinkedRoleForDeletingOutcomeCallable checkServiceLinkedRoleForDeletingCallable(const Model::CheckServiceLinkedRoleForDeletingRequest& request) const;
+			CheckServiceStatusOutcome checkServiceStatus(const Model::CheckServiceStatusRequest &request)const;
+			void checkServiceStatusAsync(const Model::CheckServiceStatusRequest& request, const CheckServiceStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CheckServiceStatusOutcomeCallable checkServiceStatusCallable(const Model::CheckServiceStatusRequest& request) const;
 			ConfigAppOutcome configApp(const Model::ConfigAppRequest &request)const;
 			void configAppAsync(const Model::ConfigAppRequest& request, const ConfigAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ConfigAppOutcomeCallable configAppCallable(const Model::ConfigAppRequest& request) const;
@@ -375,6 +413,9 @@ namespace AlibabaCloud
 			CreateAlertContactGroupOutcome createAlertContactGroup(const Model::CreateAlertContactGroupRequest &request)const;
 			void createAlertContactGroupAsync(const Model::CreateAlertContactGroupRequest& request, const CreateAlertContactGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateAlertContactGroupOutcomeCallable createAlertContactGroupCallable(const Model::CreateAlertContactGroupRequest& request) const;
+			CreateDispatchRuleOutcome createDispatchRule(const Model::CreateDispatchRuleRequest &request)const;
+			void createDispatchRuleAsync(const Model::CreateDispatchRuleRequest& request, const CreateDispatchRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateDispatchRuleOutcomeCallable createDispatchRuleCallable(const Model::CreateDispatchRuleRequest& request) const;
 			CreateRetcodeAppOutcome createRetcodeApp(const Model::CreateRetcodeAppRequest &request)const;
 			void createRetcodeAppAsync(const Model::CreateRetcodeAppRequest& request, const CreateRetcodeAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateRetcodeAppOutcomeCallable createRetcodeAppCallable(const Model::CreateRetcodeAppRequest& request) const;
@@ -390,6 +431,9 @@ namespace AlibabaCloud
 			DeleteAlertRulesOutcome deleteAlertRules(const Model::DeleteAlertRulesRequest &request)const;
 			void deleteAlertRulesAsync(const Model::DeleteAlertRulesRequest& request, const DeleteAlertRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteAlertRulesOutcomeCallable deleteAlertRulesCallable(const Model::DeleteAlertRulesRequest& request) const;
+			DeleteDispatchRuleOutcome deleteDispatchRule(const Model::DeleteDispatchRuleRequest &request)const;
+			void deleteDispatchRuleAsync(const Model::DeleteDispatchRuleRequest& request, const DeleteDispatchRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteDispatchRuleOutcomeCallable deleteDispatchRuleCallable(const Model::DeleteDispatchRuleRequest& request) const;
 			DeleteRetcodeAppOutcome deleteRetcodeApp(const Model::DeleteRetcodeAppRequest &request)const;
 			void deleteRetcodeAppAsync(const Model::DeleteRetcodeAppRequest& request, const DeleteRetcodeAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteRetcodeAppOutcomeCallable deleteRetcodeAppCallable(const Model::DeleteRetcodeAppRequest& request) const;
@@ -456,6 +500,9 @@ namespace AlibabaCloud
 			ListDashboardsOutcome listDashboards(const Model::ListDashboardsRequest &request)const;
 			void listDashboardsAsync(const Model::ListDashboardsRequest& request, const ListDashboardsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListDashboardsOutcomeCallable listDashboardsCallable(const Model::ListDashboardsRequest& request) const;
+			ListDispatchRuleOutcome listDispatchRule(const Model::ListDispatchRuleRequest &request)const;
+			void listDispatchRuleAsync(const Model::ListDispatchRuleRequest& request, const ListDispatchRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListDispatchRuleOutcomeCallable listDispatchRuleCallable(const Model::ListDispatchRuleRequest& request) const;
 			ListPromClustersOutcome listPromClusters(const Model::ListPromClustersRequest &request)const;
 			void listPromClustersAsync(const Model::ListPromClustersRequest& request, const ListPromClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListPromClustersOutcomeCallable listPromClustersCallable(const Model::ListPromClustersRequest& request) const;
@@ -465,12 +512,18 @@ namespace AlibabaCloud
 			ListScenarioOutcome listScenario(const Model::ListScenarioRequest &request)const;
 			void listScenarioAsync(const Model::ListScenarioRequest& request, const ListScenarioAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListScenarioOutcomeCallable listScenarioCallable(const Model::ListScenarioRequest& request) const;
+			ListServerlessTopNAppsOutcome listServerlessTopNApps(const Model::ListServerlessTopNAppsRequest &request)const;
+			void listServerlessTopNAppsAsync(const Model::ListServerlessTopNAppsRequest& request, const ListServerlessTopNAppsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListServerlessTopNAppsOutcomeCallable listServerlessTopNAppsCallable(const Model::ListServerlessTopNAppsRequest& request) const;
 			ListTraceAppsOutcome listTraceApps(const Model::ListTraceAppsRequest &request)const;
 			void listTraceAppsAsync(const Model::ListTraceAppsRequest& request, const ListTraceAppsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListTraceAppsOutcomeCallable listTraceAppsCallable(const Model::ListTraceAppsRequest& request) const;
 			OpenArmsServiceOutcome openArmsService(const Model::OpenArmsServiceRequest &request)const;
 			void openArmsServiceAsync(const Model::OpenArmsServiceRequest& request, const OpenArmsServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			OpenArmsServiceOutcomeCallable openArmsServiceCallable(const Model::OpenArmsServiceRequest& request) const;
+			OpenVClusterOutcome openVCluster(const Model::OpenVClusterRequest &request)const;
+			void openVClusterAsync(const Model::OpenVClusterRequest& request, const OpenVClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			OpenVClusterOutcomeCallable openVClusterCallable(const Model::OpenVClusterRequest& request) const;
 			QueryDatasetOutcome queryDataset(const Model::QueryDatasetRequest &request)const;
 			void queryDatasetAsync(const Model::QueryDatasetRequest& request, const QueryDatasetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryDatasetOutcomeCallable queryDatasetCallable(const Model::QueryDatasetRequest& request) const;
@@ -537,6 +590,9 @@ namespace AlibabaCloud
 			UpdateAlertRuleOutcome updateAlertRule(const Model::UpdateAlertRuleRequest &request)const;
 			void updateAlertRuleAsync(const Model::UpdateAlertRuleRequest& request, const UpdateAlertRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateAlertRuleOutcomeCallable updateAlertRuleCallable(const Model::UpdateAlertRuleRequest& request) const;
+			UpdateDispatchRuleOutcome updateDispatchRule(const Model::UpdateDispatchRuleRequest &request)const;
+			void updateDispatchRuleAsync(const Model::UpdateDispatchRuleRequest& request, const UpdateDispatchRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateDispatchRuleOutcomeCallable updateDispatchRuleCallable(const Model::UpdateDispatchRuleRequest& request) const;
 			UpdateWebhookOutcome updateWebhook(const Model::UpdateWebhookRequest &request)const;
 			void updateWebhookAsync(const Model::UpdateWebhookRequest& request, const UpdateWebhookAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateWebhookOutcomeCallable updateWebhookCallable(const Model::UpdateWebhookRequest& request) const;

arms/include/alibabacloud/arms/model/CheckServiceStatusRequest.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_ARMS_MODEL_CHECKSERVICESTATUSREQUEST_H_
+#define ALIBABACLOUD_ARMS_MODEL_CHECKSERVICESTATUSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/arms/ARMSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ARMS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ARMS_EXPORT CheckServiceStatusRequest : public RpcServiceRequest
+			{
+
+			public:
+				CheckServiceStatusRequest();
+				~CheckServiceStatusRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getSvcCode()const;
+				void setSvcCode(const std::string& svcCode);
+
+            private:
+				std::string regionId_;
+				std::string svcCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ARMS_MODEL_CHECKSERVICESTATUSREQUEST_H_

arms/include/alibabacloud/arms/model/CheckServiceStatusResult.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_ARMS_MODEL_CHECKSERVICESTATUSRESULT_H_
+#define ALIBABACLOUD_ARMS_MODEL_CHECKSERVICESTATUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/arms/ARMSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ARMS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ARMS_EXPORT CheckServiceStatusResult : public ServiceResult
+			{
+			public:
+
+
+				CheckServiceStatusResult();
+				explicit CheckServiceStatusResult(const std::string &payload);
+				~CheckServiceStatusResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ARMS_MODEL_CHECKSERVICESTATUSRESULT_H_

arms/include/alibabacloud/arms/model/CreateDispatchRuleRequest.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_ARMS_MODEL_CREATEDISPATCHRULEREQUEST_H_
+#define ALIBABACLOUD_ARMS_MODEL_CREATEDISPATCHRULEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/arms/ARMSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ARMS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ARMS_EXPORT CreateDispatchRuleRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateDispatchRuleRequest();
+				~CreateDispatchRuleRequest();
+
+				std::string getDispatchRule()const;
+				void setDispatchRule(const std::string& dispatchRule);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getProxyUserId()const;
+				void setProxyUserId(const std::string& proxyUserId);
+
+            private:
+				std::string dispatchRule_;
+				std::string regionId_;
+				std::string proxyUserId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ARMS_MODEL_CREATEDISPATCHRULEREQUEST_H_

arms/include/alibabacloud/arms/model/CreateDispatchRuleResult.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_ARMS_MODEL_CREATEDISPATCHRULERESULT_H_
+#define ALIBABACLOUD_ARMS_MODEL_CREATEDISPATCHRULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/arms/ARMSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ARMS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ARMS_EXPORT CreateDispatchRuleResult : public ServiceResult
+			{
+			public:
+
+
+				CreateDispatchRuleResult();
+				explicit CreateDispatchRuleResult(const std::string &payload);
+				~CreateDispatchRuleResult();
+				long getDispatchRuleId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long dispatchRuleId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ARMS_MODEL_CREATEDISPATCHRULERESULT_H_

arms/include/alibabacloud/arms/model/DeleteDispatchRuleRequest.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_ARMS_MODEL_DELETEDISPATCHRULEREQUEST_H_
+#define ALIBABACLOUD_ARMS_MODEL_DELETEDISPATCHRULEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/arms/ARMSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ARMS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ARMS_EXPORT DeleteDispatchRuleRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteDispatchRuleRequest();
+				~DeleteDispatchRuleRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getId()const;
+				void setId(const std::string& id);
+				std::string getProxyUserId()const;
+				void setProxyUserId(const std::string& proxyUserId);
+
+            private:
+				std::string regionId_;
+				std::string id_;
+				std::string proxyUserId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ARMS_MODEL_DELETEDISPATCHRULEREQUEST_H_

arms/include/alibabacloud/arms/model/DeleteDispatchRuleResult.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_ARMS_MODEL_DELETEDISPATCHRULERESULT_H_
+#define ALIBABACLOUD_ARMS_MODEL_DELETEDISPATCHRULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/arms/ARMSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ARMS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ARMS_EXPORT DeleteDispatchRuleResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteDispatchRuleResult();
+				explicit DeleteDispatchRuleResult(const std::string &payload);
+				~DeleteDispatchRuleResult();
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ARMS_MODEL_DELETEDISPATCHRULERESULT_H_

arms/include/alibabacloud/arms/model/DeleteScenarioRequest.h

@@ -35,10 +35,13 @@ namespace AlibabaCloud
 				DeleteScenarioRequest();
 				~DeleteScenarioRequest();
 
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
 				long getScenarioId()const;
 				void setScenarioId(long scenarioId);
 
             private:
+				std::string regionId_;
 				long scenarioId_;
 
 			};

arms/include/alibabacloud/arms/model/GetMultipleTraceResult.h

@@ -51,18 +51,20 @@ namespace AlibabaCloud
 							std::vector<LogEvent::TagEntry2> tagEntryList1;
 							long timestamp;
 						};
-						bool haveStack;
+						std::string parentSpanId;
 						std::string serviceIp;
-						std::vector<Span::LogEvent> logEventList;
 						std::string operationName;
-						std::string serviceName;
-						std::string rpcId;
 						int rpcType;
-						std::string traceID;
 						long duration;
 						std::vector<Span::TagEntry> tagEntryList;
 						long timestamp;
+						bool haveStack;
+						std::vector<Span::LogEvent> logEventList;
+						std::string serviceName;
+						std::string rpcId;
+						std::string traceID;
 						std::string resultCode;
+						std::string spanId;
 					};
 					std::string traceID;
 					std::vector<MultiCallChainInfo::Span> spans;

arms/include/alibabacloud/arms/model/GetTraceResult.h

@@ -49,18 +49,20 @@ namespace AlibabaCloud
 						std::vector<LogEvent::TagEntry2> tagEntryList1;
 						long timestamp;
 					};
-					bool haveStack;
+					std::string parentSpanId;
 					std::string serviceIp;
-					std::vector<Span::LogEvent> logEventList;
 					std::string operationName;
-					std::string serviceName;
-					std::string rpcId;
 					int rpcType;
-					std::string traceID;
 					long duration;
 					std::vector<Span::TagEntry> tagEntryList;
 					long timestamp;
+					bool haveStack;
+					std::vector<Span::LogEvent> logEventList;
+					std::string serviceName;
+					std::string rpcId;
+					std::string traceID;
 					std::string resultCode;
+					std::string spanId;
 				};
 
 

arms/include/alibabacloud/arms/model/ListDispatchRuleRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ARMS_MODEL_LISTDISPATCHRULEREQUEST_H_
+#define ALIBABACLOUD_ARMS_MODEL_LISTDISPATCHRULEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/arms/ARMSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ARMS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ARMS_EXPORT ListDispatchRuleRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListDispatchRuleRequest();
+				~ListDispatchRuleRequest();
+
+				bool getSystem()const;
+				void setSystem(bool system);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getProxyUserId()const;
+				void setProxyUserId(const std::string& proxyUserId);
+
+            private:
+				bool system_;
+				std::string regionId_;
+				std::string name_;
+				std::string proxyUserId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ARMS_MODEL_LISTDISPATCHRULEREQUEST_H_

arms/include/alibabacloud/arms/model/ListDispatchRuleResult.h

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

arms/include/alibabacloud/arms/model/ListServerlessTopNAppsRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ARMS_MODEL_LISTSERVERLESSTOPNAPPSREQUEST_H_
+#define ALIBABACLOUD_ARMS_MODEL_LISTSERVERLESSTOPNAPPSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/arms/ARMSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ARMS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ARMS_EXPORT ListServerlessTopNAppsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListServerlessTopNAppsRequest();
+				~ListServerlessTopNAppsRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				int getLimit()const;
+				void setLimit(int limit);
+				std::string getOrderBy()const;
+				void setOrderBy(const std::string& orderBy);
+				long getEndTime()const;
+				void setEndTime(long endTime);
+				long getStartTime()const;
+				void setStartTime(long startTime);
+
+            private:
+				std::string regionId_;
+				int limit_;
+				std::string orderBy_;
+				long endTime_;
+				long startTime_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ARMS_MODEL_LISTSERVERLESSTOPNAPPSREQUEST_H_

arms/include/alibabacloud/arms/model/ListServerlessTopNAppsResult.h

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

arms/include/alibabacloud/arms/model/OpenVClusterRequest.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_ARMS_MODEL_OPENVCLUSTERREQUEST_H_
+#define ALIBABACLOUD_ARMS_MODEL_OPENVCLUSTERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/arms/ARMSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ARMS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ARMS_EXPORT OpenVClusterRequest : public RpcServiceRequest
+			{
+
+			public:
+				OpenVClusterRequest();
+				~OpenVClusterRequest();
+
+				std::string getClusterType()const;
+				void setClusterType(const std::string& clusterType);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				int getLength()const;
+				void setLength(int length);
+
+            private:
+				std::string clusterType_;
+				std::string regionId_;
+				int length_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ARMS_MODEL_OPENVCLUSTERREQUEST_H_

arms/include/alibabacloud/arms/model/OpenVClusterResult.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_ARMS_MODEL_OPENVCLUSTERRESULT_H_
+#define ALIBABACLOUD_ARMS_MODEL_OPENVCLUSTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/arms/ARMSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ARMS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ARMS_EXPORT OpenVClusterResult : public ServiceResult
+			{
+			public:
+
+
+				OpenVClusterResult();
+				explicit OpenVClusterResult(const std::string &payload);
+				~OpenVClusterResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ARMS_MODEL_OPENVCLUSTERRESULT_H_

arms/include/alibabacloud/arms/model/QueryMetricByPageRequest.h

@@ -63,6 +63,8 @@ namespace AlibabaCloud
 				void setIntervalInSec(int intervalInSec);
 				std::string getMetric()const;
 				void setMetric(const std::string& metric);
+				std::vector<std::string> getCustomFilters()const;
+				void setCustomFilters(const std::vector<std::string>& customFilters);
 				int getPageSize()const;
 				void setPageSize(int pageSize);
 				std::vector<std::string> getDimensions()const;
@@ -82,6 +84,7 @@ namespace AlibabaCloud
 				std::vector<std::string> measures_;
 				int intervalInSec_;
 				std::string metric_;
+				std::vector<std::string> customFilters_;
 				int pageSize_;
 				std::vector<std::string> dimensions_;
 				std::string order_;

arms/include/alibabacloud/arms/model/UpdateDispatchRuleRequest.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_ARMS_MODEL_UPDATEDISPATCHRULEREQUEST_H_
+#define ALIBABACLOUD_ARMS_MODEL_UPDATEDISPATCHRULEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/arms/ARMSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ARMS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ARMS_EXPORT UpdateDispatchRuleRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateDispatchRuleRequest();
+				~UpdateDispatchRuleRequest();
+
+				std::string getDispatchRule()const;
+				void setDispatchRule(const std::string& dispatchRule);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getProxyUserId()const;
+				void setProxyUserId(const std::string& proxyUserId);
+
+            private:
+				std::string dispatchRule_;
+				std::string regionId_;
+				std::string proxyUserId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ARMS_MODEL_UPDATEDISPATCHRULEREQUEST_H_

arms/include/alibabacloud/arms/model/UpdateDispatchRuleResult.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_ARMS_MODEL_UPDATEDISPATCHRULERESULT_H_
+#define ALIBABACLOUD_ARMS_MODEL_UPDATEDISPATCHRULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/arms/ARMSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ARMS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ARMS_EXPORT UpdateDispatchRuleResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateDispatchRuleResult();
+				explicit UpdateDispatchRuleResult(const std::string &payload);
+				~UpdateDispatchRuleResult();
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ARMS_MODEL_UPDATEDISPATCHRULERESULT_H_

arms/src/ARMSClient.cc

@@ -231,6 +231,42 @@ ARMSClient::CheckServiceLinkedRoleForDeletingOutcomeCallable ARMSClient::checkSe
 	return task->get_future();
 }
 
+ARMSClient::CheckServiceStatusOutcome ARMSClient::checkServiceStatus(const CheckServiceStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CheckServiceStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CheckServiceStatusOutcome(CheckServiceStatusResult(outcome.result()));
+	else
+		return CheckServiceStatusOutcome(outcome.error());
+}
+
+void ARMSClient::checkServiceStatusAsync(const CheckServiceStatusRequest& request, const CheckServiceStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, checkServiceStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ARMSClient::CheckServiceStatusOutcomeCallable ARMSClient::checkServiceStatusCallable(const CheckServiceStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CheckServiceStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->checkServiceStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ARMSClient::ConfigAppOutcome ARMSClient::configApp(const ConfigAppRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -339,6 +375,42 @@ ARMSClient::CreateAlertContactGroupOutcomeCallable ARMSClient::createAlertContac
 	return task->get_future();
 }
 
+ARMSClient::CreateDispatchRuleOutcome ARMSClient::createDispatchRule(const CreateDispatchRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateDispatchRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateDispatchRuleOutcome(CreateDispatchRuleResult(outcome.result()));
+	else
+		return CreateDispatchRuleOutcome(outcome.error());
+}
+
+void ARMSClient::createDispatchRuleAsync(const CreateDispatchRuleRequest& request, const CreateDispatchRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createDispatchRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ARMSClient::CreateDispatchRuleOutcomeCallable ARMSClient::createDispatchRuleCallable(const CreateDispatchRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateDispatchRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->createDispatchRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ARMSClient::CreateRetcodeAppOutcome ARMSClient::createRetcodeApp(const CreateRetcodeAppRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -519,6 +591,42 @@ ARMSClient::DeleteAlertRulesOutcomeCallable ARMSClient::deleteAlertRulesCallable
 	return task->get_future();
 }
 
+ARMSClient::DeleteDispatchRuleOutcome ARMSClient::deleteDispatchRule(const DeleteDispatchRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteDispatchRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteDispatchRuleOutcome(DeleteDispatchRuleResult(outcome.result()));
+	else
+		return DeleteDispatchRuleOutcome(outcome.error());
+}
+
+void ARMSClient::deleteDispatchRuleAsync(const DeleteDispatchRuleRequest& request, const DeleteDispatchRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteDispatchRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ARMSClient::DeleteDispatchRuleOutcomeCallable ARMSClient::deleteDispatchRuleCallable(const DeleteDispatchRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteDispatchRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteDispatchRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ARMSClient::DeleteRetcodeAppOutcome ARMSClient::deleteRetcodeApp(const DeleteRetcodeAppRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1311,6 +1419,42 @@ ARMSClient::ListDashboardsOutcomeCallable ARMSClient::listDashboardsCallable(con
 	return task->get_future();
 }
 
+ARMSClient::ListDispatchRuleOutcome ARMSClient::listDispatchRule(const ListDispatchRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListDispatchRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListDispatchRuleOutcome(ListDispatchRuleResult(outcome.result()));
+	else
+		return ListDispatchRuleOutcome(outcome.error());
+}
+
+void ARMSClient::listDispatchRuleAsync(const ListDispatchRuleRequest& request, const ListDispatchRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listDispatchRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ARMSClient::ListDispatchRuleOutcomeCallable ARMSClient::listDispatchRuleCallable(const ListDispatchRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListDispatchRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->listDispatchRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ARMSClient::ListPromClustersOutcome ARMSClient::listPromClusters(const ListPromClustersRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1419,6 +1563,42 @@ ARMSClient::ListScenarioOutcomeCallable ARMSClient::listScenarioCallable(const L
 	return task->get_future();
 }
 
+ARMSClient::ListServerlessTopNAppsOutcome ARMSClient::listServerlessTopNApps(const ListServerlessTopNAppsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListServerlessTopNAppsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListServerlessTopNAppsOutcome(ListServerlessTopNAppsResult(outcome.result()));
+	else
+		return ListServerlessTopNAppsOutcome(outcome.error());
+}
+
+void ARMSClient::listServerlessTopNAppsAsync(const ListServerlessTopNAppsRequest& request, const ListServerlessTopNAppsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listServerlessTopNApps(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ARMSClient::ListServerlessTopNAppsOutcomeCallable ARMSClient::listServerlessTopNAppsCallable(const ListServerlessTopNAppsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListServerlessTopNAppsOutcome()>>(
+			[this, request]()
+			{
+			return this->listServerlessTopNApps(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ARMSClient::ListTraceAppsOutcome ARMSClient::listTraceApps(const ListTraceAppsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1491,6 +1671,42 @@ ARMSClient::OpenArmsServiceOutcomeCallable ARMSClient::openArmsServiceCallable(c
 	return task->get_future();
 }
 
+ARMSClient::OpenVClusterOutcome ARMSClient::openVCluster(const OpenVClusterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return OpenVClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return OpenVClusterOutcome(OpenVClusterResult(outcome.result()));
+	else
+		return OpenVClusterOutcome(outcome.error());
+}
+
+void ARMSClient::openVClusterAsync(const OpenVClusterRequest& request, const OpenVClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, openVCluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ARMSClient::OpenVClusterOutcomeCallable ARMSClient::openVClusterCallable(const OpenVClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<OpenVClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->openVCluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ARMSClient::QueryDatasetOutcome ARMSClient::queryDataset(const QueryDatasetRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2283,6 +2499,42 @@ ARMSClient::UpdateAlertRuleOutcomeCallable ARMSClient::updateAlertRuleCallable(c
 	return task->get_future();
 }
 
+ARMSClient::UpdateDispatchRuleOutcome ARMSClient::updateDispatchRule(const UpdateDispatchRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateDispatchRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateDispatchRuleOutcome(UpdateDispatchRuleResult(outcome.result()));
+	else
+		return UpdateDispatchRuleOutcome(outcome.error());
+}
+
+void ARMSClient::updateDispatchRuleAsync(const UpdateDispatchRuleRequest& request, const UpdateDispatchRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateDispatchRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ARMSClient::UpdateDispatchRuleOutcomeCallable ARMSClient::updateDispatchRuleCallable(const UpdateDispatchRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateDispatchRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->updateDispatchRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ARMSClient::UpdateWebhookOutcome ARMSClient::updateWebhook(const UpdateWebhookRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

arms/src/model/CheckServiceStatusRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/arms/model/CheckServiceStatusRequest.h>
+
+using AlibabaCloud::ARMS::Model::CheckServiceStatusRequest;
+
+CheckServiceStatusRequest::CheckServiceStatusRequest() :
+	RpcServiceRequest("arms", "2019-08-08", "CheckServiceStatus")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CheckServiceStatusRequest::~CheckServiceStatusRequest()
+{}
+
+std::string CheckServiceStatusRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CheckServiceStatusRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CheckServiceStatusRequest::getSvcCode()const
+{
+	return svcCode_;
+}
+
+void CheckServiceStatusRequest::setSvcCode(const std::string& svcCode)
+{
+	svcCode_ = svcCode;
+	setParameter("SvcCode", svcCode);
+}
+

arms/src/model/CheckServiceStatusResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/arms/model/CheckServiceStatusResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ARMS;
+using namespace AlibabaCloud::ARMS::Model;
+
+CheckServiceStatusResult::CheckServiceStatusResult() :
+	ServiceResult()
+{}
+
+CheckServiceStatusResult::CheckServiceStatusResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CheckServiceStatusResult::~CheckServiceStatusResult()
+{}
+
+void CheckServiceStatusResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
+
+}
+
+std::string CheckServiceStatusResult::getData()const
+{
+	return data_;
+}
+

arms/src/model/CreateDispatchRuleRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/arms/model/CreateDispatchRuleRequest.h>
+
+using AlibabaCloud::ARMS::Model::CreateDispatchRuleRequest;
+
+CreateDispatchRuleRequest::CreateDispatchRuleRequest() :
+	RpcServiceRequest("arms", "2019-08-08", "CreateDispatchRule")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateDispatchRuleRequest::~CreateDispatchRuleRequest()
+{}
+
+std::string CreateDispatchRuleRequest::getDispatchRule()const
+{
+	return dispatchRule_;
+}
+
+void CreateDispatchRuleRequest::setDispatchRule(const std::string& dispatchRule)
+{
+	dispatchRule_ = dispatchRule;
+	setParameter("DispatchRule", dispatchRule);
+}
+
+std::string CreateDispatchRuleRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateDispatchRuleRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreateDispatchRuleRequest::getProxyUserId()const
+{
+	return proxyUserId_;
+}
+
+void CreateDispatchRuleRequest::setProxyUserId(const std::string& proxyUserId)
+{
+	proxyUserId_ = proxyUserId;
+	setParameter("ProxyUserId", proxyUserId);
+}
+

arms/src/model/CreateDispatchRuleResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/arms/model/CreateDispatchRuleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ARMS;
+using namespace AlibabaCloud::ARMS::Model;
+
+CreateDispatchRuleResult::CreateDispatchRuleResult() :
+	ServiceResult()
+{}
+
+CreateDispatchRuleResult::CreateDispatchRuleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateDispatchRuleResult::~CreateDispatchRuleResult()
+{}
+
+void CreateDispatchRuleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["DispatchRuleId"].isNull())
+		dispatchRuleId_ = std::stol(value["DispatchRuleId"].asString());
+
+}
+
+long CreateDispatchRuleResult::getDispatchRuleId()const
+{
+	return dispatchRuleId_;
+}
+

arms/src/model/DeleteDispatchRuleRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/arms/model/DeleteDispatchRuleRequest.h>
+
+using AlibabaCloud::ARMS::Model::DeleteDispatchRuleRequest;
+
+DeleteDispatchRuleRequest::DeleteDispatchRuleRequest() :
+	RpcServiceRequest("arms", "2019-08-08", "DeleteDispatchRule")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteDispatchRuleRequest::~DeleteDispatchRuleRequest()
+{}
+
+std::string DeleteDispatchRuleRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteDispatchRuleRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DeleteDispatchRuleRequest::getId()const
+{
+	return id_;
+}
+
+void DeleteDispatchRuleRequest::setId(const std::string& id)
+{
+	id_ = id;
+	setParameter("Id", id);
+}
+
+std::string DeleteDispatchRuleRequest::getProxyUserId()const
+{
+	return proxyUserId_;
+}
+
+void DeleteDispatchRuleRequest::setProxyUserId(const std::string& proxyUserId)
+{
+	proxyUserId_ = proxyUserId;
+	setParameter("ProxyUserId", proxyUserId);
+}
+

arms/src/model/DeleteDispatchRuleResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/arms/model/DeleteDispatchRuleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ARMS;
+using namespace AlibabaCloud::ARMS::Model;
+
+DeleteDispatchRuleResult::DeleteDispatchRuleResult() :
+	ServiceResult()
+{}
+
+DeleteDispatchRuleResult::DeleteDispatchRuleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteDispatchRuleResult::~DeleteDispatchRuleResult()
+{}
+
+void DeleteDispatchRuleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+bool DeleteDispatchRuleResult::getSuccess()const
+{
+	return success_;
+}
+

arms/src/model/DeleteScenarioRequest.cc

@@ -27,6 +27,17 @@ DeleteScenarioRequest::DeleteScenarioRequest() :
 DeleteScenarioRequest::~DeleteScenarioRequest()
 {}
 
+std::string DeleteScenarioRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteScenarioRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
 long DeleteScenarioRequest::getScenarioId()const
 {
 	return scenarioId_;

arms/src/model/GetMultipleTraceResult.cc

@@ -69,6 +69,10 @@ void GetMultipleTraceResult::parse(const std::string &payload)
 				spansObject.haveStack = valueMultiCallChainInfosMultiCallChainInfoSpansSpan["HaveStack"].asString() == "true";
 			if(!valueMultiCallChainInfosMultiCallChainInfoSpansSpan["RpcType"].isNull())
 				spansObject.rpcType = std::stoi(valueMultiCallChainInfosMultiCallChainInfoSpansSpan["RpcType"].asString());
+			if(!valueMultiCallChainInfosMultiCallChainInfoSpansSpan["SpanId"].isNull())
+				spansObject.spanId = valueMultiCallChainInfosMultiCallChainInfoSpansSpan["SpanId"].asString();
+			if(!valueMultiCallChainInfosMultiCallChainInfoSpansSpan["ParentSpanId"].isNull())
+				spansObject.parentSpanId = valueMultiCallChainInfosMultiCallChainInfoSpansSpan["ParentSpanId"].asString();
 			auto allTagEntryListNode = valueMultiCallChainInfosMultiCallChainInfoSpansSpan["TagEntryList"]["TagEntry"];
 			for (auto valueMultiCallChainInfosMultiCallChainInfoSpansSpanTagEntryListTagEntry : allTagEntryListNode)
 			{

arms/src/model/GetTraceResult.cc

@@ -63,6 +63,10 @@ void GetTraceResult::parse(const std::string &payload)
 			spansObject.haveStack = valueSpansSpan["HaveStack"].asString() == "true";
 		if(!valueSpansSpan["RpcType"].isNull())
 			spansObject.rpcType = std::stoi(valueSpansSpan["RpcType"].asString());
+		if(!valueSpansSpan["SpanId"].isNull())
+			spansObject.spanId = valueSpansSpan["SpanId"].asString();
+		if(!valueSpansSpan["ParentSpanId"].isNull())
+			spansObject.parentSpanId = valueSpansSpan["ParentSpanId"].asString();
 		auto allTagEntryListNode = valueSpansSpan["TagEntryList"]["TagEntry"];
 		for (auto valueSpansSpanTagEntryListTagEntry : allTagEntryListNode)
 		{

arms/src/model/ListDispatchRuleRequest.cc

@@ -0,0 +1,73 @@
+/*
+ * 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/arms/model/ListDispatchRuleRequest.h>
+
+using AlibabaCloud::ARMS::Model::ListDispatchRuleRequest;
+
+ListDispatchRuleRequest::ListDispatchRuleRequest() :
+	RpcServiceRequest("arms", "2019-08-08", "ListDispatchRule")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListDispatchRuleRequest::~ListDispatchRuleRequest()
+{}
+
+bool ListDispatchRuleRequest::getSystem()const
+{
+	return system_;
+}
+
+void ListDispatchRuleRequest::setSystem(bool system)
+{
+	system_ = system;
+	setParameter("System", system ? "true" : "false");
+}
+
+std::string ListDispatchRuleRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ListDispatchRuleRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string ListDispatchRuleRequest::getName()const
+{
+	return name_;
+}
+
+void ListDispatchRuleRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+std::string ListDispatchRuleRequest::getProxyUserId()const
+{
+	return proxyUserId_;
+}
+
+void ListDispatchRuleRequest::setProxyUserId(const std::string& proxyUserId)
+{
+	proxyUserId_ = proxyUserId;
+	setParameter("ProxyUserId", proxyUserId);
+}
+

arms/src/model/ListDispatchRuleResult.cc

@@ -0,0 +1,61 @@
+/*
+ * 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/arms/model/ListDispatchRuleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ARMS;
+using namespace AlibabaCloud::ARMS::Model;
+
+ListDispatchRuleResult::ListDispatchRuleResult() :
+	ServiceResult()
+{}
+
+ListDispatchRuleResult::ListDispatchRuleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListDispatchRuleResult::~ListDispatchRuleResult()
+{}
+
+void ListDispatchRuleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDispatchRulesNode = value["DispatchRules"]["DispatchRule"];
+	for (auto valueDispatchRulesDispatchRule : allDispatchRulesNode)
+	{
+		DispatchRule dispatchRulesObject;
+		if(!valueDispatchRulesDispatchRule["RuleId"].isNull())
+			dispatchRulesObject.ruleId = std::stol(valueDispatchRulesDispatchRule["RuleId"].asString());
+		if(!valueDispatchRulesDispatchRule["Name"].isNull())
+			dispatchRulesObject.name = valueDispatchRulesDispatchRule["Name"].asString();
+		if(!valueDispatchRulesDispatchRule["State"].isNull())
+			dispatchRulesObject.state = valueDispatchRulesDispatchRule["State"].asString();
+		dispatchRules_.push_back(dispatchRulesObject);
+	}
+
+}
+
+std::vector<ListDispatchRuleResult::DispatchRule> ListDispatchRuleResult::getDispatchRules()const
+{
+	return dispatchRules_;
+}
+

arms/src/model/ListServerlessTopNAppsRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * 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/arms/model/ListServerlessTopNAppsRequest.h>
+
+using AlibabaCloud::ARMS::Model::ListServerlessTopNAppsRequest;
+
+ListServerlessTopNAppsRequest::ListServerlessTopNAppsRequest() :
+	RpcServiceRequest("arms", "2019-08-08", "ListServerlessTopNApps")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListServerlessTopNAppsRequest::~ListServerlessTopNAppsRequest()
+{}
+
+std::string ListServerlessTopNAppsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ListServerlessTopNAppsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+int ListServerlessTopNAppsRequest::getLimit()const
+{
+	return limit_;
+}
+
+void ListServerlessTopNAppsRequest::setLimit(int limit)
+{
+	limit_ = limit;
+	setParameter("Limit", std::to_string(limit));
+}
+
+std::string ListServerlessTopNAppsRequest::getOrderBy()const
+{
+	return orderBy_;
+}
+
+void ListServerlessTopNAppsRequest::setOrderBy(const std::string& orderBy)
+{
+	orderBy_ = orderBy;
+	setParameter("OrderBy", orderBy);
+}
+
+long ListServerlessTopNAppsRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void ListServerlessTopNAppsRequest::setEndTime(long endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", std::to_string(endTime));
+}
+
+long ListServerlessTopNAppsRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void ListServerlessTopNAppsRequest::setStartTime(long startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", std::to_string(startTime));
+}
+

arms/src/model/ListServerlessTopNAppsResult.cc

@@ -0,0 +1,67 @@
+/*
+ * 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/arms/model/ListServerlessTopNAppsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ARMS;
+using namespace AlibabaCloud::ARMS::Model;
+
+ListServerlessTopNAppsResult::ListServerlessTopNAppsResult() :
+	ServiceResult()
+{}
+
+ListServerlessTopNAppsResult::ListServerlessTopNAppsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListServerlessTopNAppsResult::~ListServerlessTopNAppsResult()
+{}
+
+void ListServerlessTopNAppsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["DataItem"];
+	for (auto valueDataDataItem : allDataNode)
+	{
+		DataItem dataObject;
+		if(!valueDataDataItem["Pid"].isNull())
+			dataObject.pid = valueDataDataItem["Pid"].asString();
+		if(!valueDataDataItem["Name"].isNull())
+			dataObject.name = valueDataDataItem["Name"].asString();
+		if(!valueDataDataItem["Region"].isNull())
+			dataObject.region = valueDataDataItem["Region"].asString();
+		if(!valueDataDataItem["Rt"].isNull())
+			dataObject.rt = std::stof(valueDataDataItem["Rt"].asString());
+		if(!valueDataDataItem["Count"].isNull())
+			dataObject.count = std::stoi(valueDataDataItem["Count"].asString());
+		if(!valueDataDataItem["Error"].isNull())
+			dataObject.error = std::stoi(valueDataDataItem["Error"].asString());
+		data_.push_back(dataObject);
+	}
+
+}
+
+std::vector<ListServerlessTopNAppsResult::DataItem> ListServerlessTopNAppsResult::getData()const
+{
+	return data_;
+}
+

arms/src/model/OpenVClusterRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/arms/model/OpenVClusterRequest.h>
+
+using AlibabaCloud::ARMS::Model::OpenVClusterRequest;
+
+OpenVClusterRequest::OpenVClusterRequest() :
+	RpcServiceRequest("arms", "2019-08-08", "OpenVCluster")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+OpenVClusterRequest::~OpenVClusterRequest()
+{}
+
+std::string OpenVClusterRequest::getClusterType()const
+{
+	return clusterType_;
+}
+
+void OpenVClusterRequest::setClusterType(const std::string& clusterType)
+{
+	clusterType_ = clusterType;
+	setParameter("ClusterType", clusterType);
+}
+
+std::string OpenVClusterRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void OpenVClusterRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+int OpenVClusterRequest::getLength()const
+{
+	return length_;
+}
+
+void OpenVClusterRequest::setLength(int length)
+{
+	length_ = length;
+	setParameter("Length", std::to_string(length));
+}
+

arms/src/model/OpenVClusterResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/arms/model/OpenVClusterResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ARMS;
+using namespace AlibabaCloud::ARMS::Model;
+
+OpenVClusterResult::OpenVClusterResult() :
+	ServiceResult()
+{}
+
+OpenVClusterResult::OpenVClusterResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+OpenVClusterResult::~OpenVClusterResult()
+{}
+
+void OpenVClusterResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
+
+}
+
+std::string OpenVClusterResult::getData()const
+{
+	return data_;
+}
+

arms/src/model/QueryMetricByPageRequest.cc

@@ -155,6 +155,19 @@ void QueryMetricByPageRequest::setMetric(const std::string& metric)
 	setParameter("Metric", metric);
 }
 
+std::vector<std::string> QueryMetricByPageRequest::getCustomFilters()const
+{
+	return customFilters_;
+}
+
+void QueryMetricByPageRequest::setCustomFilters(const std::vector<std::string>& customFilters)
+{
+	customFilters_ = customFilters;
+	for(int dep1 = 0; dep1!= customFilters.size(); dep1++) {
+		setParameter("CustomFilters."+ std::to_string(dep1), customFilters.at(dep1));
+	}
+}
+
 int QueryMetricByPageRequest::getPageSize()const
 {
 	return pageSize_;

arms/src/model/UpdateDispatchRuleRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/arms/model/UpdateDispatchRuleRequest.h>
+
+using AlibabaCloud::ARMS::Model::UpdateDispatchRuleRequest;
+
+UpdateDispatchRuleRequest::UpdateDispatchRuleRequest() :
+	RpcServiceRequest("arms", "2019-08-08", "UpdateDispatchRule")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+UpdateDispatchRuleRequest::~UpdateDispatchRuleRequest()
+{}
+
+std::string UpdateDispatchRuleRequest::getDispatchRule()const
+{
+	return dispatchRule_;
+}
+
+void UpdateDispatchRuleRequest::setDispatchRule(const std::string& dispatchRule)
+{
+	dispatchRule_ = dispatchRule;
+	setParameter("DispatchRule", dispatchRule);
+}
+
+std::string UpdateDispatchRuleRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void UpdateDispatchRuleRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string UpdateDispatchRuleRequest::getProxyUserId()const
+{
+	return proxyUserId_;
+}
+
+void UpdateDispatchRuleRequest::setProxyUserId(const std::string& proxyUserId)
+{
+	proxyUserId_ = proxyUserId;
+	setParameter("ProxyUserId", proxyUserId);
+}
+

arms/src/model/UpdateDispatchRuleResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/arms/model/UpdateDispatchRuleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ARMS;
+using namespace AlibabaCloud::ARMS::Model;
+
+UpdateDispatchRuleResult::UpdateDispatchRuleResult() :
+	ServiceResult()
+{}
+
+UpdateDispatchRuleResult::UpdateDispatchRuleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateDispatchRuleResult::~UpdateDispatchRuleResult()
+{}
+
+void UpdateDispatchRuleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+bool UpdateDispatchRuleResult::getSuccess()const
+{
+	return success_;
+}
+