ESS SDK Auto Released By wujin.lhr,Version：1.17.3

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

CHANGELOG

@@ -1,3 +1,6 @@
+2018-06-13 Version: 1.17.3
+1, Add lifecycleHook.
+
 2018-06-08 Version: 1.17.2
 1, Add scdn interface，support scdn.
 

VERSION

@@ -1 +1 @@
-1.17.2
+1.17.3

ess/CMakeLists.txt

@@ -33,6 +33,8 @@ set(ess_public_header_model
 	include/alibabacloud/ess/model/ExitStandbyResult.h
 	include/alibabacloud/ess/model/DescribeNotificationConfigurationsRequest.h
 	include/alibabacloud/ess/model/DescribeNotificationConfigurationsResult.h
+	include/alibabacloud/ess/model/ModifyLifecycleHookRequest.h
+	include/alibabacloud/ess/model/ModifyLifecycleHookResult.h
 	include/alibabacloud/ess/model/DescribeScalingRulesRequest.h
 	include/alibabacloud/ess/model/DescribeScalingRulesResult.h
 	include/alibabacloud/ess/model/ModifyScalingGroupRequest.h
@@ -59,6 +61,8 @@ set(ess_public_header_model
 	include/alibabacloud/ess/model/DescribeScalingConfigurationsResult.h
 	include/alibabacloud/ess/model/ModifyScheduledTaskRequest.h
 	include/alibabacloud/ess/model/ModifyScheduledTaskResult.h
+	include/alibabacloud/ess/model/RecordLifecycleActionHeartbeatRequest.h
+	include/alibabacloud/ess/model/RecordLifecycleActionHeartbeatResult.h
 	include/alibabacloud/ess/model/RemoveInstancesRequest.h
 	include/alibabacloud/ess/model/RemoveInstancesResult.h
 	include/alibabacloud/ess/model/DescribeNotificationTypesRequest.h
@@ -77,10 +81,18 @@ 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/DeleteLifecycleHookRequest.h
+	include/alibabacloud/ess/model/DeleteLifecycleHookResult.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/CompleteLifecycleActionRequest.h
+	include/alibabacloud/ess/model/CompleteLifecycleActionResult.h
+	include/alibabacloud/ess/model/DescribeLifecycleHooksRequest.h
+	include/alibabacloud/ess/model/DescribeLifecycleHooksResult.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
@@ -99,6 +111,8 @@ set(ess_public_header_model
 	include/alibabacloud/ess/model/ModifyScalingRuleResult.h
 	include/alibabacloud/ess/model/DeleteScalingRuleRequest.h
 	include/alibabacloud/ess/model/DeleteScalingRuleResult.h
+	include/alibabacloud/ess/model/CreateLifecycleHookRequest.h
+	include/alibabacloud/ess/model/CreateLifecycleHookResult.h
 	include/alibabacloud/ess/model/VerifyUserRequest.h
 	include/alibabacloud/ess/model/VerifyUserResult.h
 	include/alibabacloud/ess/model/ModifyAlertConfigRequest.h
@@ -118,6 +132,8 @@ set(ess_src
 	src/model/ExitStandbyResult.cc
 	src/model/DescribeNotificationConfigurationsRequest.cc
 	src/model/DescribeNotificationConfigurationsResult.cc
+	src/model/ModifyLifecycleHookRequest.cc
+	src/model/ModifyLifecycleHookResult.cc
 	src/model/DescribeScalingRulesRequest.cc
 	src/model/DescribeScalingRulesResult.cc
 	src/model/ModifyScalingGroupRequest.cc
@@ -144,6 +160,8 @@ set(ess_src
 	src/model/DescribeScalingConfigurationsResult.cc
 	src/model/ModifyScheduledTaskRequest.cc
 	src/model/ModifyScheduledTaskResult.cc
+	src/model/RecordLifecycleActionHeartbeatRequest.cc
+	src/model/RecordLifecycleActionHeartbeatResult.cc
 	src/model/RemoveInstancesRequest.cc
 	src/model/RemoveInstancesResult.cc
 	src/model/DescribeNotificationTypesRequest.cc
@@ -162,10 +180,18 @@ set(ess_src
 	src/model/DescribeRegionsResult.cc
 	src/model/DescribeScheduledTasksRequest.cc
 	src/model/DescribeScheduledTasksResult.cc
+	src/model/DeleteLifecycleHookRequest.cc
+	src/model/DeleteLifecycleHookResult.cc
 	src/model/SetInstancesProtectionRequest.cc
 	src/model/SetInstancesProtectionResult.cc
 	src/model/DeleteNotificationConfigurationRequest.cc
 	src/model/DeleteNotificationConfigurationResult.cc
+	src/model/CompleteLifecycleActionRequest.cc
+	src/model/CompleteLifecycleActionResult.cc
+	src/model/DescribeLifecycleHooksRequest.cc
+	src/model/DescribeLifecycleHooksResult.cc
+	src/model/DescribeAccountAttributesRequest.cc
+	src/model/DescribeAccountAttributesResult.cc
 	src/model/DetachInstancesRequest.cc
 	src/model/DetachInstancesResult.cc
 	src/model/DescribeLimitationRequest.cc
@@ -184,6 +210,8 @@ set(ess_src
 	src/model/ModifyScalingRuleResult.cc
 	src/model/DeleteScalingRuleRequest.cc
 	src/model/DeleteScalingRuleResult.cc
+	src/model/CreateLifecycleHookRequest.cc
+	src/model/CreateLifecycleHookResult.cc
 	src/model/VerifyUserRequest.cc
 	src/model/VerifyUserResult.cc
 	src/model/ModifyAlertConfigRequest.cc

ess/include/alibabacloud/ess/EssClient.h

@@ -22,88 +22,102 @@
 #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/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"
+#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/ModifyLifecycleHookRequest.h"
+#include "model/ModifyLifecycleHookResult.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/RecordLifecycleActionHeartbeatRequest.h"
+#include "model/RecordLifecycleActionHeartbeatResult.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/DeleteLifecycleHookRequest.h"
+#include "model/DeleteLifecycleHookResult.h"
+#include "model/SetInstancesProtectionRequest.h"
+#include "model/SetInstancesProtectionResult.h"
+#include "model/DeleteNotificationConfigurationRequest.h"
+#include "model/DeleteNotificationConfigurationResult.h"
+#include "model/CompleteLifecycleActionRequest.h"
+#include "model/CompleteLifecycleActionResult.h"
+#include "model/DescribeLifecycleHooksRequest.h"
+#include "model/DescribeLifecycleHooksResult.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/CreateLifecycleHookRequest.h"
+#include "model/CreateLifecycleHookResult.h"
+#include "model/VerifyUserRequest.h"
+#include "model/VerifyUserResult.h"
+#include "model/ModifyAlertConfigRequest.h"
+#include "model/ModifyAlertConfigResult.h"
 
 
 namespace AlibabaCloud
@@ -115,127 +129,148 @@ 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::ModifyLifecycleHookResult> ModifyLifecycleHookOutcome;
+			typedef std::future<ModifyLifecycleHookOutcome> ModifyLifecycleHookOutcomeCallable;
+			typedef std::function<void(const EssClient*, const Model::ModifyLifecycleHookRequest&, const ModifyLifecycleHookOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyLifecycleHookAsyncHandler;
 			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 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::RecordLifecycleActionHeartbeatResult> RecordLifecycleActionHeartbeatOutcome;
+			typedef std::future<RecordLifecycleActionHeartbeatOutcome> RecordLifecycleActionHeartbeatOutcomeCallable;
+			typedef std::function<void(const EssClient*, const Model::RecordLifecycleActionHeartbeatRequest&, const RecordLifecycleActionHeartbeatOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecordLifecycleActionHeartbeatAsyncHandler;
 			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::DeleteLifecycleHookResult> DeleteLifecycleHookOutcome;
+			typedef std::future<DeleteLifecycleHookOutcome> DeleteLifecycleHookOutcomeCallable;
+			typedef std::function<void(const EssClient*, const Model::DeleteLifecycleHookRequest&, const DeleteLifecycleHookOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLifecycleHookAsyncHandler;
 			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 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 std::function<void(const EssClient*, const Model::DeleteNotificationConfigurationRequest&, const DeleteNotificationConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteNotificationConfigurationAsyncHandler;
+			typedef Outcome<Error, Model::CompleteLifecycleActionResult> CompleteLifecycleActionOutcome;
+			typedef std::future<CompleteLifecycleActionOutcome> CompleteLifecycleActionOutcomeCallable;
+			typedef std::function<void(const EssClient*, const Model::CompleteLifecycleActionRequest&, const CompleteLifecycleActionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CompleteLifecycleActionAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLifecycleHooksResult> DescribeLifecycleHooksOutcome;
+			typedef std::future<DescribeLifecycleHooksOutcome> DescribeLifecycleHooksOutcomeCallable;
+			typedef std::function<void(const EssClient*, const Model::DescribeLifecycleHooksRequest&, const DescribeLifecycleHooksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLifecycleHooksAsyncHandler;
+			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 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::CreateLifecycleHookResult> CreateLifecycleHookOutcome;
+			typedef std::future<CreateLifecycleHookOutcome> CreateLifecycleHookOutcomeCallable;
+			typedef std::function<void(const EssClient*, const Model::CreateLifecycleHookRequest&, const CreateLifecycleHookOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLifecycleHookAsyncHandler;
 			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);
@@ -243,127 +278,148 @@ 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;
+			ModifyLifecycleHookOutcome modifyLifecycleHook(const Model::ModifyLifecycleHookRequest &request)const;
+			void modifyLifecycleHookAsync(const Model::ModifyLifecycleHookRequest& request, const ModifyLifecycleHookAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyLifecycleHookOutcomeCallable modifyLifecycleHookCallable(const Model::ModifyLifecycleHookRequest& 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;
+			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;
+			RecordLifecycleActionHeartbeatOutcome recordLifecycleActionHeartbeat(const Model::RecordLifecycleActionHeartbeatRequest &request)const;
+			void recordLifecycleActionHeartbeatAsync(const Model::RecordLifecycleActionHeartbeatRequest& request, const RecordLifecycleActionHeartbeatAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RecordLifecycleActionHeartbeatOutcomeCallable recordLifecycleActionHeartbeatCallable(const Model::RecordLifecycleActionHeartbeatRequest& 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;
+			DeleteLifecycleHookOutcome deleteLifecycleHook(const Model::DeleteLifecycleHookRequest &request)const;
+			void deleteLifecycleHookAsync(const Model::DeleteLifecycleHookRequest& request, const DeleteLifecycleHookAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteLifecycleHookOutcomeCallable deleteLifecycleHookCallable(const Model::DeleteLifecycleHookRequest& 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;
+			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;
+			DeleteNotificationConfigurationOutcomeCallable deleteNotificationConfigurationCallable(const Model::DeleteNotificationConfigurationRequest& request) const;
+			CompleteLifecycleActionOutcome completeLifecycleAction(const Model::CompleteLifecycleActionRequest &request)const;
+			void completeLifecycleActionAsync(const Model::CompleteLifecycleActionRequest& request, const CompleteLifecycleActionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CompleteLifecycleActionOutcomeCallable completeLifecycleActionCallable(const Model::CompleteLifecycleActionRequest& request) const;
+			DescribeLifecycleHooksOutcome describeLifecycleHooks(const Model::DescribeLifecycleHooksRequest &request)const;
+			void describeLifecycleHooksAsync(const Model::DescribeLifecycleHooksRequest& request, const DescribeLifecycleHooksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLifecycleHooksOutcomeCallable describeLifecycleHooksCallable(const Model::DescribeLifecycleHooksRequest& 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;
 			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;
+			CreateLifecycleHookOutcome createLifecycleHook(const Model::CreateLifecycleHookRequest &request)const;
+			void createLifecycleHookAsync(const Model::CreateLifecycleHookRequest& request, const CreateLifecycleHookAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateLifecycleHookOutcomeCallable createLifecycleHookCallable(const Model::CreateLifecycleHookRequest& 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/AttachInstancesRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ESS_MODEL_COMPLETELIFECYCLEACTIONREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_COMPLETELIFECYCLEACTIONREQUEST_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 CompleteLifecycleActionRequest : public RpcServiceRequest
+			{
+
+			public:
+				CompleteLifecycleActionRequest();
+				~CompleteLifecycleActionRequest();
+
+				std::string getLifecycleActionToken()const;
+				void setLifecycleActionToken(const std::string& lifecycleActionToken);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getLifecycleHookId()const;
+				void setLifecycleHookId(const std::string& lifecycleHookId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getLifecycleActionResult()const;
+				void setLifecycleActionResult(const std::string& lifecycleActionResult);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string lifecycleActionToken_;
+				std::string resourceOwnerAccount_;
+				std::string lifecycleHookId_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string lifecycleActionResult_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_COMPLETELIFECYCLEACTIONREQUEST_H_

ess/include/alibabacloud/ess/model/CompleteLifecycleActionResult.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_COMPLETELIFECYCLEACTIONRESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_COMPLETELIFECYCLEACTIONRESULT_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 CompleteLifecycleActionResult : public ServiceResult
+			{
+			public:
+
+
+				CompleteLifecycleActionResult();
+				explicit CompleteLifecycleActionResult(const std::string &payload);
+				~CompleteLifecycleActionResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_COMPLETELIFECYCLEACTIONRESULT_H_

ess/include/alibabacloud/ess/model/CreateLifecycleHookRequest.h

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ESS_MODEL_CREATELIFECYCLEHOOKREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_CREATELIFECYCLEHOOKREQUEST_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 CreateLifecycleHookRequest : public RpcServiceRequest
+			{
+				struct LifecycleHook
+				{
+					std::string lifecycleHookName;
+					std::string lifecycleTransition;
+					std::string defaultResult;
+					int heartbeatTimeout;
+					std::string notificationMetadata;
+					std::string notificationArn;
+				};
+
+			public:
+				CreateLifecycleHookRequest();
+				~CreateLifecycleHookRequest();
+
+				std::string getDefaultResult()const;
+				void setDefaultResult(const std::string& defaultResult);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				int getHeartbeatTimeout()const;
+				void setHeartbeatTimeout(int heartbeatTimeout);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getNotificationMetadata()const;
+				void setNotificationMetadata(const std::string& notificationMetadata);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getLifecycleTransition()const;
+				void setLifecycleTransition(const std::string& lifecycleTransition);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getLifecycleHookName()const;
+				void setLifecycleHookName(const std::string& lifecycleHookName);
+				std::string getNotificationArn()const;
+				void setNotificationArn(const std::string& notificationArn);
+				std::vector<LifecycleHook> getLifecycleHook()const;
+				void setLifecycleHook(const std::vector<LifecycleHook>& lifecycleHook);
+
+            private:
+				std::string defaultResult_;
+				std::string resourceOwnerAccount_;
+				int heartbeatTimeout_;
+				std::string scalingGroupId_;
+				std::string ownerAccount_;
+				std::string notificationMetadata_;
+				long ownerId_;
+				std::string lifecycleTransition_;
+				std::string accessKeyId_;
+				std::string lifecycleHookName_;
+				std::string notificationArn_;
+				std::vector<LifecycleHook> lifecycleHook_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_CREATELIFECYCLEHOOKREQUEST_H_

ess/include/alibabacloud/ess/model/CreateLifecycleHookResult.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_CREATELIFECYCLEHOOKRESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_CREATELIFECYCLEHOOKRESULT_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 CreateLifecycleHookResult : public ServiceResult
+			{
+			public:
+
+
+				CreateLifecycleHookResult();
+				explicit CreateLifecycleHookResult(const std::string &payload);
+				~CreateLifecycleHookResult();
+				std::string getLifecycleHookId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string lifecycleHookId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_CREATELIFECYCLEHOOKRESULT_H_

ess/include/alibabacloud/ess/model/CreateNotificationConfigurationRequest.h

@@ -182,4 +182,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_ESS_MODEL_CREATESCALINGCONFIGURATIONREQUEST_H_
+#endif // !ALIBABACLOUD_ESS_MODEL_CREATESCALINGCONFIGURATIONREQUEST_H_

ess/include/alibabacloud/ess/model/CreateScalingConfigurationResult.h

@@ -30,6 +30,15 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_ESS_EXPORT CreateScalingGroupRequest : public RpcServiceRequest
 			{
+				struct LifecycleHook
+				{
+					std::string lifecycleHookName;
+					std::string lifecycleTransition;
+					std::string defaultResult;
+					int heartbeatTimeout;
+					std::string notificationMetadata;
+					std::string notificationArn;
+				};
 
 			public:
 				CreateScalingGroupRequest();
@@ -41,6 +50,8 @@ namespace AlibabaCloud
 				void setDBInstanceIds(const std::string& dBInstanceIds);
 				std::string getLoadBalancerIds()const;
 				void setLoadBalancerIds(const std::string& loadBalancerIds);
+				std::string getHealthCheckType()const;
+				void setHealthCheckType(const std::string& healthCheckType);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getScalingGroupName()const;
@@ -61,6 +72,8 @@ namespace AlibabaCloud
 				void setRegionId(const std::string& regionId);
 				int getMaxSize()const;
 				void setMaxSize(int maxSize);
+				std::vector<LifecycleHook> getLifecycleHook()const;
+				void setLifecycleHook(const std::vector<LifecycleHook>& lifecycleHook);
 				int getDefaultCooldown()const;
 				void setDefaultCooldown(int defaultCooldown);
 				std::string getRemovalPolicy1()const;
@@ -72,6 +85,7 @@ namespace AlibabaCloud
 				std::string multiAZPolicy_;
 				std::string dBInstanceIds_;
 				std::string loadBalancerIds_;
+				std::string healthCheckType_;
 				std::string resourceOwnerAccount_;
 				std::string scalingGroupName_;
 				std::vector<std::string> vSwitchIds_;
@@ -82,6 +96,7 @@ namespace AlibabaCloud
 				std::string vSwitchId_;
 				std::string regionId_;
 				int maxSize_;
+				std::vector<LifecycleHook> lifecycleHook_;
 				int defaultCooldown_;
 				std::string removalPolicy1_;
 				std::string removalPolicy2_;

ess/include/alibabacloud/ess/model/CreateScalingGroupResult.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ESS_MODEL_DELETELIFECYCLEHOOKREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DELETELIFECYCLEHOOKREQUEST_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 DeleteLifecycleHookRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteLifecycleHookRequest();
+				~DeleteLifecycleHookRequest();
+
+				std::string getLifecycleHookName()const;
+				void setLifecycleHookName(const std::string& lifecycleHookName);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getLifecycleHookId()const;
+				void setLifecycleHookId(const std::string& lifecycleHookId);
+				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:
+				std::string lifecycleHookName_;
+				std::string resourceOwnerAccount_;
+				std::string lifecycleHookId_;
+				std::string scalingGroupId_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DELETELIFECYCLEHOOKREQUEST_H_

ess/include/alibabacloud/ess/model/DeleteLifecycleHookResult.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_DELETELIFECYCLEHOOKRESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_DELETELIFECYCLEHOOKRESULT_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 DeleteLifecycleHookResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteLifecycleHookResult();
+				explicit DeleteLifecycleHookResult(const std::string &payload);
+				~DeleteLifecycleHookResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DELETELIFECYCLEHOOKRESULT_H_

ess/include/alibabacloud/ess/model/DeleteNotificationConfigurationRequest.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_ESS_MODEL_DESCRIBEACCOUNTATTRIBUTESREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBEACCOUNTATTRIBUTESREQUEST_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 DescribeAccountAttributesRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeAccountAttributesRequest();
+				~DescribeAccountAttributesRequest();
+
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string resourceOwnerAccount_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEACCOUNTATTRIBUTESREQUEST_H_

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

@@ -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.
+ */
+
+#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/DescribeAlertConfigRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBELIFECYCLEHOOKSREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBELIFECYCLEHOOKSREQUEST_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 DescribeLifecycleHooksRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeLifecycleHooksRequest();
+				~DescribeLifecycleHooksRequest();
+
+				std::string getLifecycleHookName()const;
+				void setLifecycleHookName(const std::string& lifecycleHookName);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				std::vector<std::string> getLifecycleHookId()const;
+				void setLifecycleHookId(const std::vector<std::string>& lifecycleHookId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string lifecycleHookName_;
+				std::string resourceOwnerAccount_;
+				std::string scalingGroupId_;
+				std::vector<std::string> lifecycleHookId_;
+				std::string ownerAccount_;
+				int pageSize_;
+				long ownerId_;
+				int pageNumber_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBELIFECYCLEHOOKSREQUEST_H_

ess/include/alibabacloud/ess/model/DescribeLifecycleHooksResult.h

@@ -0,0 +1,68 @@
+/*
+ * 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_DESCRIBELIFECYCLEHOOKSRESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBELIFECYCLEHOOKSRESULT_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 DescribeLifecycleHooksResult : public ServiceResult
+			{
+			public:
+				struct LifecycleHook
+				{
+					std::string lifecycleHookName;
+					std::string notificationArn;
+					std::string scalingGroupId;
+					std::string lifecycleTransition;
+					int heartbeatTimeout;
+					std::string notificationMetadata;
+					std::string defaultResult;
+					std::string lifecycleHookId;
+				};
+
+
+				DescribeLifecycleHooksResult();
+				explicit DescribeLifecycleHooksResult(const std::string &payload);
+				~DescribeLifecycleHooksResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<LifecycleHook> getLifecycleHooks()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<LifecycleHook> lifecycleHooks_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBELIFECYCLEHOOKSRESULT_H_

ess/include/alibabacloud/ess/model/DescribeLimitationRequest.h

@@ -56,6 +56,7 @@ namespace AlibabaCloud
 					std::string regionId;
 					std::vector<std::string> dBInstanceIds;
 					int protectedCapacity;
+					std::string healthCheckType;
 					int standbyCapacity;
 				};
 

ess/include/alibabacloud/ess/model/DescribeScalingInstancesRequest.h

@@ -35,86 +35,29 @@ namespace AlibabaCloud
 				DetachInstancesRequest();
 				~DetachInstancesRequest();
 
-				std::string getInstanceId10()const;
-				void setInstanceId10(const std::string& instanceId10);
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
-				std::string getInstanceId12()const;
-				void setInstanceId12(const std::string& instanceId12);
-				std::string getInstanceId11()const;
-				void setInstanceId11(const std::string& instanceId11);
-				std::string getScalingGroupId()const;
-				void setScalingGroupId(const std::string& scalingGroupId);
-				std::string getAccessKeyId()const;
-				void setAccessKeyId(const std::string& accessKeyId);
-				std::string getInstanceId20()const;
-				void setInstanceId20(const std::string& instanceId20);
-				std::string getInstanceId1()const;
-				void setInstanceId1(const std::string& instanceId1);
-				std::string getInstanceId3()const;
-				void setInstanceId3(const std::string& instanceId3);
+				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 getInstanceId2()const;
-				void setInstanceId2(const std::string& instanceId2);
-				std::string getInstanceId5()const;
-				void setInstanceId5(const std::string& instanceId5);
-				std::string getInstanceId4()const;
-				void setInstanceId4(const std::string& instanceId4);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
-				std::string getInstanceId7()const;
-				void setInstanceId7(const std::string& instanceId7);
-				std::string getInstanceId6()const;
-				void setInstanceId6(const std::string& instanceId6);
-				std::string getInstanceId9()const;
-				void setInstanceId9(const std::string& instanceId9);
-				std::string getInstanceId8()const;
-				void setInstanceId8(const std::string& instanceId8);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
-				std::string getInstanceId18()const;
-				void setInstanceId18(const std::string& instanceId18);
-				std::string getInstanceId17()const;
-				void setInstanceId17(const std::string& instanceId17);
-				std::string getInstanceId19()const;
-				void setInstanceId19(const std::string& instanceId19);
-				std::string getInstanceId14()const;
-				void setInstanceId14(const std::string& instanceId14);
-				std::string getInstanceId13()const;
-				void setInstanceId13(const std::string& instanceId13);
-				std::string getInstanceId16()const;
-				void setInstanceId16(const std::string& instanceId16);
-				std::string getInstanceId15()const;
-				void setInstanceId15(const std::string& instanceId15);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
 
             private:
-				std::string instanceId10_;
 				long resourceOwnerId_;
-				std::string instanceId12_;
-				std::string instanceId11_;
-				std::string scalingGroupId_;
-				std::string accessKeyId_;
-				std::string instanceId20_;
-				std::string instanceId1_;
-				std::string instanceId3_;
+				std::vector<std::string> instanceId_;
 				std::string resourceOwnerAccount_;
-				std::string instanceId2_;
-				std::string instanceId5_;
-				std::string instanceId4_;
+				std::string scalingGroupId_;
 				std::string ownerAccount_;
-				std::string instanceId7_;
-				std::string instanceId6_;
-				std::string instanceId9_;
-				std::string instanceId8_;
 				long ownerId_;
-				std::string instanceId18_;
-				std::string instanceId17_;
-				std::string instanceId19_;
-				std::string instanceId14_;
-				std::string instanceId13_;
-				std::string instanceId16_;
-				std::string instanceId15_;
+				std::string accessKeyId_;
 
 			};
 		}

ess/include/alibabacloud/ess/model/DetachInstancesResult.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ESS_MODEL_MODIFYLIFECYCLEHOOKREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_MODIFYLIFECYCLEHOOKREQUEST_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 ModifyLifecycleHookRequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifyLifecycleHookRequest();
+				~ModifyLifecycleHookRequest();
+
+				std::string getDefaultResult()const;
+				void setDefaultResult(const std::string& defaultResult);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				int getHeartbeatTimeout()const;
+				void setHeartbeatTimeout(int heartbeatTimeout);
+				std::string getLifecycleHookId()const;
+				void setLifecycleHookId(const std::string& lifecycleHookId);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getNotificationMetadata()const;
+				void setNotificationMetadata(const std::string& notificationMetadata);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getLifecycleTransition()const;
+				void setLifecycleTransition(const std::string& lifecycleTransition);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getLifecycleHookName()const;
+				void setLifecycleHookName(const std::string& lifecycleHookName);
+				std::string getNotificationArn()const;
+				void setNotificationArn(const std::string& notificationArn);
+
+            private:
+				std::string defaultResult_;
+				std::string resourceOwnerAccount_;
+				int heartbeatTimeout_;
+				std::string lifecycleHookId_;
+				std::string scalingGroupId_;
+				std::string ownerAccount_;
+				std::string notificationMetadata_;
+				long ownerId_;
+				std::string lifecycleTransition_;
+				std::string accessKeyId_;
+				std::string lifecycleHookName_;
+				std::string notificationArn_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_MODIFYLIFECYCLEHOOKREQUEST_H_

ess/include/alibabacloud/ess/model/ModifyLifecycleHookResult.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_MODIFYLIFECYCLEHOOKRESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_MODIFYLIFECYCLEHOOKRESULT_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 ModifyLifecycleHookResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyLifecycleHookResult();
+				explicit ModifyLifecycleHookResult(const std::string &payload);
+				~ModifyLifecycleHookResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_MODIFYLIFECYCLEHOOKRESULT_H_

ess/include/alibabacloud/ess/model/ModifyNotificationConfigurationRequest.h

@@ -37,6 +37,8 @@ namespace AlibabaCloud
 
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
+				std::string getHealthCheckType()const;
+				void setHealthCheckType(const std::string& healthCheckType);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getScalingGroupName()const;
@@ -64,6 +66,7 @@ namespace AlibabaCloud
 
             private:
 				long resourceOwnerId_;
+				std::string healthCheckType_;
 				std::string resourceOwnerAccount_;
 				std::string scalingGroupName_;
 				std::string scalingGroupId_;

ess/include/alibabacloud/ess/model/ModifyScalingGroupResult.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ESS_MODEL_RECORDLIFECYCLEACTIONHEARTBEATREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_RECORDLIFECYCLEACTIONHEARTBEATREQUEST_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 RecordLifecycleActionHeartbeatRequest : public RpcServiceRequest
+			{
+
+			public:
+				RecordLifecycleActionHeartbeatRequest();
+				~RecordLifecycleActionHeartbeatRequest();
+
+				std::string getLifecycleActionToken()const;
+				void setLifecycleActionToken(const std::string& lifecycleActionToken);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				int getHeartbeatTimeout()const;
+				void setHeartbeatTimeout(int heartbeatTimeout);
+				std::string getLifecycleHookId()const;
+				void setLifecycleHookId(const std::string& lifecycleHookId);
+				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:
+				std::string lifecycleActionToken_;
+				std::string resourceOwnerAccount_;
+				int heartbeatTimeout_;
+				std::string lifecycleHookId_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_RECORDLIFECYCLEACTIONHEARTBEATREQUEST_H_

ess/include/alibabacloud/ess/model/RecordLifecycleActionHeartbeatResult.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_RECORDLIFECYCLEACTIONHEARTBEATRESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_RECORDLIFECYCLEACTIONHEARTBEATRESULT_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 RecordLifecycleActionHeartbeatResult : public ServiceResult
+			{
+			public:
+
+
+				RecordLifecycleActionHeartbeatResult();
+				explicit RecordLifecycleActionHeartbeatResult(const std::string &payload);
+				~RecordLifecycleActionHeartbeatResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_RECORDLIFECYCLEACTIONHEARTBEATRESULT_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,43 @@ EssClient::DescribeNotificationConfigurationsOutcomeCallable EssClient::describe
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
+
+EssClient::ModifyLifecycleHookOutcome EssClient::modifyLifecycleHook(const ModifyLifecycleHookRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyLifecycleHookOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyLifecycleHookOutcome(ModifyLifecycleHookResult(outcome.result()));
+	else
+		return ModifyLifecycleHookOutcome(outcome.error());
+}
+
+void EssClient::modifyLifecycleHookAsync(const ModifyLifecycleHookRequest& request, const ModifyLifecycleHookAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyLifecycleHook(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::ModifyLifecycleHookOutcomeCallable EssClient::modifyLifecycleHookCallable(const ModifyLifecycleHookRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyLifecycleHookOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyLifecycleHook(request);
+			});
 
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::DescribeScalingRulesOutcome EssClient::describeScalingRules(const DescribeScalingRulesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -302,7 +338,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 +374,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 +410,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 +446,7 @@ 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();
@@ -446,7 +482,7 @@ EssClient::RebalanceInstancesOutcomeCallable EssClient::rebalanceInstancesCallab
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::CreateNotificationConfigurationOutcome EssClient::createNotificationConfiguration(const CreateNotificationConfigurationRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -482,7 +518,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();
@@ -518,7 +554,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();
@@ -554,7 +590,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();
@@ -590,7 +626,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();
@@ -626,7 +662,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();
@@ -662,7 +698,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();
@@ -698,7 +734,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();
@@ -734,7 +770,43 @@ EssClient::ModifyScheduledTaskOutcomeCallable EssClient::modifyScheduledTaskCall
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
+
+EssClient::RecordLifecycleActionHeartbeatOutcome EssClient::recordLifecycleActionHeartbeat(const RecordLifecycleActionHeartbeatRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RecordLifecycleActionHeartbeatOutcome(endpointOutcome.error());
 
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RecordLifecycleActionHeartbeatOutcome(RecordLifecycleActionHeartbeatResult(outcome.result()));
+	else
+		return RecordLifecycleActionHeartbeatOutcome(outcome.error());
+}
+
+void EssClient::recordLifecycleActionHeartbeatAsync(const RecordLifecycleActionHeartbeatRequest& request, const RecordLifecycleActionHeartbeatAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, recordLifecycleActionHeartbeat(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::RecordLifecycleActionHeartbeatOutcomeCallable EssClient::recordLifecycleActionHeartbeatCallable(const RecordLifecycleActionHeartbeatRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RecordLifecycleActionHeartbeatOutcome()>>(
+			[this, request]()
+			{
+			return this->recordLifecycleActionHeartbeat(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::RemoveInstancesOutcome EssClient::removeInstances(const RemoveInstancesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -770,7 +842,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();
@@ -806,7 +878,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();
@@ -842,7 +914,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();
@@ -878,7 +950,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();
@@ -914,7 +986,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();
@@ -950,7 +1022,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();
@@ -986,7 +1058,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();
@@ -1022,7 +1094,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();
@@ -1058,7 +1130,43 @@ EssClient::DescribeScheduledTasksOutcomeCallable EssClient::describeScheduledTas
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
+
+EssClient::DeleteLifecycleHookOutcome EssClient::deleteLifecycleHook(const DeleteLifecycleHookRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteLifecycleHookOutcome(endpointOutcome.error());
 
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteLifecycleHookOutcome(DeleteLifecycleHookResult(outcome.result()));
+	else
+		return DeleteLifecycleHookOutcome(outcome.error());
+}
+
+void EssClient::deleteLifecycleHookAsync(const DeleteLifecycleHookRequest& request, const DeleteLifecycleHookAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteLifecycleHook(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DeleteLifecycleHookOutcomeCallable EssClient::deleteLifecycleHookCallable(const DeleteLifecycleHookRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteLifecycleHookOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteLifecycleHook(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::SetInstancesProtectionOutcome EssClient::setInstancesProtection(const SetInstancesProtectionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1094,7 +1202,7 @@ EssClient::SetInstancesProtectionOutcomeCallable EssClient::setInstancesProtecti
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DeleteNotificationConfigurationOutcome EssClient::deleteNotificationConfiguration(const DeleteNotificationConfigurationRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1130,7 +1238,115 @@ EssClient::DeleteNotificationConfigurationOutcomeCallable EssClient::deleteNotif
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
+
+EssClient::CompleteLifecycleActionOutcome EssClient::completeLifecycleAction(const CompleteLifecycleActionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CompleteLifecycleActionOutcome(endpointOutcome.error());
 
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CompleteLifecycleActionOutcome(CompleteLifecycleActionResult(outcome.result()));
+	else
+		return CompleteLifecycleActionOutcome(outcome.error());
+}
+
+void EssClient::completeLifecycleActionAsync(const CompleteLifecycleActionRequest& request, const CompleteLifecycleActionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, completeLifecycleAction(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::CompleteLifecycleActionOutcomeCallable EssClient::completeLifecycleActionCallable(const CompleteLifecycleActionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CompleteLifecycleActionOutcome()>>(
+			[this, request]()
+			{
+			return this->completeLifecycleAction(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::DescribeLifecycleHooksOutcome EssClient::describeLifecycleHooks(const DescribeLifecycleHooksRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLifecycleHooksOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLifecycleHooksOutcome(DescribeLifecycleHooksResult(outcome.result()));
+	else
+		return DescribeLifecycleHooksOutcome(outcome.error());
+}
+
+void EssClient::describeLifecycleHooksAsync(const DescribeLifecycleHooksRequest& request, const DescribeLifecycleHooksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLifecycleHooks(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DescribeLifecycleHooksOutcomeCallable EssClient::describeLifecycleHooksCallable(const DescribeLifecycleHooksRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLifecycleHooksOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLifecycleHooks(request);
+			});
+
+	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();
@@ -1166,7 +1382,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();
@@ -1202,7 +1418,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();
@@ -1238,7 +1454,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();
@@ -1274,7 +1490,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();
@@ -1310,7 +1526,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();
@@ -1346,7 +1562,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();
@@ -1382,7 +1598,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();
@@ -1418,7 +1634,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();
@@ -1454,7 +1670,43 @@ EssClient::DeleteScalingRuleOutcomeCallable EssClient::deleteScalingRuleCallable
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
+
+EssClient::CreateLifecycleHookOutcome EssClient::createLifecycleHook(const CreateLifecycleHookRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateLifecycleHookOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateLifecycleHookOutcome(CreateLifecycleHookResult(outcome.result()));
+	else
+		return CreateLifecycleHookOutcome(outcome.error());
+}
+
+void EssClient::createLifecycleHookAsync(const CreateLifecycleHookRequest& request, const CreateLifecycleHookAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createLifecycleHook(request), context);
+	};
 
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::CreateLifecycleHookOutcomeCallable EssClient::createLifecycleHookCallable(const CreateLifecycleHookRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateLifecycleHookOutcome()>>(
+			[this, request]()
+			{
+			return this->createLifecycleHook(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::VerifyUserOutcome EssClient::verifyUser(const VerifyUserRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1490,7 +1742,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();
@@ -1526,4 +1778,4 @@ EssClient::ModifyAlertConfigOutcomeCallable EssClient::modifyAlertConfigCallable
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+

ess/src/model/AttachInstancesRequest.cc

@@ -0,0 +1,104 @@
+/*
+ * 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/ess/model/CompleteLifecycleActionRequest.h>
+
+using AlibabaCloud::Ess::Model::CompleteLifecycleActionRequest;
+
+CompleteLifecycleActionRequest::CompleteLifecycleActionRequest() :
+	RpcServiceRequest("ess", "2014-08-28", "CompleteLifecycleAction")
+{}
+
+CompleteLifecycleActionRequest::~CompleteLifecycleActionRequest()
+{}
+
+std::string CompleteLifecycleActionRequest::getLifecycleActionToken()const
+{
+	return lifecycleActionToken_;
+}
+
+void CompleteLifecycleActionRequest::setLifecycleActionToken(const std::string& lifecycleActionToken)
+{
+	lifecycleActionToken_ = lifecycleActionToken;
+	setParameter("LifecycleActionToken", lifecycleActionToken);
+}
+
+std::string CompleteLifecycleActionRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CompleteLifecycleActionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CompleteLifecycleActionRequest::getLifecycleHookId()const
+{
+	return lifecycleHookId_;
+}
+
+void CompleteLifecycleActionRequest::setLifecycleHookId(const std::string& lifecycleHookId)
+{
+	lifecycleHookId_ = lifecycleHookId;
+	setParameter("LifecycleHookId", lifecycleHookId);
+}
+
+std::string CompleteLifecycleActionRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CompleteLifecycleActionRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long CompleteLifecycleActionRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CompleteLifecycleActionRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CompleteLifecycleActionRequest::getLifecycleActionResult()const
+{
+	return lifecycleActionResult_;
+}
+
+void CompleteLifecycleActionRequest::setLifecycleActionResult(const std::string& lifecycleActionResult)
+{
+	lifecycleActionResult_ = lifecycleActionResult;
+	setParameter("LifecycleActionResult", lifecycleActionResult);
+}
+
+std::string CompleteLifecycleActionRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CompleteLifecycleActionRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

ess/src/model/CompleteLifecycleActionResult.cc

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

ess/src/model/CreateLifecycleHookRequest.cc

@@ -0,0 +1,169 @@
+/*
+ * 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/ess/model/CreateLifecycleHookRequest.h>
+
+using AlibabaCloud::Ess::Model::CreateLifecycleHookRequest;
+
+CreateLifecycleHookRequest::CreateLifecycleHookRequest() :
+	RpcServiceRequest("ess", "2014-08-28", "CreateLifecycleHook")
+{}
+
+CreateLifecycleHookRequest::~CreateLifecycleHookRequest()
+{}
+
+std::string CreateLifecycleHookRequest::getDefaultResult()const
+{
+	return defaultResult_;
+}
+
+void CreateLifecycleHookRequest::setDefaultResult(const std::string& defaultResult)
+{
+	defaultResult_ = defaultResult;
+	setParameter("DefaultResult", defaultResult);
+}
+
+std::string CreateLifecycleHookRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateLifecycleHookRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+int CreateLifecycleHookRequest::getHeartbeatTimeout()const
+{
+	return heartbeatTimeout_;
+}
+
+void CreateLifecycleHookRequest::setHeartbeatTimeout(int heartbeatTimeout)
+{
+	heartbeatTimeout_ = heartbeatTimeout;
+	setParameter("HeartbeatTimeout", std::to_string(heartbeatTimeout));
+}
+
+std::string CreateLifecycleHookRequest::getScalingGroupId()const
+{
+	return scalingGroupId_;
+}
+
+void CreateLifecycleHookRequest::setScalingGroupId(const std::string& scalingGroupId)
+{
+	scalingGroupId_ = scalingGroupId;
+	setParameter("ScalingGroupId", scalingGroupId);
+}
+
+std::string CreateLifecycleHookRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateLifecycleHookRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string CreateLifecycleHookRequest::getNotificationMetadata()const
+{
+	return notificationMetadata_;
+}
+
+void CreateLifecycleHookRequest::setNotificationMetadata(const std::string& notificationMetadata)
+{
+	notificationMetadata_ = notificationMetadata;
+	setParameter("NotificationMetadata", notificationMetadata);
+}
+
+long CreateLifecycleHookRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateLifecycleHookRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateLifecycleHookRequest::getLifecycleTransition()const
+{
+	return lifecycleTransition_;
+}
+
+void CreateLifecycleHookRequest::setLifecycleTransition(const std::string& lifecycleTransition)
+{
+	lifecycleTransition_ = lifecycleTransition;
+	setParameter("LifecycleTransition", lifecycleTransition);
+}
+
+std::string CreateLifecycleHookRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CreateLifecycleHookRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string CreateLifecycleHookRequest::getLifecycleHookName()const
+{
+	return lifecycleHookName_;
+}
+
+void CreateLifecycleHookRequest::setLifecycleHookName(const std::string& lifecycleHookName)
+{
+	lifecycleHookName_ = lifecycleHookName;
+	setParameter("LifecycleHookName", lifecycleHookName);
+}
+
+std::string CreateLifecycleHookRequest::getNotificationArn()const
+{
+	return notificationArn_;
+}
+
+void CreateLifecycleHookRequest::setNotificationArn(const std::string& notificationArn)
+{
+	notificationArn_ = notificationArn;
+	setParameter("NotificationArn", notificationArn);
+}
+
+std::vector<CreateLifecycleHookRequest::LifecycleHook> CreateLifecycleHookRequest::getLifecycleHook()const
+{
+	return lifecycleHook_;
+}
+
+void CreateLifecycleHookRequest::setLifecycleHook(const std::vector<LifecycleHook>& lifecycleHook)
+{
+	lifecycleHook_ = lifecycleHook;
+	int i = 0;
+	for(int i = 0; i!= lifecycleHook.size(); i++)	{
+		auto obj = lifecycleHook.at(i);
+		std::string str ="LifecycleHook."+ std::to_string(i);
+		setParameter(str + ".LifecycleHookName", obj.lifecycleHookName);
+		setParameter(str + ".LifecycleTransition", obj.lifecycleTransition);
+		setParameter(str + ".DefaultResult", obj.defaultResult);
+		setParameter(str + ".HeartbeatTimeout", std::to_string(obj.heartbeatTimeout));
+		setParameter(str + ".NotificationMetadata", obj.notificationMetadata);
+		setParameter(str + ".NotificationArn", obj.notificationArn);
+	}
+}
+

ess/src/model/CreateLifecycleHookResult.cc

@@ -0,0 +1,52 @@
+/*
+ * 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/ess/model/CreateLifecycleHookResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ess;
+using namespace AlibabaCloud::Ess::Model;
+
+CreateLifecycleHookResult::CreateLifecycleHookResult() :
+	ServiceResult()
+{}
+
+CreateLifecycleHookResult::CreateLifecycleHookResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateLifecycleHookResult::~CreateLifecycleHookResult()
+{}
+
+void CreateLifecycleHookResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	if(!value["LifecycleHookId"].isNull())
+		lifecycleHookId_ = value["LifecycleHookId"].asString();
+
+}
+
+std::string CreateLifecycleHookResult::getLifecycleHookId()const
+{
+	return lifecycleHookId_;
+}
+

ess/src/model/CreateNotificationConfigurationRequest.cc

@@ -58,6 +58,17 @@ void CreateScalingGroupRequest::setLoadBalancerIds(const std::string& loadBalanc
 	setParameter("LoadBalancerIds", loadBalancerIds);
 }
 
+std::string CreateScalingGroupRequest::getHealthCheckType()const
+{
+	return healthCheckType_;
+}
+
+void CreateScalingGroupRequest::setHealthCheckType(const std::string& healthCheckType)
+{
+	healthCheckType_ = healthCheckType;
+	setParameter("HealthCheckType", healthCheckType);
+}
+
 std::string CreateScalingGroupRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -169,6 +180,27 @@ void CreateScalingGroupRequest::setMaxSize(int maxSize)
 	setParameter("MaxSize", std::to_string(maxSize));
 }
 
+std::vector<CreateScalingGroupRequest::LifecycleHook> CreateScalingGroupRequest::getLifecycleHook()const
+{
+	return lifecycleHook_;
+}
+
+void CreateScalingGroupRequest::setLifecycleHook(const std::vector<LifecycleHook>& lifecycleHook)
+{
+	lifecycleHook_ = lifecycleHook;
+	int i = 0;
+	for(int i = 0; i!= lifecycleHook.size(); i++)	{
+		auto obj = lifecycleHook.at(i);
+		std::string str ="LifecycleHook."+ std::to_string(i);
+		setParameter(str + ".LifecycleHookName", obj.lifecycleHookName);
+		setParameter(str + ".LifecycleTransition", obj.lifecycleTransition);
+		setParameter(str + ".DefaultResult", obj.defaultResult);
+		setParameter(str + ".HeartbeatTimeout", std::to_string(obj.heartbeatTimeout));
+		setParameter(str + ".NotificationMetadata", obj.notificationMetadata);
+		setParameter(str + ".NotificationArn", obj.notificationArn);
+	}
+}
+
 int CreateScalingGroupRequest::getDefaultCooldown()const
 {
 	return defaultCooldown_;

ess/src/model/CreateScalingGroupResult.cc

@@ -0,0 +1,104 @@
+/*
+ * 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/ess/model/DeleteLifecycleHookRequest.h>
+
+using AlibabaCloud::Ess::Model::DeleteLifecycleHookRequest;
+
+DeleteLifecycleHookRequest::DeleteLifecycleHookRequest() :
+	RpcServiceRequest("ess", "2014-08-28", "DeleteLifecycleHook")
+{}
+
+DeleteLifecycleHookRequest::~DeleteLifecycleHookRequest()
+{}
+
+std::string DeleteLifecycleHookRequest::getLifecycleHookName()const
+{
+	return lifecycleHookName_;
+}
+
+void DeleteLifecycleHookRequest::setLifecycleHookName(const std::string& lifecycleHookName)
+{
+	lifecycleHookName_ = lifecycleHookName;
+	setParameter("LifecycleHookName", lifecycleHookName);
+}
+
+std::string DeleteLifecycleHookRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DeleteLifecycleHookRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DeleteLifecycleHookRequest::getLifecycleHookId()const
+{
+	return lifecycleHookId_;
+}
+
+void DeleteLifecycleHookRequest::setLifecycleHookId(const std::string& lifecycleHookId)
+{
+	lifecycleHookId_ = lifecycleHookId;
+	setParameter("LifecycleHookId", lifecycleHookId);
+}
+
+std::string DeleteLifecycleHookRequest::getScalingGroupId()const
+{
+	return scalingGroupId_;
+}
+
+void DeleteLifecycleHookRequest::setScalingGroupId(const std::string& scalingGroupId)
+{
+	scalingGroupId_ = scalingGroupId;
+	setParameter("ScalingGroupId", scalingGroupId);
+}
+
+std::string DeleteLifecycleHookRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DeleteLifecycleHookRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DeleteLifecycleHookRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DeleteLifecycleHookRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DeleteLifecycleHookRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DeleteLifecycleHookRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

ess/src/model/DeleteLifecycleHookResult.cc

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

ess/src/model/DeleteNotificationConfigurationRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/ess/model/DescribeAccountAttributesRequest.h>
+
+using AlibabaCloud::Ess::Model::DescribeAccountAttributesRequest;
+
+DescribeAccountAttributesRequest::DescribeAccountAttributesRequest() :
+	RpcServiceRequest("ess", "2014-08-28", "DescribeAccountAttributes")
+{}
+
+DescribeAccountAttributesRequest::~DescribeAccountAttributesRequest()
+{}
+
+std::string DescribeAccountAttributesRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeAccountAttributesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+long DescribeAccountAttributesRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeAccountAttributesRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeAccountAttributesRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeAccountAttributesRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

ess/src/model/DescribeAccountAttributesResult.cc

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ess/model/DescribeAccountAttributesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ess;
+using namespace AlibabaCloud::Ess::Model;
+
+DescribeAccountAttributesResult::DescribeAccountAttributesResult() :
+	ServiceResult()
+{}
+
+DescribeAccountAttributesResult::DescribeAccountAttributesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeAccountAttributesResult::~DescribeAccountAttributesResult()
+{}
+
+void DescribeAccountAttributesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	if(!value["MaxNumberOfScalingGroups"].isNull())
+		maxNumberOfScalingGroups_ = std::stoi(value["MaxNumberOfScalingGroups"].asString());
+	if(!value["MaxNumberOfScalingConfigurations"].isNull())
+		maxNumberOfScalingConfigurations_ = std::stoi(value["MaxNumberOfScalingConfigurations"].asString());
+	if(!value["MaxNumberOfScalingRules"].isNull())
+		maxNumberOfScalingRules_ = std::stoi(value["MaxNumberOfScalingRules"].asString());
+	if(!value["MaxNumberOfScheduledTasks"].isNull())
+		maxNumberOfScheduledTasks_ = std::stoi(value["MaxNumberOfScheduledTasks"].asString());
+	if(!value["MaxNumberOfScalingInstances"].isNull())
+		maxNumberOfScalingInstances_ = std::stoi(value["MaxNumberOfScalingInstances"].asString());
+	if(!value["MaxNumberOfDBInstances"].isNull())
+		maxNumberOfDBInstances_ = std::stoi(value["MaxNumberOfDBInstances"].asString());
+	if(!value["MaxNumberOfLoadBalancers"].isNull())
+		maxNumberOfLoadBalancers_ = std::stoi(value["MaxNumberOfLoadBalancers"].asString());
+	if(!value["MaxNumberOfMinSize"].isNull())
+		maxNumberOfMinSize_ = std::stoi(value["MaxNumberOfMinSize"].asString());
+	if(!value["MaxNumberOfMaxSize"].isNull())
+		maxNumberOfMaxSize_ = std::stoi(value["MaxNumberOfMaxSize"].asString());
+
+}
+
+int DescribeAccountAttributesResult::getMaxNumberOfScalingRules()const
+{
+	return maxNumberOfScalingRules_;
+}
+
+int DescribeAccountAttributesResult::getMaxNumberOfScalingInstances()const
+{
+	return maxNumberOfScalingInstances_;
+}
+
+int DescribeAccountAttributesResult::getMaxNumberOfScheduledTasks()const
+{
+	return maxNumberOfScheduledTasks_;
+}
+
+int DescribeAccountAttributesResult::getMaxNumberOfLoadBalancers()const
+{
+	return maxNumberOfLoadBalancers_;
+}
+
+int DescribeAccountAttributesResult::getMaxNumberOfMinSize()const
+{
+	return maxNumberOfMinSize_;
+}
+
+int DescribeAccountAttributesResult::getMaxNumberOfScalingGroups()const
+{
+	return maxNumberOfScalingGroups_;
+}
+
+int DescribeAccountAttributesResult::getMaxNumberOfScalingConfigurations()const
+{
+	return maxNumberOfScalingConfigurations_;
+}
+
+int DescribeAccountAttributesResult::getMaxNumberOfDBInstances()const
+{
+	return maxNumberOfDBInstances_;
+}
+
+int DescribeAccountAttributesResult::getMaxNumberOfMaxSize()const
+{
+	return maxNumberOfMaxSize_;
+}
+

ess/src/model/DescribeAlertConfigRequest.cc

@@ -0,0 +1,127 @@
+/*
+ * 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/ess/model/DescribeLifecycleHooksRequest.h>
+
+using AlibabaCloud::Ess::Model::DescribeLifecycleHooksRequest;
+
+DescribeLifecycleHooksRequest::DescribeLifecycleHooksRequest() :
+	RpcServiceRequest("ess", "2014-08-28", "DescribeLifecycleHooks")
+{}
+
+DescribeLifecycleHooksRequest::~DescribeLifecycleHooksRequest()
+{}
+
+std::string DescribeLifecycleHooksRequest::getLifecycleHookName()const
+{
+	return lifecycleHookName_;
+}
+
+void DescribeLifecycleHooksRequest::setLifecycleHookName(const std::string& lifecycleHookName)
+{
+	lifecycleHookName_ = lifecycleHookName;
+	setParameter("LifecycleHookName", lifecycleHookName);
+}
+
+std::string DescribeLifecycleHooksRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeLifecycleHooksRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeLifecycleHooksRequest::getScalingGroupId()const
+{
+	return scalingGroupId_;
+}
+
+void DescribeLifecycleHooksRequest::setScalingGroupId(const std::string& scalingGroupId)
+{
+	scalingGroupId_ = scalingGroupId;
+	setParameter("ScalingGroupId", scalingGroupId);
+}
+
+std::vector<std::string> DescribeLifecycleHooksRequest::getLifecycleHookId()const
+{
+	return lifecycleHookId_;
+}
+
+void DescribeLifecycleHooksRequest::setLifecycleHookId(const std::vector<std::string>& lifecycleHookId)
+{
+	lifecycleHookId_ = lifecycleHookId;
+	for(int i = 0; i!= lifecycleHookId.size(); i++)
+		setParameter("LifecycleHookId."+ std::to_string(i), lifecycleHookId.at(i));
+}
+
+std::string DescribeLifecycleHooksRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeLifecycleHooksRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+int DescribeLifecycleHooksRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeLifecycleHooksRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+long DescribeLifecycleHooksRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeLifecycleHooksRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+int DescribeLifecycleHooksRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeLifecycleHooksRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DescribeLifecycleHooksRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeLifecycleHooksRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

ess/src/model/DescribeLifecycleHooksResult.cc

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ess/model/DescribeLifecycleHooksResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ess;
+using namespace AlibabaCloud::Ess::Model;
+
+DescribeLifecycleHooksResult::DescribeLifecycleHooksResult() :
+	ServiceResult()
+{}
+
+DescribeLifecycleHooksResult::DescribeLifecycleHooksResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLifecycleHooksResult::~DescribeLifecycleHooksResult()
+{}
+
+void DescribeLifecycleHooksResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allLifecycleHooks = value["LifecycleHooks"]["LifecycleHook"];
+	for (auto value : allLifecycleHooks)
+	{
+		LifecycleHook lifecycleHooksObject;
+		if(!value["ScalingGroupId"].isNull())
+			lifecycleHooksObject.scalingGroupId = value["ScalingGroupId"].asString();
+		if(!value["LifecycleHookId"].isNull())
+			lifecycleHooksObject.lifecycleHookId = value["LifecycleHookId"].asString();
+		if(!value["LifecycleHookName"].isNull())
+			lifecycleHooksObject.lifecycleHookName = value["LifecycleHookName"].asString();
+		if(!value["DefaultResult"].isNull())
+			lifecycleHooksObject.defaultResult = value["DefaultResult"].asString();
+		if(!value["HeartbeatTimeout"].isNull())
+			lifecycleHooksObject.heartbeatTimeout = std::stoi(value["HeartbeatTimeout"].asString());
+		if(!value["LifecycleTransition"].isNull())
+			lifecycleHooksObject.lifecycleTransition = value["LifecycleTransition"].asString();
+		if(!value["NotificationMetadata"].isNull())
+			lifecycleHooksObject.notificationMetadata = value["NotificationMetadata"].asString();
+		if(!value["NotificationArn"].isNull())
+			lifecycleHooksObject.notificationArn = value["NotificationArn"].asString();
+		lifecycleHooks_.push_back(lifecycleHooksObject);
+	}
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+
+}
+
+int DescribeLifecycleHooksResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeLifecycleHooksResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeLifecycleHooksResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeLifecycleHooksResult::LifecycleHook> DescribeLifecycleHooksResult::getLifecycleHooks()const
+{
+	return lifecycleHooks_;
+}
+

ess/src/model/DescribeLimitationRequest.cc

@@ -82,6 +82,8 @@ void DescribeScalingGroupsResult::parse(const std::string &payload)
 			scalingGroupsObject.vSwitchId = value["VSwitchId"].asString();
 		if(!value["MultiAZPolicy"].isNull())
 			scalingGroupsObject.multiAZPolicy = value["MultiAZPolicy"].asString();
+		if(!value["HealthCheckType"].isNull())
+			scalingGroupsObject.healthCheckType = value["HealthCheckType"].asString();
 		auto allVSwitchIds = value["VSwitchIds"]["VSwitchId"];
 		for (auto value : allVSwitchIds)
 			scalingGroupsObject.vSwitchIds.push_back(value.asString());

ess/src/model/DescribeScalingInstancesRequest.cc

@@ -25,17 +25,6 @@ DetachInstancesRequest::DetachInstancesRequest() :
 DetachInstancesRequest::~DetachInstancesRequest()
 {}
 
-std::string DetachInstancesRequest::getInstanceId10()const
-{
-	return instanceId10_;
-}
-
-void DetachInstancesRequest::setInstanceId10(const std::string& instanceId10)
-{
-	instanceId10_ = instanceId10;
-	setParameter("InstanceId10", instanceId10);
-}
-
 long DetachInstancesRequest::getResourceOwnerId()const
 {
 	return resourceOwnerId_;
@@ -47,81 +36,16 @@ void DetachInstancesRequest::setResourceOwnerId(long resourceOwnerId)
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
-std::string DetachInstancesRequest::getInstanceId12()const
-{
-	return instanceId12_;
-}
-
-void DetachInstancesRequest::setInstanceId12(const std::string& instanceId12)
-{
-	instanceId12_ = instanceId12;
-	setParameter("InstanceId12", instanceId12);
-}
-
-std::string DetachInstancesRequest::getInstanceId11()const
-{
-	return instanceId11_;
-}
-
-void DetachInstancesRequest::setInstanceId11(const std::string& instanceId11)
-{
-	instanceId11_ = instanceId11;
-	setParameter("InstanceId11", instanceId11);
-}
-
-std::string DetachInstancesRequest::getScalingGroupId()const
+std::vector<std::string> DetachInstancesRequest::getInstanceId()const
 {
-	return scalingGroupId_;
+	return instanceId_;
 }
 
-void DetachInstancesRequest::setScalingGroupId(const std::string& scalingGroupId)
+void DetachInstancesRequest::setInstanceId(const std::vector<std::string>& instanceId)
 {
-	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
-}
-
-std::string DetachInstancesRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
-}
-
-void DetachInstancesRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
-}
-
-std::string DetachInstancesRequest::getInstanceId20()const
-{
-	return instanceId20_;
-}
-
-void DetachInstancesRequest::setInstanceId20(const std::string& instanceId20)
-{
-	instanceId20_ = instanceId20;
-	setParameter("InstanceId20", instanceId20);
-}
-
-std::string DetachInstancesRequest::getInstanceId1()const
-{
-	return instanceId1_;
-}
-
-void DetachInstancesRequest::setInstanceId1(const std::string& instanceId1)
-{
-	instanceId1_ = instanceId1;
-	setParameter("InstanceId1", instanceId1);
-}
-
-std::string DetachInstancesRequest::getInstanceId3()const
-{
-	return instanceId3_;
-}
-
-void DetachInstancesRequest::setInstanceId3(const std::string& instanceId3)
-{
-	instanceId3_ = instanceId3;
-	setParameter("InstanceId3", instanceId3);
+	instanceId_ = instanceId;
+	for(int i = 0; i!= instanceId.size(); i++)
+		setParameter("InstanceId."+ std::to_string(i), instanceId.at(i));
 }
 
 std::string DetachInstancesRequest::getResourceOwnerAccount()const
@@ -135,37 +59,15 @@ void DetachInstancesRequest::setResourceOwnerAccount(const std::string& resource
 	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
-std::string DetachInstancesRequest::getInstanceId2()const
-{
-	return instanceId2_;
-}
-
-void DetachInstancesRequest::setInstanceId2(const std::string& instanceId2)
-{
-	instanceId2_ = instanceId2;
-	setParameter("InstanceId2", instanceId2);
-}
-
-std::string DetachInstancesRequest::getInstanceId5()const
-{
-	return instanceId5_;
-}
-
-void DetachInstancesRequest::setInstanceId5(const std::string& instanceId5)
-{
-	instanceId5_ = instanceId5;
-	setParameter("InstanceId5", instanceId5);
-}
-
-std::string DetachInstancesRequest::getInstanceId4()const
+std::string DetachInstancesRequest::getScalingGroupId()const
 {
-	return instanceId4_;
+	return scalingGroupId_;
 }
 
-void DetachInstancesRequest::setInstanceId4(const std::string& instanceId4)
+void DetachInstancesRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
-	instanceId4_ = instanceId4;
-	setParameter("InstanceId4", instanceId4);
+	scalingGroupId_ = scalingGroupId;
+	setParameter("ScalingGroupId", scalingGroupId);
 }
 
 std::string DetachInstancesRequest::getOwnerAccount()const
@@ -179,50 +81,6 @@ void DetachInstancesRequest::setOwnerAccount(const std::string& ownerAccount)
 	setParameter("OwnerAccount", ownerAccount);
 }
 
-std::string DetachInstancesRequest::getInstanceId7()const
-{
-	return instanceId7_;
-}
-
-void DetachInstancesRequest::setInstanceId7(const std::string& instanceId7)
-{
-	instanceId7_ = instanceId7;
-	setParameter("InstanceId7", instanceId7);
-}
-
-std::string DetachInstancesRequest::getInstanceId6()const
-{
-	return instanceId6_;
-}
-
-void DetachInstancesRequest::setInstanceId6(const std::string& instanceId6)
-{
-	instanceId6_ = instanceId6;
-	setParameter("InstanceId6", instanceId6);
-}
-
-std::string DetachInstancesRequest::getInstanceId9()const
-{
-	return instanceId9_;
-}
-
-void DetachInstancesRequest::setInstanceId9(const std::string& instanceId9)
-{
-	instanceId9_ = instanceId9;
-	setParameter("InstanceId9", instanceId9);
-}
-
-std::string DetachInstancesRequest::getInstanceId8()const
-{
-	return instanceId8_;
-}
-
-void DetachInstancesRequest::setInstanceId8(const std::string& instanceId8)
-{
-	instanceId8_ = instanceId8;
-	setParameter("InstanceId8", instanceId8);
-}
-
 long DetachInstancesRequest::getOwnerId()const
 {
 	return ownerId_;
@@ -234,80 +92,14 @@ void DetachInstancesRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
-std::string DetachInstancesRequest::getInstanceId18()const
-{
-	return instanceId18_;
-}
-
-void DetachInstancesRequest::setInstanceId18(const std::string& instanceId18)
-{
-	instanceId18_ = instanceId18;
-	setParameter("InstanceId18", instanceId18);
-}
-
-std::string DetachInstancesRequest::getInstanceId17()const
-{
-	return instanceId17_;
-}
-
-void DetachInstancesRequest::setInstanceId17(const std::string& instanceId17)
-{
-	instanceId17_ = instanceId17;
-	setParameter("InstanceId17", instanceId17);
-}
-
-std::string DetachInstancesRequest::getInstanceId19()const
-{
-	return instanceId19_;
-}
-
-void DetachInstancesRequest::setInstanceId19(const std::string& instanceId19)
-{
-	instanceId19_ = instanceId19;
-	setParameter("InstanceId19", instanceId19);
-}
-
-std::string DetachInstancesRequest::getInstanceId14()const
-{
-	return instanceId14_;
-}
-
-void DetachInstancesRequest::setInstanceId14(const std::string& instanceId14)
-{
-	instanceId14_ = instanceId14;
-	setParameter("InstanceId14", instanceId14);
-}
-
-std::string DetachInstancesRequest::getInstanceId13()const
-{
-	return instanceId13_;
-}
-
-void DetachInstancesRequest::setInstanceId13(const std::string& instanceId13)
-{
-	instanceId13_ = instanceId13;
-	setParameter("InstanceId13", instanceId13);
-}
-
-std::string DetachInstancesRequest::getInstanceId16()const
-{
-	return instanceId16_;
-}
-
-void DetachInstancesRequest::setInstanceId16(const std::string& instanceId16)
-{
-	instanceId16_ = instanceId16;
-	setParameter("InstanceId16", instanceId16);
-}
-
-std::string DetachInstancesRequest::getInstanceId15()const
+std::string DetachInstancesRequest::getAccessKeyId()const
 {
-	return instanceId15_;
+	return accessKeyId_;
 }
 
-void DetachInstancesRequest::setInstanceId15(const std::string& instanceId15)
+void DetachInstancesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
-	instanceId15_ = instanceId15;
-	setParameter("InstanceId15", instanceId15);
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DetachInstancesResult.cc

@@ -0,0 +1,159 @@
+/*
+ * 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/ess/model/ModifyLifecycleHookRequest.h>
+
+using AlibabaCloud::Ess::Model::ModifyLifecycleHookRequest;
+
+ModifyLifecycleHookRequest::ModifyLifecycleHookRequest() :
+	RpcServiceRequest("ess", "2014-08-28", "ModifyLifecycleHook")
+{}
+
+ModifyLifecycleHookRequest::~ModifyLifecycleHookRequest()
+{}
+
+std::string ModifyLifecycleHookRequest::getDefaultResult()const
+{
+	return defaultResult_;
+}
+
+void ModifyLifecycleHookRequest::setDefaultResult(const std::string& defaultResult)
+{
+	defaultResult_ = defaultResult;
+	setParameter("DefaultResult", defaultResult);
+}
+
+std::string ModifyLifecycleHookRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void ModifyLifecycleHookRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+int ModifyLifecycleHookRequest::getHeartbeatTimeout()const
+{
+	return heartbeatTimeout_;
+}
+
+void ModifyLifecycleHookRequest::setHeartbeatTimeout(int heartbeatTimeout)
+{
+	heartbeatTimeout_ = heartbeatTimeout;
+	setParameter("HeartbeatTimeout", std::to_string(heartbeatTimeout));
+}
+
+std::string ModifyLifecycleHookRequest::getLifecycleHookId()const
+{
+	return lifecycleHookId_;
+}
+
+void ModifyLifecycleHookRequest::setLifecycleHookId(const std::string& lifecycleHookId)
+{
+	lifecycleHookId_ = lifecycleHookId;
+	setParameter("LifecycleHookId", lifecycleHookId);
+}
+
+std::string ModifyLifecycleHookRequest::getScalingGroupId()const
+{
+	return scalingGroupId_;
+}
+
+void ModifyLifecycleHookRequest::setScalingGroupId(const std::string& scalingGroupId)
+{
+	scalingGroupId_ = scalingGroupId;
+	setParameter("ScalingGroupId", scalingGroupId);
+}
+
+std::string ModifyLifecycleHookRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void ModifyLifecycleHookRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string ModifyLifecycleHookRequest::getNotificationMetadata()const
+{
+	return notificationMetadata_;
+}
+
+void ModifyLifecycleHookRequest::setNotificationMetadata(const std::string& notificationMetadata)
+{
+	notificationMetadata_ = notificationMetadata;
+	setParameter("NotificationMetadata", notificationMetadata);
+}
+
+long ModifyLifecycleHookRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ModifyLifecycleHookRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string ModifyLifecycleHookRequest::getLifecycleTransition()const
+{
+	return lifecycleTransition_;
+}
+
+void ModifyLifecycleHookRequest::setLifecycleTransition(const std::string& lifecycleTransition)
+{
+	lifecycleTransition_ = lifecycleTransition;
+	setParameter("LifecycleTransition", lifecycleTransition);
+}
+
+std::string ModifyLifecycleHookRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void ModifyLifecycleHookRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string ModifyLifecycleHookRequest::getLifecycleHookName()const
+{
+	return lifecycleHookName_;
+}
+
+void ModifyLifecycleHookRequest::setLifecycleHookName(const std::string& lifecycleHookName)
+{
+	lifecycleHookName_ = lifecycleHookName;
+	setParameter("LifecycleHookName", lifecycleHookName);
+}
+
+std::string ModifyLifecycleHookRequest::getNotificationArn()const
+{
+	return notificationArn_;
+}
+
+void ModifyLifecycleHookRequest::setNotificationArn(const std::string& notificationArn)
+{
+	notificationArn_ = notificationArn;
+	setParameter("NotificationArn", notificationArn);
+}
+

ess/src/model/ModifyLifecycleHookResult.cc

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

ess/src/model/ModifyNotificationConfigurationRequest.cc

@@ -36,6 +36,17 @@ void ModifyScalingGroupRequest::setResourceOwnerId(long resourceOwnerId)
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+std::string ModifyScalingGroupRequest::getHealthCheckType()const
+{
+	return healthCheckType_;
+}
+
+void ModifyScalingGroupRequest::setHealthCheckType(const std::string& healthCheckType)
+{
+	healthCheckType_ = healthCheckType;
+	setParameter("HealthCheckType", healthCheckType);
+}
+
 std::string ModifyScalingGroupRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;

ess/src/model/ModifyScalingGroupResult.cc

@@ -0,0 +1,104 @@
+/*
+ * 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/ess/model/RecordLifecycleActionHeartbeatRequest.h>
+
+using AlibabaCloud::Ess::Model::RecordLifecycleActionHeartbeatRequest;
+
+RecordLifecycleActionHeartbeatRequest::RecordLifecycleActionHeartbeatRequest() :
+	RpcServiceRequest("ess", "2014-08-28", "RecordLifecycleActionHeartbeat")
+{}
+
+RecordLifecycleActionHeartbeatRequest::~RecordLifecycleActionHeartbeatRequest()
+{}
+
+std::string RecordLifecycleActionHeartbeatRequest::getLifecycleActionToken()const
+{
+	return lifecycleActionToken_;
+}
+
+void RecordLifecycleActionHeartbeatRequest::setLifecycleActionToken(const std::string& lifecycleActionToken)
+{
+	lifecycleActionToken_ = lifecycleActionToken;
+	setParameter("LifecycleActionToken", lifecycleActionToken);
+}
+
+std::string RecordLifecycleActionHeartbeatRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void RecordLifecycleActionHeartbeatRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+int RecordLifecycleActionHeartbeatRequest::getHeartbeatTimeout()const
+{
+	return heartbeatTimeout_;
+}
+
+void RecordLifecycleActionHeartbeatRequest::setHeartbeatTimeout(int heartbeatTimeout)
+{
+	heartbeatTimeout_ = heartbeatTimeout;
+	setParameter("HeartbeatTimeout", std::to_string(heartbeatTimeout));
+}
+
+std::string RecordLifecycleActionHeartbeatRequest::getLifecycleHookId()const
+{
+	return lifecycleHookId_;
+}
+
+void RecordLifecycleActionHeartbeatRequest::setLifecycleHookId(const std::string& lifecycleHookId)
+{
+	lifecycleHookId_ = lifecycleHookId;
+	setParameter("LifecycleHookId", lifecycleHookId);
+}
+
+std::string RecordLifecycleActionHeartbeatRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void RecordLifecycleActionHeartbeatRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long RecordLifecycleActionHeartbeatRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void RecordLifecycleActionHeartbeatRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string RecordLifecycleActionHeartbeatRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void RecordLifecycleActionHeartbeatRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

ess/src/model/RecordLifecycleActionHeartbeatResult.cc

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