由武进发起的ESS SDK自动发布, 版本号：1.8.1

Signed-off-by: haowei.yao <haowei.yao@alibaba-inc.com>

CHANGELOG

@@ -1,3 +1,6 @@
+2018-05-08 Version: 1.8.1
+1, Remove DescribeAccountAttributes.
+
 2018-05-02 Version: 1.8.0
 1, Add new interface InstallCloudAssistant, support Cloud Assistant client installation.
 2, Add new interface DescribeCloudAssistantStatus, support Cloud Assistant client status detection.

VERSION

@@ -1 +1 @@
-1.8.0
+1.8.1

ess/CMakeLists.txt

@@ -41,6 +41,8 @@ set(ess_public_header_model
 	include/alibabacloud/ess/model/EnableScalingGroupResult.h
 	include/alibabacloud/ess/model/DeactivateScalingConfigurationRequest.h
 	include/alibabacloud/ess/model/DeactivateScalingConfigurationResult.h
+	include/alibabacloud/ess/model/RebalanceInstancesRequest.h
+	include/alibabacloud/ess/model/RebalanceInstancesResult.h
 	include/alibabacloud/ess/model/CreateNotificationConfigurationRequest.h
 	include/alibabacloud/ess/model/CreateNotificationConfigurationResult.h
 	include/alibabacloud/ess/model/VerifyAuthenticationRequest.h
@@ -75,10 +77,10 @@ set(ess_public_header_model
 	include/alibabacloud/ess/model/DescribeRegionsResult.h
 	include/alibabacloud/ess/model/DescribeScheduledTasksRequest.h
 	include/alibabacloud/ess/model/DescribeScheduledTasksResult.h
+	include/alibabacloud/ess/model/SetInstancesProtectionRequest.h
+	include/alibabacloud/ess/model/SetInstancesProtectionResult.h
 	include/alibabacloud/ess/model/DeleteNotificationConfigurationRequest.h
 	include/alibabacloud/ess/model/DeleteNotificationConfigurationResult.h
-	include/alibabacloud/ess/model/DescribeAccountAttributesRequest.h
-	include/alibabacloud/ess/model/DescribeAccountAttributesResult.h
 	include/alibabacloud/ess/model/DetachInstancesRequest.h
 	include/alibabacloud/ess/model/DetachInstancesResult.h
 	include/alibabacloud/ess/model/DescribeLimitationRequest.h
@@ -124,6 +126,8 @@ set(ess_src
 	src/model/EnableScalingGroupResult.cc
 	src/model/DeactivateScalingConfigurationRequest.cc
 	src/model/DeactivateScalingConfigurationResult.cc
+	src/model/RebalanceInstancesRequest.cc
+	src/model/RebalanceInstancesResult.cc
 	src/model/CreateNotificationConfigurationRequest.cc
 	src/model/CreateNotificationConfigurationResult.cc
 	src/model/VerifyAuthenticationRequest.cc
@@ -158,10 +162,10 @@ set(ess_src
 	src/model/DescribeRegionsResult.cc
 	src/model/DescribeScheduledTasksRequest.cc
 	src/model/DescribeScheduledTasksResult.cc
+	src/model/SetInstancesProtectionRequest.cc
+	src/model/SetInstancesProtectionResult.cc
 	src/model/DeleteNotificationConfigurationRequest.cc
 	src/model/DeleteNotificationConfigurationResult.cc
-	src/model/DescribeAccountAttributesRequest.cc
-	src/model/DescribeAccountAttributesResult.cc
 	src/model/DetachInstancesRequest.cc
 	src/model/DetachInstancesResult.cc
 	src/model/DescribeLimitationRequest.cc

ess/include/alibabacloud/ess/EssClient.h

@@ -22,86 +22,88 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RpcServiceClient.h>
 #include "EssExport.h"
-#include "model/AttachInstancesRequest.h"
-#include "model/AttachInstancesResult.h"
-#include "model/DescribeScalingGroupsRequest.h"
-#include "model/DescribeScalingGroupsResult.h"
-#include "model/EnterStandbyRequest.h"
-#include "model/EnterStandbyResult.h"
-#include "model/DescribeScalingActivitiesRequest.h"
-#include "model/DescribeScalingActivitiesResult.h"
-#include "model/ExitStandbyRequest.h"
-#include "model/ExitStandbyResult.h"
-#include "model/DescribeNotificationConfigurationsRequest.h"
-#include "model/DescribeNotificationConfigurationsResult.h"
-#include "model/DescribeScalingRulesRequest.h"
-#include "model/DescribeScalingRulesResult.h"
-#include "model/ModifyScalingGroupRequest.h"
-#include "model/ModifyScalingGroupResult.h"
-#include "model/EnableScalingGroupRequest.h"
-#include "model/EnableScalingGroupResult.h"
-#include "model/DeactivateScalingConfigurationRequest.h"
-#include "model/DeactivateScalingConfigurationResult.h"
-#include "model/CreateNotificationConfigurationRequest.h"
-#include "model/CreateNotificationConfigurationResult.h"
-#include "model/VerifyAuthenticationRequest.h"
-#include "model/VerifyAuthenticationResult.h"
-#include "model/CreateScheduledTaskRequest.h"
-#include "model/CreateScheduledTaskResult.h"
-#include "model/DeleteScheduledTaskRequest.h"
-#include "model/DeleteScheduledTaskResult.h"
-#include "model/ModifyNotificationConfigurationRequest.h"
-#include "model/ModifyNotificationConfigurationResult.h"
-#include "model/CreateScalingRuleRequest.h"
-#include "model/CreateScalingRuleResult.h"
-#include "model/DescribeScalingConfigurationsRequest.h"
-#include "model/DescribeScalingConfigurationsResult.h"
-#include "model/ModifyScheduledTaskRequest.h"
-#include "model/ModifyScheduledTaskResult.h"
-#include "model/RemoveInstancesRequest.h"
-#include "model/RemoveInstancesResult.h"
-#include "model/DescribeNotificationTypesRequest.h"
-#include "model/DescribeNotificationTypesResult.h"
-#include "model/ExecuteScalingRuleRequest.h"
-#include "model/ExecuteScalingRuleResult.h"
-#include "model/DeleteScalingGroupRequest.h"
-#include "model/DeleteScalingGroupResult.h"
-#include "model/DescribeScalingInstancesRequest.h"
-#include "model/DescribeScalingInstancesResult.h"
-#include "model/CreateScalingConfigurationRequest.h"
-#include "model/CreateScalingConfigurationResult.h"
-#include "model/DescribeCapacityHistoryRequest.h"
-#include "model/DescribeCapacityHistoryResult.h"
-#include "model/DescribeRegionsRequest.h"
-#include "model/DescribeRegionsResult.h"
-#include "model/DescribeScheduledTasksRequest.h"
-#include "model/DescribeScheduledTasksResult.h"
-#include "model/DeleteNotificationConfigurationRequest.h"
-#include "model/DeleteNotificationConfigurationResult.h"
-#include "model/DescribeAccountAttributesRequest.h"
-#include "model/DescribeAccountAttributesResult.h"
-#include "model/DetachInstancesRequest.h"
-#include "model/DetachInstancesResult.h"
-#include "model/DescribeLimitationRequest.h"
-#include "model/DescribeLimitationResult.h"
-#include "model/DescribeScalingActivityDetailRequest.h"
-#include "model/DescribeScalingActivityDetailResult.h"
-#include "model/DescribeAlertConfigRequest.h"
-#include "model/DescribeAlertConfigResult.h"
-#include "model/CreateScalingGroupRequest.h"
-#include "model/CreateScalingGroupResult.h"
-#include "model/DeleteScalingConfigurationRequest.h"
-#include "model/DeleteScalingConfigurationResult.h"
-#include "model/DisableScalingGroupRequest.h"
-#include "model/DisableScalingGroupResult.h"
-#include "model/ModifyScalingRuleRequest.h"
-#include "model/ModifyScalingRuleResult.h"
-#include "model/DeleteScalingRuleRequest.h"
-#include "model/DeleteScalingRuleResult.h"
-#include "model/VerifyUserRequest.h"
-#include "model/VerifyUserResult.h"
-#include "model/ModifyAlertConfigRequest.h"
-#include "model/ModifyAlertConfigResult.h"
+#include "model/AttachInstancesRequest.h"
+#include "model/AttachInstancesResult.h"
+#include "model/DescribeScalingGroupsRequest.h"
+#include "model/DescribeScalingGroupsResult.h"
+#include "model/EnterStandbyRequest.h"
+#include "model/EnterStandbyResult.h"
+#include "model/DescribeScalingActivitiesRequest.h"
+#include "model/DescribeScalingActivitiesResult.h"
+#include "model/ExitStandbyRequest.h"
+#include "model/ExitStandbyResult.h"
+#include "model/DescribeNotificationConfigurationsRequest.h"
+#include "model/DescribeNotificationConfigurationsResult.h"
+#include "model/DescribeScalingRulesRequest.h"
+#include "model/DescribeScalingRulesResult.h"
+#include "model/ModifyScalingGroupRequest.h"
+#include "model/ModifyScalingGroupResult.h"
+#include "model/EnableScalingGroupRequest.h"
+#include "model/EnableScalingGroupResult.h"
+#include "model/DeactivateScalingConfigurationRequest.h"
+#include "model/DeactivateScalingConfigurationResult.h"
+#include "model/RebalanceInstancesRequest.h"
+#include "model/RebalanceInstancesResult.h"
+#include "model/CreateNotificationConfigurationRequest.h"
+#include "model/CreateNotificationConfigurationResult.h"
+#include "model/VerifyAuthenticationRequest.h"
+#include "model/VerifyAuthenticationResult.h"
+#include "model/CreateScheduledTaskRequest.h"
+#include "model/CreateScheduledTaskResult.h"
+#include "model/DeleteScheduledTaskRequest.h"
+#include "model/DeleteScheduledTaskResult.h"
+#include "model/ModifyNotificationConfigurationRequest.h"
+#include "model/ModifyNotificationConfigurationResult.h"
+#include "model/CreateScalingRuleRequest.h"
+#include "model/CreateScalingRuleResult.h"
+#include "model/DescribeScalingConfigurationsRequest.h"
+#include "model/DescribeScalingConfigurationsResult.h"
+#include "model/ModifyScheduledTaskRequest.h"
+#include "model/ModifyScheduledTaskResult.h"
+#include "model/RemoveInstancesRequest.h"
+#include "model/RemoveInstancesResult.h"
+#include "model/DescribeNotificationTypesRequest.h"
+#include "model/DescribeNotificationTypesResult.h"
+#include "model/ExecuteScalingRuleRequest.h"
+#include "model/ExecuteScalingRuleResult.h"
+#include "model/DeleteScalingGroupRequest.h"
+#include "model/DeleteScalingGroupResult.h"
+#include "model/DescribeScalingInstancesRequest.h"
+#include "model/DescribeScalingInstancesResult.h"
+#include "model/CreateScalingConfigurationRequest.h"
+#include "model/CreateScalingConfigurationResult.h"
+#include "model/DescribeCapacityHistoryRequest.h"
+#include "model/DescribeCapacityHistoryResult.h"
+#include "model/DescribeRegionsRequest.h"
+#include "model/DescribeRegionsResult.h"
+#include "model/DescribeScheduledTasksRequest.h"
+#include "model/DescribeScheduledTasksResult.h"
+#include "model/SetInstancesProtectionRequest.h"
+#include "model/SetInstancesProtectionResult.h"
+#include "model/DeleteNotificationConfigurationRequest.h"
+#include "model/DeleteNotificationConfigurationResult.h"
+#include "model/DetachInstancesRequest.h"
+#include "model/DetachInstancesResult.h"
+#include "model/DescribeLimitationRequest.h"
+#include "model/DescribeLimitationResult.h"
+#include "model/DescribeScalingActivityDetailRequest.h"
+#include "model/DescribeScalingActivityDetailResult.h"
+#include "model/DescribeAlertConfigRequest.h"
+#include "model/DescribeAlertConfigResult.h"
+#include "model/CreateScalingGroupRequest.h"
+#include "model/CreateScalingGroupResult.h"
+#include "model/DeleteScalingConfigurationRequest.h"
+#include "model/DeleteScalingConfigurationResult.h"
+#include "model/DisableScalingGroupRequest.h"
+#include "model/DisableScalingGroupResult.h"
+#include "model/ModifyScalingRuleRequest.h"
+#include "model/ModifyScalingRuleResult.h"
+#include "model/DeleteScalingRuleRequest.h"
+#include "model/DeleteScalingRuleResult.h"
+#include "model/VerifyUserRequest.h"
+#include "model/VerifyUserResult.h"
+#include "model/ModifyAlertConfigRequest.h"
+#include "model/ModifyAlertConfigResult.h"
 
 
 namespace AlibabaCloud
@@ -113,124 +115,127 @@ namespace AlibabaCloud
 		public:
 			typedef Outcome<Error, Model::AttachInstancesResult> AttachInstancesOutcome;
 			typedef std::future<AttachInstancesOutcome> AttachInstancesOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::AttachInstancesRequest&, const AttachInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachInstancesAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::AttachInstancesRequest&, const AttachInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachInstancesAsyncHandler;
 			typedef Outcome<Error, Model::DescribeScalingGroupsResult> DescribeScalingGroupsOutcome;
 			typedef std::future<DescribeScalingGroupsOutcome> DescribeScalingGroupsOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DescribeScalingGroupsRequest&, const DescribeScalingGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingGroupsAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DescribeScalingGroupsRequest&, const DescribeScalingGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingGroupsAsyncHandler;
 			typedef Outcome<Error, Model::EnterStandbyResult> EnterStandbyOutcome;
 			typedef std::future<EnterStandbyOutcome> EnterStandbyOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::EnterStandbyRequest&, const EnterStandbyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnterStandbyAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::EnterStandbyRequest&, const EnterStandbyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnterStandbyAsyncHandler;
 			typedef Outcome<Error, Model::DescribeScalingActivitiesResult> DescribeScalingActivitiesOutcome;
 			typedef std::future<DescribeScalingActivitiesOutcome> DescribeScalingActivitiesOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DescribeScalingActivitiesRequest&, const DescribeScalingActivitiesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingActivitiesAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DescribeScalingActivitiesRequest&, const DescribeScalingActivitiesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingActivitiesAsyncHandler;
 			typedef Outcome<Error, Model::ExitStandbyResult> ExitStandbyOutcome;
 			typedef std::future<ExitStandbyOutcome> ExitStandbyOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::ExitStandbyRequest&, const ExitStandbyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExitStandbyAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::ExitStandbyRequest&, const ExitStandbyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExitStandbyAsyncHandler;
 			typedef Outcome<Error, Model::DescribeNotificationConfigurationsResult> DescribeNotificationConfigurationsOutcome;
 			typedef std::future<DescribeNotificationConfigurationsOutcome> DescribeNotificationConfigurationsOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DescribeNotificationConfigurationsRequest&, const DescribeNotificationConfigurationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeNotificationConfigurationsAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DescribeNotificationConfigurationsRequest&, const DescribeNotificationConfigurationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeNotificationConfigurationsAsyncHandler;
 			typedef Outcome<Error, Model::DescribeScalingRulesResult> DescribeScalingRulesOutcome;
 			typedef std::future<DescribeScalingRulesOutcome> DescribeScalingRulesOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DescribeScalingRulesRequest&, const DescribeScalingRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingRulesAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DescribeScalingRulesRequest&, const DescribeScalingRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingRulesAsyncHandler;
 			typedef Outcome<Error, Model::ModifyScalingGroupResult> ModifyScalingGroupOutcome;
 			typedef std::future<ModifyScalingGroupOutcome> ModifyScalingGroupOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::ModifyScalingGroupRequest&, const ModifyScalingGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyScalingGroupAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::ModifyScalingGroupRequest&, const ModifyScalingGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyScalingGroupAsyncHandler;
 			typedef Outcome<Error, Model::EnableScalingGroupResult> EnableScalingGroupOutcome;
 			typedef std::future<EnableScalingGroupOutcome> EnableScalingGroupOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::EnableScalingGroupRequest&, const EnableScalingGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableScalingGroupAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::EnableScalingGroupRequest&, const EnableScalingGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableScalingGroupAsyncHandler;
 			typedef Outcome<Error, Model::DeactivateScalingConfigurationResult> DeactivateScalingConfigurationOutcome;
 			typedef std::future<DeactivateScalingConfigurationOutcome> DeactivateScalingConfigurationOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DeactivateScalingConfigurationRequest&, const DeactivateScalingConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeactivateScalingConfigurationAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DeactivateScalingConfigurationRequest&, const DeactivateScalingConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeactivateScalingConfigurationAsyncHandler;
+			typedef Outcome<Error, Model::RebalanceInstancesResult> RebalanceInstancesOutcome;
+			typedef std::future<RebalanceInstancesOutcome> RebalanceInstancesOutcomeCallable;
+			typedef std::function<void(const EssClient*, const Model::RebalanceInstancesRequest&, const RebalanceInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RebalanceInstancesAsyncHandler;
 			typedef Outcome<Error, Model::CreateNotificationConfigurationResult> CreateNotificationConfigurationOutcome;
 			typedef std::future<CreateNotificationConfigurationOutcome> CreateNotificationConfigurationOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::CreateNotificationConfigurationRequest&, const CreateNotificationConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateNotificationConfigurationAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::CreateNotificationConfigurationRequest&, const CreateNotificationConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateNotificationConfigurationAsyncHandler;
 			typedef Outcome<Error, Model::VerifyAuthenticationResult> VerifyAuthenticationOutcome;
 			typedef std::future<VerifyAuthenticationOutcome> VerifyAuthenticationOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::VerifyAuthenticationRequest&, const VerifyAuthenticationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VerifyAuthenticationAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::VerifyAuthenticationRequest&, const VerifyAuthenticationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VerifyAuthenticationAsyncHandler;
 			typedef Outcome<Error, Model::CreateScheduledTaskResult> CreateScheduledTaskOutcome;
 			typedef std::future<CreateScheduledTaskOutcome> CreateScheduledTaskOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::CreateScheduledTaskRequest&, const CreateScheduledTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateScheduledTaskAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::CreateScheduledTaskRequest&, const CreateScheduledTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateScheduledTaskAsyncHandler;
 			typedef Outcome<Error, Model::DeleteScheduledTaskResult> DeleteScheduledTaskOutcome;
 			typedef std::future<DeleteScheduledTaskOutcome> DeleteScheduledTaskOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DeleteScheduledTaskRequest&, const DeleteScheduledTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteScheduledTaskAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DeleteScheduledTaskRequest&, const DeleteScheduledTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteScheduledTaskAsyncHandler;
 			typedef Outcome<Error, Model::ModifyNotificationConfigurationResult> ModifyNotificationConfigurationOutcome;
 			typedef std::future<ModifyNotificationConfigurationOutcome> ModifyNotificationConfigurationOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::ModifyNotificationConfigurationRequest&, const ModifyNotificationConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyNotificationConfigurationAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::ModifyNotificationConfigurationRequest&, const ModifyNotificationConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyNotificationConfigurationAsyncHandler;
 			typedef Outcome<Error, Model::CreateScalingRuleResult> CreateScalingRuleOutcome;
 			typedef std::future<CreateScalingRuleOutcome> CreateScalingRuleOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::CreateScalingRuleRequest&, const CreateScalingRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateScalingRuleAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::CreateScalingRuleRequest&, const CreateScalingRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateScalingRuleAsyncHandler;
 			typedef Outcome<Error, Model::DescribeScalingConfigurationsResult> DescribeScalingConfigurationsOutcome;
 			typedef std::future<DescribeScalingConfigurationsOutcome> DescribeScalingConfigurationsOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DescribeScalingConfigurationsRequest&, const DescribeScalingConfigurationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingConfigurationsAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DescribeScalingConfigurationsRequest&, const DescribeScalingConfigurationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingConfigurationsAsyncHandler;
 			typedef Outcome<Error, Model::ModifyScheduledTaskResult> ModifyScheduledTaskOutcome;
 			typedef std::future<ModifyScheduledTaskOutcome> ModifyScheduledTaskOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::ModifyScheduledTaskRequest&, const ModifyScheduledTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyScheduledTaskAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::ModifyScheduledTaskRequest&, const ModifyScheduledTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyScheduledTaskAsyncHandler;
 			typedef Outcome<Error, Model::RemoveInstancesResult> RemoveInstancesOutcome;
 			typedef std::future<RemoveInstancesOutcome> RemoveInstancesOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::RemoveInstancesRequest&, const RemoveInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveInstancesAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::RemoveInstancesRequest&, const RemoveInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveInstancesAsyncHandler;
 			typedef Outcome<Error, Model::DescribeNotificationTypesResult> DescribeNotificationTypesOutcome;
 			typedef std::future<DescribeNotificationTypesOutcome> DescribeNotificationTypesOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DescribeNotificationTypesRequest&, const DescribeNotificationTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeNotificationTypesAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DescribeNotificationTypesRequest&, const DescribeNotificationTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeNotificationTypesAsyncHandler;
 			typedef Outcome<Error, Model::ExecuteScalingRuleResult> ExecuteScalingRuleOutcome;
 			typedef std::future<ExecuteScalingRuleOutcome> ExecuteScalingRuleOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::ExecuteScalingRuleRequest&, const ExecuteScalingRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExecuteScalingRuleAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::ExecuteScalingRuleRequest&, const ExecuteScalingRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExecuteScalingRuleAsyncHandler;
 			typedef Outcome<Error, Model::DeleteScalingGroupResult> DeleteScalingGroupOutcome;
 			typedef std::future<DeleteScalingGroupOutcome> DeleteScalingGroupOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DeleteScalingGroupRequest&, const DeleteScalingGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteScalingGroupAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DeleteScalingGroupRequest&, const DeleteScalingGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteScalingGroupAsyncHandler;
 			typedef Outcome<Error, Model::DescribeScalingInstancesResult> DescribeScalingInstancesOutcome;
 			typedef std::future<DescribeScalingInstancesOutcome> DescribeScalingInstancesOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DescribeScalingInstancesRequest&, const DescribeScalingInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingInstancesAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DescribeScalingInstancesRequest&, const DescribeScalingInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingInstancesAsyncHandler;
 			typedef Outcome<Error, Model::CreateScalingConfigurationResult> CreateScalingConfigurationOutcome;
 			typedef std::future<CreateScalingConfigurationOutcome> CreateScalingConfigurationOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::CreateScalingConfigurationRequest&, const CreateScalingConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateScalingConfigurationAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::CreateScalingConfigurationRequest&, const CreateScalingConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateScalingConfigurationAsyncHandler;
 			typedef Outcome<Error, Model::DescribeCapacityHistoryResult> DescribeCapacityHistoryOutcome;
 			typedef std::future<DescribeCapacityHistoryOutcome> DescribeCapacityHistoryOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DescribeCapacityHistoryRequest&, const DescribeCapacityHistoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCapacityHistoryAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DescribeCapacityHistoryRequest&, const DescribeCapacityHistoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCapacityHistoryAsyncHandler;
 			typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
 			typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
 			typedef Outcome<Error, Model::DescribeScheduledTasksResult> DescribeScheduledTasksOutcome;
 			typedef std::future<DescribeScheduledTasksOutcome> DescribeScheduledTasksOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DescribeScheduledTasksRequest&, const DescribeScheduledTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScheduledTasksAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DescribeScheduledTasksRequest&, const DescribeScheduledTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScheduledTasksAsyncHandler;
+			typedef Outcome<Error, Model::SetInstancesProtectionResult> SetInstancesProtectionOutcome;
+			typedef std::future<SetInstancesProtectionOutcome> SetInstancesProtectionOutcomeCallable;
+			typedef std::function<void(const EssClient*, const Model::SetInstancesProtectionRequest&, const SetInstancesProtectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetInstancesProtectionAsyncHandler;
 			typedef Outcome<Error, Model::DeleteNotificationConfigurationResult> DeleteNotificationConfigurationOutcome;
 			typedef std::future<DeleteNotificationConfigurationOutcome> DeleteNotificationConfigurationOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DeleteNotificationConfigurationRequest&, const DeleteNotificationConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteNotificationConfigurationAsyncHandler;
-			typedef Outcome<Error, Model::DescribeAccountAttributesResult> DescribeAccountAttributesOutcome;
-			typedef std::future<DescribeAccountAttributesOutcome> DescribeAccountAttributesOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DescribeAccountAttributesRequest&, const DescribeAccountAttributesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccountAttributesAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DeleteNotificationConfigurationRequest&, const DeleteNotificationConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteNotificationConfigurationAsyncHandler;
 			typedef Outcome<Error, Model::DetachInstancesResult> DetachInstancesOutcome;
 			typedef std::future<DetachInstancesOutcome> DetachInstancesOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DetachInstancesRequest&, const DetachInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachInstancesAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DetachInstancesRequest&, const DetachInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachInstancesAsyncHandler;
 			typedef Outcome<Error, Model::DescribeLimitationResult> DescribeLimitationOutcome;
 			typedef std::future<DescribeLimitationOutcome> DescribeLimitationOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DescribeLimitationRequest&, const DescribeLimitationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLimitationAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DescribeLimitationRequest&, const DescribeLimitationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLimitationAsyncHandler;
 			typedef Outcome<Error, Model::DescribeScalingActivityDetailResult> DescribeScalingActivityDetailOutcome;
 			typedef std::future<DescribeScalingActivityDetailOutcome> DescribeScalingActivityDetailOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DescribeScalingActivityDetailRequest&, const DescribeScalingActivityDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingActivityDetailAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DescribeScalingActivityDetailRequest&, const DescribeScalingActivityDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingActivityDetailAsyncHandler;
 			typedef Outcome<Error, Model::DescribeAlertConfigResult> DescribeAlertConfigOutcome;
 			typedef std::future<DescribeAlertConfigOutcome> DescribeAlertConfigOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DescribeAlertConfigRequest&, const DescribeAlertConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAlertConfigAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DescribeAlertConfigRequest&, const DescribeAlertConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAlertConfigAsyncHandler;
 			typedef Outcome<Error, Model::CreateScalingGroupResult> CreateScalingGroupOutcome;
 			typedef std::future<CreateScalingGroupOutcome> CreateScalingGroupOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::CreateScalingGroupRequest&, const CreateScalingGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateScalingGroupAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::CreateScalingGroupRequest&, const CreateScalingGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateScalingGroupAsyncHandler;
 			typedef Outcome<Error, Model::DeleteScalingConfigurationResult> DeleteScalingConfigurationOutcome;
 			typedef std::future<DeleteScalingConfigurationOutcome> DeleteScalingConfigurationOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DeleteScalingConfigurationRequest&, const DeleteScalingConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteScalingConfigurationAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DeleteScalingConfigurationRequest&, const DeleteScalingConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteScalingConfigurationAsyncHandler;
 			typedef Outcome<Error, Model::DisableScalingGroupResult> DisableScalingGroupOutcome;
 			typedef std::future<DisableScalingGroupOutcome> DisableScalingGroupOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DisableScalingGroupRequest&, const DisableScalingGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableScalingGroupAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DisableScalingGroupRequest&, const DisableScalingGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableScalingGroupAsyncHandler;
 			typedef Outcome<Error, Model::ModifyScalingRuleResult> ModifyScalingRuleOutcome;
 			typedef std::future<ModifyScalingRuleOutcome> ModifyScalingRuleOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::ModifyScalingRuleRequest&, const ModifyScalingRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyScalingRuleAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::ModifyScalingRuleRequest&, const ModifyScalingRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyScalingRuleAsyncHandler;
 			typedef Outcome<Error, Model::DeleteScalingRuleResult> DeleteScalingRuleOutcome;
 			typedef std::future<DeleteScalingRuleOutcome> DeleteScalingRuleOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::DeleteScalingRuleRequest&, const DeleteScalingRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteScalingRuleAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::DeleteScalingRuleRequest&, const DeleteScalingRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteScalingRuleAsyncHandler;
 			typedef Outcome<Error, Model::VerifyUserResult> VerifyUserOutcome;
 			typedef std::future<VerifyUserOutcome> VerifyUserOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::VerifyUserRequest&, const VerifyUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VerifyUserAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::VerifyUserRequest&, const VerifyUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VerifyUserAsyncHandler;
 			typedef Outcome<Error, Model::ModifyAlertConfigResult> ModifyAlertConfigOutcome;
 			typedef std::future<ModifyAlertConfigOutcome> ModifyAlertConfigOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::ModifyAlertConfigRequest&, const ModifyAlertConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAlertConfigAsyncHandler;
+			typedef std::function<void(const EssClient*, const Model::ModifyAlertConfigRequest&, const ModifyAlertConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAlertConfigAsyncHandler;
 
 			EssClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			EssClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
@@ -238,124 +243,127 @@ namespace AlibabaCloud
 			~EssClient();
 			AttachInstancesOutcome attachInstances(const Model::AttachInstancesRequest &request)const;
 			void attachInstancesAsync(const Model::AttachInstancesRequest& request, const AttachInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			AttachInstancesOutcomeCallable attachInstancesCallable(const Model::AttachInstancesRequest& request) const;
+			AttachInstancesOutcomeCallable attachInstancesCallable(const Model::AttachInstancesRequest& request) const;
 			DescribeScalingGroupsOutcome describeScalingGroups(const Model::DescribeScalingGroupsRequest &request)const;
 			void describeScalingGroupsAsync(const Model::DescribeScalingGroupsRequest& request, const DescribeScalingGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeScalingGroupsOutcomeCallable describeScalingGroupsCallable(const Model::DescribeScalingGroupsRequest& request) const;
+			DescribeScalingGroupsOutcomeCallable describeScalingGroupsCallable(const Model::DescribeScalingGroupsRequest& request) const;
 			EnterStandbyOutcome enterStandby(const Model::EnterStandbyRequest &request)const;
 			void enterStandbyAsync(const Model::EnterStandbyRequest& request, const EnterStandbyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			EnterStandbyOutcomeCallable enterStandbyCallable(const Model::EnterStandbyRequest& request) const;
+			EnterStandbyOutcomeCallable enterStandbyCallable(const Model::EnterStandbyRequest& request) const;
 			DescribeScalingActivitiesOutcome describeScalingActivities(const Model::DescribeScalingActivitiesRequest &request)const;
 			void describeScalingActivitiesAsync(const Model::DescribeScalingActivitiesRequest& request, const DescribeScalingActivitiesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeScalingActivitiesOutcomeCallable describeScalingActivitiesCallable(const Model::DescribeScalingActivitiesRequest& request) const;
+			DescribeScalingActivitiesOutcomeCallable describeScalingActivitiesCallable(const Model::DescribeScalingActivitiesRequest& request) const;
 			ExitStandbyOutcome exitStandby(const Model::ExitStandbyRequest &request)const;
 			void exitStandbyAsync(const Model::ExitStandbyRequest& request, const ExitStandbyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ExitStandbyOutcomeCallable exitStandbyCallable(const Model::ExitStandbyRequest& request) const;
+			ExitStandbyOutcomeCallable exitStandbyCallable(const Model::ExitStandbyRequest& request) const;
 			DescribeNotificationConfigurationsOutcome describeNotificationConfigurations(const Model::DescribeNotificationConfigurationsRequest &request)const;
 			void describeNotificationConfigurationsAsync(const Model::DescribeNotificationConfigurationsRequest& request, const DescribeNotificationConfigurationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeNotificationConfigurationsOutcomeCallable describeNotificationConfigurationsCallable(const Model::DescribeNotificationConfigurationsRequest& request) const;
+			DescribeNotificationConfigurationsOutcomeCallable describeNotificationConfigurationsCallable(const Model::DescribeNotificationConfigurationsRequest& request) const;
 			DescribeScalingRulesOutcome describeScalingRules(const Model::DescribeScalingRulesRequest &request)const;
 			void describeScalingRulesAsync(const Model::DescribeScalingRulesRequest& request, const DescribeScalingRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeScalingRulesOutcomeCallable describeScalingRulesCallable(const Model::DescribeScalingRulesRequest& request) const;
+			DescribeScalingRulesOutcomeCallable describeScalingRulesCallable(const Model::DescribeScalingRulesRequest& request) const;
 			ModifyScalingGroupOutcome modifyScalingGroup(const Model::ModifyScalingGroupRequest &request)const;
 			void modifyScalingGroupAsync(const Model::ModifyScalingGroupRequest& request, const ModifyScalingGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ModifyScalingGroupOutcomeCallable modifyScalingGroupCallable(const Model::ModifyScalingGroupRequest& request) const;
+			ModifyScalingGroupOutcomeCallable modifyScalingGroupCallable(const Model::ModifyScalingGroupRequest& request) const;
 			EnableScalingGroupOutcome enableScalingGroup(const Model::EnableScalingGroupRequest &request)const;
 			void enableScalingGroupAsync(const Model::EnableScalingGroupRequest& request, const EnableScalingGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			EnableScalingGroupOutcomeCallable enableScalingGroupCallable(const Model::EnableScalingGroupRequest& request) const;
+			EnableScalingGroupOutcomeCallable enableScalingGroupCallable(const Model::EnableScalingGroupRequest& request) const;
 			DeactivateScalingConfigurationOutcome deactivateScalingConfiguration(const Model::DeactivateScalingConfigurationRequest &request)const;
 			void deactivateScalingConfigurationAsync(const Model::DeactivateScalingConfigurationRequest& request, const DeactivateScalingConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DeactivateScalingConfigurationOutcomeCallable deactivateScalingConfigurationCallable(const Model::DeactivateScalingConfigurationRequest& request) const;
+			DeactivateScalingConfigurationOutcomeCallable deactivateScalingConfigurationCallable(const Model::DeactivateScalingConfigurationRequest& request) const;
+			RebalanceInstancesOutcome rebalanceInstances(const Model::RebalanceInstancesRequest &request)const;
+			void rebalanceInstancesAsync(const Model::RebalanceInstancesRequest& request, const RebalanceInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RebalanceInstancesOutcomeCallable rebalanceInstancesCallable(const Model::RebalanceInstancesRequest& request) const;
 			CreateNotificationConfigurationOutcome createNotificationConfiguration(const Model::CreateNotificationConfigurationRequest &request)const;
 			void createNotificationConfigurationAsync(const Model::CreateNotificationConfigurationRequest& request, const CreateNotificationConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateNotificationConfigurationOutcomeCallable createNotificationConfigurationCallable(const Model::CreateNotificationConfigurationRequest& request) const;
+			CreateNotificationConfigurationOutcomeCallable createNotificationConfigurationCallable(const Model::CreateNotificationConfigurationRequest& request) const;
 			VerifyAuthenticationOutcome verifyAuthentication(const Model::VerifyAuthenticationRequest &request)const;
 			void verifyAuthenticationAsync(const Model::VerifyAuthenticationRequest& request, const VerifyAuthenticationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			VerifyAuthenticationOutcomeCallable verifyAuthenticationCallable(const Model::VerifyAuthenticationRequest& request) const;
+			VerifyAuthenticationOutcomeCallable verifyAuthenticationCallable(const Model::VerifyAuthenticationRequest& request) const;
 			CreateScheduledTaskOutcome createScheduledTask(const Model::CreateScheduledTaskRequest &request)const;
 			void createScheduledTaskAsync(const Model::CreateScheduledTaskRequest& request, const CreateScheduledTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateScheduledTaskOutcomeCallable createScheduledTaskCallable(const Model::CreateScheduledTaskRequest& request) const;
+			CreateScheduledTaskOutcomeCallable createScheduledTaskCallable(const Model::CreateScheduledTaskRequest& request) const;
 			DeleteScheduledTaskOutcome deleteScheduledTask(const Model::DeleteScheduledTaskRequest &request)const;
 			void deleteScheduledTaskAsync(const Model::DeleteScheduledTaskRequest& request, const DeleteScheduledTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DeleteScheduledTaskOutcomeCallable deleteScheduledTaskCallable(const Model::DeleteScheduledTaskRequest& request) const;
+			DeleteScheduledTaskOutcomeCallable deleteScheduledTaskCallable(const Model::DeleteScheduledTaskRequest& request) const;
 			ModifyNotificationConfigurationOutcome modifyNotificationConfiguration(const Model::ModifyNotificationConfigurationRequest &request)const;
 			void modifyNotificationConfigurationAsync(const Model::ModifyNotificationConfigurationRequest& request, const ModifyNotificationConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ModifyNotificationConfigurationOutcomeCallable modifyNotificationConfigurationCallable(const Model::ModifyNotificationConfigurationRequest& request) const;
+			ModifyNotificationConfigurationOutcomeCallable modifyNotificationConfigurationCallable(const Model::ModifyNotificationConfigurationRequest& request) const;
 			CreateScalingRuleOutcome createScalingRule(const Model::CreateScalingRuleRequest &request)const;
 			void createScalingRuleAsync(const Model::CreateScalingRuleRequest& request, const CreateScalingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateScalingRuleOutcomeCallable createScalingRuleCallable(const Model::CreateScalingRuleRequest& request) const;
+			CreateScalingRuleOutcomeCallable createScalingRuleCallable(const Model::CreateScalingRuleRequest& request) const;
 			DescribeScalingConfigurationsOutcome describeScalingConfigurations(const Model::DescribeScalingConfigurationsRequest &request)const;
 			void describeScalingConfigurationsAsync(const Model::DescribeScalingConfigurationsRequest& request, const DescribeScalingConfigurationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeScalingConfigurationsOutcomeCallable describeScalingConfigurationsCallable(const Model::DescribeScalingConfigurationsRequest& request) const;
+			DescribeScalingConfigurationsOutcomeCallable describeScalingConfigurationsCallable(const Model::DescribeScalingConfigurationsRequest& request) const;
 			ModifyScheduledTaskOutcome modifyScheduledTask(const Model::ModifyScheduledTaskRequest &request)const;
 			void modifyScheduledTaskAsync(const Model::ModifyScheduledTaskRequest& request, const ModifyScheduledTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ModifyScheduledTaskOutcomeCallable modifyScheduledTaskCallable(const Model::ModifyScheduledTaskRequest& request) const;
+			ModifyScheduledTaskOutcomeCallable modifyScheduledTaskCallable(const Model::ModifyScheduledTaskRequest& request) const;
 			RemoveInstancesOutcome removeInstances(const Model::RemoveInstancesRequest &request)const;
 			void removeInstancesAsync(const Model::RemoveInstancesRequest& request, const RemoveInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			RemoveInstancesOutcomeCallable removeInstancesCallable(const Model::RemoveInstancesRequest& request) const;
+			RemoveInstancesOutcomeCallable removeInstancesCallable(const Model::RemoveInstancesRequest& request) const;
 			DescribeNotificationTypesOutcome describeNotificationTypes(const Model::DescribeNotificationTypesRequest &request)const;
 			void describeNotificationTypesAsync(const Model::DescribeNotificationTypesRequest& request, const DescribeNotificationTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeNotificationTypesOutcomeCallable describeNotificationTypesCallable(const Model::DescribeNotificationTypesRequest& request) const;
+			DescribeNotificationTypesOutcomeCallable describeNotificationTypesCallable(const Model::DescribeNotificationTypesRequest& request) const;
 			ExecuteScalingRuleOutcome executeScalingRule(const Model::ExecuteScalingRuleRequest &request)const;
 			void executeScalingRuleAsync(const Model::ExecuteScalingRuleRequest& request, const ExecuteScalingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ExecuteScalingRuleOutcomeCallable executeScalingRuleCallable(const Model::ExecuteScalingRuleRequest& request) const;
+			ExecuteScalingRuleOutcomeCallable executeScalingRuleCallable(const Model::ExecuteScalingRuleRequest& request) const;
 			DeleteScalingGroupOutcome deleteScalingGroup(const Model::DeleteScalingGroupRequest &request)const;
 			void deleteScalingGroupAsync(const Model::DeleteScalingGroupRequest& request, const DeleteScalingGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DeleteScalingGroupOutcomeCallable deleteScalingGroupCallable(const Model::DeleteScalingGroupRequest& request) const;
+			DeleteScalingGroupOutcomeCallable deleteScalingGroupCallable(const Model::DeleteScalingGroupRequest& request) const;
 			DescribeScalingInstancesOutcome describeScalingInstances(const Model::DescribeScalingInstancesRequest &request)const;
 			void describeScalingInstancesAsync(const Model::DescribeScalingInstancesRequest& request, const DescribeScalingInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeScalingInstancesOutcomeCallable describeScalingInstancesCallable(const Model::DescribeScalingInstancesRequest& request) const;
+			DescribeScalingInstancesOutcomeCallable describeScalingInstancesCallable(const Model::DescribeScalingInstancesRequest& request) const;
 			CreateScalingConfigurationOutcome createScalingConfiguration(const Model::CreateScalingConfigurationRequest &request)const;
 			void createScalingConfigurationAsync(const Model::CreateScalingConfigurationRequest& request, const CreateScalingConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateScalingConfigurationOutcomeCallable createScalingConfigurationCallable(const Model::CreateScalingConfigurationRequest& request) const;
+			CreateScalingConfigurationOutcomeCallable createScalingConfigurationCallable(const Model::CreateScalingConfigurationRequest& request) const;
 			DescribeCapacityHistoryOutcome describeCapacityHistory(const Model::DescribeCapacityHistoryRequest &request)const;
 			void describeCapacityHistoryAsync(const Model::DescribeCapacityHistoryRequest& request, const DescribeCapacityHistoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeCapacityHistoryOutcomeCallable describeCapacityHistoryCallable(const Model::DescribeCapacityHistoryRequest& request) const;
+			DescribeCapacityHistoryOutcomeCallable describeCapacityHistoryCallable(const Model::DescribeCapacityHistoryRequest& request) const;
 			DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
 			void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
+			DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
 			DescribeScheduledTasksOutcome describeScheduledTasks(const Model::DescribeScheduledTasksRequest &request)const;
 			void describeScheduledTasksAsync(const Model::DescribeScheduledTasksRequest& request, const DescribeScheduledTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeScheduledTasksOutcomeCallable describeScheduledTasksCallable(const Model::DescribeScheduledTasksRequest& request) const;
+			DescribeScheduledTasksOutcomeCallable describeScheduledTasksCallable(const Model::DescribeScheduledTasksRequest& request) const;
+			SetInstancesProtectionOutcome setInstancesProtection(const Model::SetInstancesProtectionRequest &request)const;
+			void setInstancesProtectionAsync(const Model::SetInstancesProtectionRequest& request, const SetInstancesProtectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetInstancesProtectionOutcomeCallable setInstancesProtectionCallable(const Model::SetInstancesProtectionRequest& request) const;
 			DeleteNotificationConfigurationOutcome deleteNotificationConfiguration(const Model::DeleteNotificationConfigurationRequest &request)const;
 			void deleteNotificationConfigurationAsync(const Model::DeleteNotificationConfigurationRequest& request, const DeleteNotificationConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DeleteNotificationConfigurationOutcomeCallable deleteNotificationConfigurationCallable(const Model::DeleteNotificationConfigurationRequest& request) const;
-			DescribeAccountAttributesOutcome describeAccountAttributes(const Model::DescribeAccountAttributesRequest &request)const;
-			void describeAccountAttributesAsync(const Model::DescribeAccountAttributesRequest& request, const DescribeAccountAttributesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeAccountAttributesOutcomeCallable describeAccountAttributesCallable(const Model::DescribeAccountAttributesRequest& request) const;
+			DeleteNotificationConfigurationOutcomeCallable deleteNotificationConfigurationCallable(const Model::DeleteNotificationConfigurationRequest& request) const;
 			DetachInstancesOutcome detachInstances(const Model::DetachInstancesRequest &request)const;
 			void detachInstancesAsync(const Model::DetachInstancesRequest& request, const DetachInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DetachInstancesOutcomeCallable detachInstancesCallable(const Model::DetachInstancesRequest& request) const;
+			DetachInstancesOutcomeCallable detachInstancesCallable(const Model::DetachInstancesRequest& request) const;
 			DescribeLimitationOutcome describeLimitation(const Model::DescribeLimitationRequest &request)const;
 			void describeLimitationAsync(const Model::DescribeLimitationRequest& request, const DescribeLimitationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeLimitationOutcomeCallable describeLimitationCallable(const Model::DescribeLimitationRequest& request) const;
+			DescribeLimitationOutcomeCallable describeLimitationCallable(const Model::DescribeLimitationRequest& request) const;
 			DescribeScalingActivityDetailOutcome describeScalingActivityDetail(const Model::DescribeScalingActivityDetailRequest &request)const;
 			void describeScalingActivityDetailAsync(const Model::DescribeScalingActivityDetailRequest& request, const DescribeScalingActivityDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeScalingActivityDetailOutcomeCallable describeScalingActivityDetailCallable(const Model::DescribeScalingActivityDetailRequest& request) const;
+			DescribeScalingActivityDetailOutcomeCallable describeScalingActivityDetailCallable(const Model::DescribeScalingActivityDetailRequest& request) const;
 			DescribeAlertConfigOutcome describeAlertConfig(const Model::DescribeAlertConfigRequest &request)const;
 			void describeAlertConfigAsync(const Model::DescribeAlertConfigRequest& request, const DescribeAlertConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeAlertConfigOutcomeCallable describeAlertConfigCallable(const Model::DescribeAlertConfigRequest& request) const;
+			DescribeAlertConfigOutcomeCallable describeAlertConfigCallable(const Model::DescribeAlertConfigRequest& request) const;
 			CreateScalingGroupOutcome createScalingGroup(const Model::CreateScalingGroupRequest &request)const;
 			void createScalingGroupAsync(const Model::CreateScalingGroupRequest& request, const CreateScalingGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateScalingGroupOutcomeCallable createScalingGroupCallable(const Model::CreateScalingGroupRequest& request) const;
+			CreateScalingGroupOutcomeCallable createScalingGroupCallable(const Model::CreateScalingGroupRequest& request) const;
 			DeleteScalingConfigurationOutcome deleteScalingConfiguration(const Model::DeleteScalingConfigurationRequest &request)const;
 			void deleteScalingConfigurationAsync(const Model::DeleteScalingConfigurationRequest& request, const DeleteScalingConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DeleteScalingConfigurationOutcomeCallable deleteScalingConfigurationCallable(const Model::DeleteScalingConfigurationRequest& request) const;
+			DeleteScalingConfigurationOutcomeCallable deleteScalingConfigurationCallable(const Model::DeleteScalingConfigurationRequest& request) const;
 			DisableScalingGroupOutcome disableScalingGroup(const Model::DisableScalingGroupRequest &request)const;
 			void disableScalingGroupAsync(const Model::DisableScalingGroupRequest& request, const DisableScalingGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DisableScalingGroupOutcomeCallable disableScalingGroupCallable(const Model::DisableScalingGroupRequest& request) const;
+			DisableScalingGroupOutcomeCallable disableScalingGroupCallable(const Model::DisableScalingGroupRequest& request) const;
 			ModifyScalingRuleOutcome modifyScalingRule(const Model::ModifyScalingRuleRequest &request)const;
 			void modifyScalingRuleAsync(const Model::ModifyScalingRuleRequest& request, const ModifyScalingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ModifyScalingRuleOutcomeCallable modifyScalingRuleCallable(const Model::ModifyScalingRuleRequest& request) const;
+			ModifyScalingRuleOutcomeCallable modifyScalingRuleCallable(const Model::ModifyScalingRuleRequest& request) const;
 			DeleteScalingRuleOutcome deleteScalingRule(const Model::DeleteScalingRuleRequest &request)const;
 			void deleteScalingRuleAsync(const Model::DeleteScalingRuleRequest& request, const DeleteScalingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DeleteScalingRuleOutcomeCallable deleteScalingRuleCallable(const Model::DeleteScalingRuleRequest& request) const;
+			DeleteScalingRuleOutcomeCallable deleteScalingRuleCallable(const Model::DeleteScalingRuleRequest& request) const;
 			VerifyUserOutcome verifyUser(const Model::VerifyUserRequest &request)const;
 			void verifyUserAsync(const Model::VerifyUserRequest& request, const VerifyUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			VerifyUserOutcomeCallable verifyUserCallable(const Model::VerifyUserRequest& request) const;
+			VerifyUserOutcomeCallable verifyUserCallable(const Model::VerifyUserRequest& request) const;
 			ModifyAlertConfigOutcome modifyAlertConfig(const Model::ModifyAlertConfigRequest &request)const;
 			void modifyAlertConfigAsync(const Model::ModifyAlertConfigRequest& request, const ModifyAlertConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ModifyAlertConfigOutcomeCallable modifyAlertConfigCallable(const Model::ModifyAlertConfigRequest& request) const;
+			ModifyAlertConfigOutcomeCallable modifyAlertConfigCallable(const Model::ModifyAlertConfigRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

ess/include/alibabacloud/ess/model/CreateScalingGroupRequest.h

@@ -35,6 +35,8 @@ namespace AlibabaCloud
 				CreateScalingGroupRequest();
 				~CreateScalingGroupRequest();
 
+				std::string getMultiAZPolicy()const;
+				void setMultiAZPolicy(const std::string& multiAZPolicy);
 				std::string getDBInstanceIds()const;
 				void setDBInstanceIds(const std::string& dBInstanceIds);
 				std::string getLoadBalancerIds()const;
@@ -67,6 +69,7 @@ namespace AlibabaCloud
 				void setRemovalPolicy2(const std::string& removalPolicy2);
 
             private:
+				std::string multiAZPolicy_;
 				std::string dBInstanceIds_;
 				std::string loadBalancerIds_;
 				std::string resourceOwnerAccount_;

ess/include/alibabacloud/ess/model/DescribeAccountAttributesResult.h

@@ -1,67 +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_ESS_MODEL_DESCRIBEACCOUNTATTRIBUTESRESULT_H_
-#define ALIBABACLOUD_ESS_MODEL_DESCRIBEACCOUNTATTRIBUTESRESULT_H_
-
-#include <string>
-#include <vector>
-#include <utility>
-#include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/ess/EssExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Ess
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_ESS_EXPORT DescribeAccountAttributesResult : public ServiceResult
-			{
-			public:
-
-
-				DescribeAccountAttributesResult();
-				explicit DescribeAccountAttributesResult(const std::string &payload);
-				~DescribeAccountAttributesResult();
-				int getMaxNumberOfScalingRules()const;
-				int getMaxNumberOfScalingInstances()const;
-				int getMaxNumberOfScheduledTasks()const;
-				int getMaxNumberOfLoadBalancers()const;
-				int getMaxNumberOfMinSize()const;
-				int getMaxNumberOfScalingGroups()const;
-				int getMaxNumberOfScalingConfigurations()const;
-				int getMaxNumberOfDBInstances()const;
-				int getMaxNumberOfMaxSize()const;
-
-			protected:
-				void parse(const std::string &payload);
-			private:
-				int maxNumberOfScalingRules_;
-				int maxNumberOfScalingInstances_;
-				int maxNumberOfScheduledTasks_;
-				int maxNumberOfLoadBalancers_;
-				int maxNumberOfMinSize_;
-				int maxNumberOfScalingGroups_;
-				int maxNumberOfScalingConfigurations_;
-				int maxNumberOfDBInstances_;
-				int maxNumberOfMaxSize_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEACCOUNTATTRIBUTESRESULT_H_

ess/include/alibabacloud/ess/model/DescribeScalingGroupsResult.h

@@ -52,8 +52,10 @@ namespace AlibabaCloud
 					std::vector<std::string> removalPolicies;
 					std::string creationTime;
 					int totalCapacity;
+					std::string multiAZPolicy;
 					std::string regionId;
 					std::vector<std::string> dBInstanceIds;
+					int protectedCapacity;
 					int standbyCapacity;
 				};
 

ess/include/alibabacloud/ess/model/RebalanceInstancesRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBEACCOUNTATTRIBUTESREQUEST_H_
-#define ALIBABACLOUD_ESS_MODEL_DESCRIBEACCOUNTATTRIBUTESREQUEST_H_
+#ifndef ALIBABACLOUD_ESS_MODEL_REBALANCEINSTANCESREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_REBALANCEINSTANCESREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,22 +28,31 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_ESS_EXPORT DescribeAccountAttributesRequest : public RpcServiceRequest
+			class ALIBABACLOUD_ESS_EXPORT RebalanceInstancesRequest : public RpcServiceRequest
 			{
 
 			public:
-				DescribeAccountAttributesRequest();
-				~DescribeAccountAttributesRequest();
+				RebalanceInstancesRequest();
+				~RebalanceInstancesRequest();
 
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
 
             private:
+				long resourceOwnerId_;
 				std::string resourceOwnerAccount_;
+				std::string scalingGroupId_;
+				std::string ownerAccount_;
 				long ownerId_;
 				std::string accessKeyId_;
 
@@ -51,4 +60,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEACCOUNTATTRIBUTESREQUEST_H_
+#endif // !ALIBABACLOUD_ESS_MODEL_REBALANCEINSTANCESREQUEST_H_

ess/include/alibabacloud/ess/model/RebalanceInstancesResult.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_ESS_MODEL_REBALANCEINSTANCESRESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_REBALANCEINSTANCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ess/EssExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT RebalanceInstancesResult : public ServiceResult
+			{
+			public:
+
+
+				RebalanceInstancesResult();
+				explicit RebalanceInstancesResult(const std::string &payload);
+				~RebalanceInstancesResult();
+				std::string getScalingActivityId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string scalingActivityId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_REBALANCEINSTANCESRESULT_H_

ess/include/alibabacloud/ess/model/SetInstancesProtectionRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ESS_MODEL_SETINSTANCESPROTECTIONREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_SETINSTANCESPROTECTIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ess/EssExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT SetInstancesProtectionRequest : public RpcServiceRequest
+			{
+
+			public:
+				SetInstancesProtectionRequest();
+				~SetInstancesProtectionRequest();
+
+				std::vector<std::string> getInstanceId()const;
+				void setInstanceId(const std::vector<std::string>& instanceId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				bool getProtectedFromScaleIn()const;
+				void setProtectedFromScaleIn(bool protectedFromScaleIn);
+
+            private:
+				std::vector<std::string> instanceId_;
+				std::string resourceOwnerAccount_;
+				std::string scalingGroupId_;
+				long ownerId_;
+				std::string accessKeyId_;
+				bool protectedFromScaleIn_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_SETINSTANCESPROTECTIONREQUEST_H_

ess/include/alibabacloud/ess/model/SetInstancesProtectionResult.h

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

ess/src/EssClient.cc

@@ -86,7 +86,7 @@ EssClient::AttachInstancesOutcomeCallable EssClient::attachInstancesCallable(con
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DescribeScalingGroupsOutcome EssClient::describeScalingGroups(const DescribeScalingGroupsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -122,7 +122,7 @@ EssClient::DescribeScalingGroupsOutcomeCallable EssClient::describeScalingGroups
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::EnterStandbyOutcome EssClient::enterStandby(const EnterStandbyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -158,7 +158,7 @@ EssClient::EnterStandbyOutcomeCallable EssClient::enterStandbyCallable(const Ent
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DescribeScalingActivitiesOutcome EssClient::describeScalingActivities(const DescribeScalingActivitiesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -194,7 +194,7 @@ EssClient::DescribeScalingActivitiesOutcomeCallable EssClient::describeScalingAc
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::ExitStandbyOutcome EssClient::exitStandby(const ExitStandbyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -230,7 +230,7 @@ EssClient::ExitStandbyOutcomeCallable EssClient::exitStandbyCallable(const ExitS
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DescribeNotificationConfigurationsOutcome EssClient::describeNotificationConfigurations(const DescribeNotificationConfigurationsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -266,7 +266,7 @@ EssClient::DescribeNotificationConfigurationsOutcomeCallable EssClient::describe
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DescribeScalingRulesOutcome EssClient::describeScalingRules(const DescribeScalingRulesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -302,7 +302,7 @@ EssClient::DescribeScalingRulesOutcomeCallable EssClient::describeScalingRulesCa
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::ModifyScalingGroupOutcome EssClient::modifyScalingGroup(const ModifyScalingGroupRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -338,7 +338,7 @@ EssClient::ModifyScalingGroupOutcomeCallable EssClient::modifyScalingGroupCallab
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::EnableScalingGroupOutcome EssClient::enableScalingGroup(const EnableScalingGroupRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -374,7 +374,7 @@ EssClient::EnableScalingGroupOutcomeCallable EssClient::enableScalingGroupCallab
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DeactivateScalingConfigurationOutcome EssClient::deactivateScalingConfiguration(const DeactivateScalingConfigurationRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -410,7 +410,43 @@ EssClient::DeactivateScalingConfigurationOutcomeCallable EssClient::deactivateSc
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
+EssClient::RebalanceInstancesOutcome EssClient::rebalanceInstances(const RebalanceInstancesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RebalanceInstancesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RebalanceInstancesOutcome(RebalanceInstancesResult(outcome.result()));
+	else
+		return RebalanceInstancesOutcome(outcome.error());
+}
+
+void EssClient::rebalanceInstancesAsync(const RebalanceInstancesRequest& request, const RebalanceInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, rebalanceInstances(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::RebalanceInstancesOutcomeCallable EssClient::rebalanceInstancesCallable(const RebalanceInstancesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RebalanceInstancesOutcome()>>(
+			[this, request]()
+			{
+			return this->rebalanceInstances(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::CreateNotificationConfigurationOutcome EssClient::createNotificationConfiguration(const CreateNotificationConfigurationRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -446,7 +482,7 @@ EssClient::CreateNotificationConfigurationOutcomeCallable EssClient::createNotif
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::VerifyAuthenticationOutcome EssClient::verifyAuthentication(const VerifyAuthenticationRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -482,7 +518,7 @@ EssClient::VerifyAuthenticationOutcomeCallable EssClient::verifyAuthenticationCa
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::CreateScheduledTaskOutcome EssClient::createScheduledTask(const CreateScheduledTaskRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -518,7 +554,7 @@ EssClient::CreateScheduledTaskOutcomeCallable EssClient::createScheduledTaskCall
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DeleteScheduledTaskOutcome EssClient::deleteScheduledTask(const DeleteScheduledTaskRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -554,7 +590,7 @@ EssClient::DeleteScheduledTaskOutcomeCallable EssClient::deleteScheduledTaskCall
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::ModifyNotificationConfigurationOutcome EssClient::modifyNotificationConfiguration(const ModifyNotificationConfigurationRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -590,7 +626,7 @@ EssClient::ModifyNotificationConfigurationOutcomeCallable EssClient::modifyNotif
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::CreateScalingRuleOutcome EssClient::createScalingRule(const CreateScalingRuleRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -626,7 +662,7 @@ EssClient::CreateScalingRuleOutcomeCallable EssClient::createScalingRuleCallable
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DescribeScalingConfigurationsOutcome EssClient::describeScalingConfigurations(const DescribeScalingConfigurationsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -662,7 +698,7 @@ EssClient::DescribeScalingConfigurationsOutcomeCallable EssClient::describeScali
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::ModifyScheduledTaskOutcome EssClient::modifyScheduledTask(const ModifyScheduledTaskRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -698,7 +734,7 @@ EssClient::ModifyScheduledTaskOutcomeCallable EssClient::modifyScheduledTaskCall
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::RemoveInstancesOutcome EssClient::removeInstances(const RemoveInstancesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -734,7 +770,7 @@ EssClient::RemoveInstancesOutcomeCallable EssClient::removeInstancesCallable(con
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DescribeNotificationTypesOutcome EssClient::describeNotificationTypes(const DescribeNotificationTypesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -770,7 +806,7 @@ EssClient::DescribeNotificationTypesOutcomeCallable EssClient::describeNotificat
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::ExecuteScalingRuleOutcome EssClient::executeScalingRule(const ExecuteScalingRuleRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -806,7 +842,7 @@ EssClient::ExecuteScalingRuleOutcomeCallable EssClient::executeScalingRuleCallab
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DeleteScalingGroupOutcome EssClient::deleteScalingGroup(const DeleteScalingGroupRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -842,7 +878,7 @@ EssClient::DeleteScalingGroupOutcomeCallable EssClient::deleteScalingGroupCallab
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DescribeScalingInstancesOutcome EssClient::describeScalingInstances(const DescribeScalingInstancesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -878,7 +914,7 @@ EssClient::DescribeScalingInstancesOutcomeCallable EssClient::describeScalingIns
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::CreateScalingConfigurationOutcome EssClient::createScalingConfiguration(const CreateScalingConfigurationRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -914,7 +950,7 @@ EssClient::CreateScalingConfigurationOutcomeCallable EssClient::createScalingCon
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DescribeCapacityHistoryOutcome EssClient::describeCapacityHistory(const DescribeCapacityHistoryRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -950,7 +986,7 @@ EssClient::DescribeCapacityHistoryOutcomeCallable EssClient::describeCapacityHis
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DescribeRegionsOutcome EssClient::describeRegions(const DescribeRegionsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -986,7 +1022,7 @@ EssClient::DescribeRegionsOutcomeCallable EssClient::describeRegionsCallable(con
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DescribeScheduledTasksOutcome EssClient::describeScheduledTasks(const DescribeScheduledTasksRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1022,7 +1058,43 @@ EssClient::DescribeScheduledTasksOutcomeCallable EssClient::describeScheduledTas
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
+EssClient::SetInstancesProtectionOutcome EssClient::setInstancesProtection(const SetInstancesProtectionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetInstancesProtectionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetInstancesProtectionOutcome(SetInstancesProtectionResult(outcome.result()));
+	else
+		return SetInstancesProtectionOutcome(outcome.error());
+}
+
+void EssClient::setInstancesProtectionAsync(const SetInstancesProtectionRequest& request, const SetInstancesProtectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setInstancesProtection(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::SetInstancesProtectionOutcomeCallable EssClient::setInstancesProtectionCallable(const SetInstancesProtectionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetInstancesProtectionOutcome()>>(
+			[this, request]()
+			{
+			return this->setInstancesProtection(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::DeleteNotificationConfigurationOutcome EssClient::deleteNotificationConfiguration(const DeleteNotificationConfigurationRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1058,43 +1130,7 @@ EssClient::DeleteNotificationConfigurationOutcomeCallable EssClient::deleteNotif
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
-EssClient::DescribeAccountAttributesOutcome EssClient::describeAccountAttributes(const DescribeAccountAttributesRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DescribeAccountAttributesOutcome(endpointOutcome.error());
 
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DescribeAccountAttributesOutcome(DescribeAccountAttributesResult(outcome.result()));
-	else
-		return DescribeAccountAttributesOutcome(outcome.error());
-}
-
-void EssClient::describeAccountAttributesAsync(const DescribeAccountAttributesRequest& request, const DescribeAccountAttributesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, describeAccountAttributes(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-EssClient::DescribeAccountAttributesOutcomeCallable EssClient::describeAccountAttributesCallable(const DescribeAccountAttributesRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DescribeAccountAttributesOutcome()>>(
-			[this, request]()
-			{
-			return this->describeAccountAttributes(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 EssClient::DetachInstancesOutcome EssClient::detachInstances(const DetachInstancesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1130,7 +1166,7 @@ EssClient::DetachInstancesOutcomeCallable EssClient::detachInstancesCallable(con
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DescribeLimitationOutcome EssClient::describeLimitation(const DescribeLimitationRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1166,7 +1202,7 @@ EssClient::DescribeLimitationOutcomeCallable EssClient::describeLimitationCallab
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DescribeScalingActivityDetailOutcome EssClient::describeScalingActivityDetail(const DescribeScalingActivityDetailRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1202,7 +1238,7 @@ EssClient::DescribeScalingActivityDetailOutcomeCallable EssClient::describeScali
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DescribeAlertConfigOutcome EssClient::describeAlertConfig(const DescribeAlertConfigRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1238,7 +1274,7 @@ EssClient::DescribeAlertConfigOutcomeCallable EssClient::describeAlertConfigCall
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::CreateScalingGroupOutcome EssClient::createScalingGroup(const CreateScalingGroupRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1274,7 +1310,7 @@ EssClient::CreateScalingGroupOutcomeCallable EssClient::createScalingGroupCallab
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DeleteScalingConfigurationOutcome EssClient::deleteScalingConfiguration(const DeleteScalingConfigurationRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1310,7 +1346,7 @@ EssClient::DeleteScalingConfigurationOutcomeCallable EssClient::deleteScalingCon
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DisableScalingGroupOutcome EssClient::disableScalingGroup(const DisableScalingGroupRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1346,7 +1382,7 @@ EssClient::DisableScalingGroupOutcomeCallable EssClient::disableScalingGroupCall
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::ModifyScalingRuleOutcome EssClient::modifyScalingRule(const ModifyScalingRuleRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1382,7 +1418,7 @@ EssClient::ModifyScalingRuleOutcomeCallable EssClient::modifyScalingRuleCallable
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DeleteScalingRuleOutcome EssClient::deleteScalingRule(const DeleteScalingRuleRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1418,7 +1454,7 @@ EssClient::DeleteScalingRuleOutcomeCallable EssClient::deleteScalingRuleCallable
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::VerifyUserOutcome EssClient::verifyUser(const VerifyUserRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1454,7 +1490,7 @@ EssClient::VerifyUserOutcomeCallable EssClient::verifyUserCallable(const VerifyU
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::ModifyAlertConfigOutcome EssClient::modifyAlertConfig(const ModifyAlertConfigRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1490,4 +1526,4 @@ EssClient::ModifyAlertConfigOutcomeCallable EssClient::modifyAlertConfigCallable
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+