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

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

CHANGELOG

@@ -1,3 +1,7 @@
+2018-04-23 Version: 1.6.3
+1, Add notificationConfiguration.
+2, Add standby status.
+
 2018-04-17 Version: 1.6.2
 1, EditPhotos add input param TakenAt
 2, add FetchMomentPhotos

VERSION

@@ -1 +1 @@
-1.6.2
+1.6.3

ess/CMakeLists.txt

@@ -25,8 +25,14 @@ set(ess_public_header_model
 	include/alibabacloud/ess/model/AttachInstancesResult.h
 	include/alibabacloud/ess/model/DescribeScalingGroupsRequest.h
 	include/alibabacloud/ess/model/DescribeScalingGroupsResult.h
+	include/alibabacloud/ess/model/EnterStandbyRequest.h
+	include/alibabacloud/ess/model/EnterStandbyResult.h
 	include/alibabacloud/ess/model/DescribeScalingActivitiesRequest.h
 	include/alibabacloud/ess/model/DescribeScalingActivitiesResult.h
+	include/alibabacloud/ess/model/ExitStandbyRequest.h
+	include/alibabacloud/ess/model/ExitStandbyResult.h
+	include/alibabacloud/ess/model/DescribeNotificationConfigurationsRequest.h
+	include/alibabacloud/ess/model/DescribeNotificationConfigurationsResult.h
 	include/alibabacloud/ess/model/DescribeScalingRulesRequest.h
 	include/alibabacloud/ess/model/DescribeScalingRulesResult.h
 	include/alibabacloud/ess/model/ModifyScalingGroupRequest.h
@@ -35,12 +41,16 @@ set(ess_public_header_model
 	include/alibabacloud/ess/model/EnableScalingGroupResult.h
 	include/alibabacloud/ess/model/DeactivateScalingConfigurationRequest.h
 	include/alibabacloud/ess/model/DeactivateScalingConfigurationResult.h
+	include/alibabacloud/ess/model/CreateNotificationConfigurationRequest.h
+	include/alibabacloud/ess/model/CreateNotificationConfigurationResult.h
 	include/alibabacloud/ess/model/VerifyAuthenticationRequest.h
 	include/alibabacloud/ess/model/VerifyAuthenticationResult.h
 	include/alibabacloud/ess/model/CreateScheduledTaskRequest.h
 	include/alibabacloud/ess/model/CreateScheduledTaskResult.h
 	include/alibabacloud/ess/model/DeleteScheduledTaskRequest.h
 	include/alibabacloud/ess/model/DeleteScheduledTaskResult.h
+	include/alibabacloud/ess/model/ModifyNotificationConfigurationRequest.h
+	include/alibabacloud/ess/model/ModifyNotificationConfigurationResult.h
 	include/alibabacloud/ess/model/CreateScalingRuleRequest.h
 	include/alibabacloud/ess/model/CreateScalingRuleResult.h
 	include/alibabacloud/ess/model/DescribeScalingConfigurationsRequest.h
@@ -49,6 +59,8 @@ set(ess_public_header_model
 	include/alibabacloud/ess/model/ModifyScheduledTaskResult.h
 	include/alibabacloud/ess/model/RemoveInstancesRequest.h
 	include/alibabacloud/ess/model/RemoveInstancesResult.h
+	include/alibabacloud/ess/model/DescribeNotificationTypesRequest.h
+	include/alibabacloud/ess/model/DescribeNotificationTypesResult.h
 	include/alibabacloud/ess/model/ExecuteScalingRuleRequest.h
 	include/alibabacloud/ess/model/ExecuteScalingRuleResult.h
 	include/alibabacloud/ess/model/DeleteScalingGroupRequest.h
@@ -63,6 +75,8 @@ 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/DeleteNotificationConfigurationRequest.h
+	include/alibabacloud/ess/model/DeleteNotificationConfigurationResult.h
 	include/alibabacloud/ess/model/DescribeAccountAttributesRequest.h
 	include/alibabacloud/ess/model/DescribeAccountAttributesResult.h
 	include/alibabacloud/ess/model/DetachInstancesRequest.h
@@ -94,8 +108,14 @@ set(ess_src
 	src/model/AttachInstancesResult.cc
 	src/model/DescribeScalingGroupsRequest.cc
 	src/model/DescribeScalingGroupsResult.cc
+	src/model/EnterStandbyRequest.cc
+	src/model/EnterStandbyResult.cc
 	src/model/DescribeScalingActivitiesRequest.cc
 	src/model/DescribeScalingActivitiesResult.cc
+	src/model/ExitStandbyRequest.cc
+	src/model/ExitStandbyResult.cc
+	src/model/DescribeNotificationConfigurationsRequest.cc
+	src/model/DescribeNotificationConfigurationsResult.cc
 	src/model/DescribeScalingRulesRequest.cc
 	src/model/DescribeScalingRulesResult.cc
 	src/model/ModifyScalingGroupRequest.cc
@@ -104,12 +124,16 @@ set(ess_src
 	src/model/EnableScalingGroupResult.cc
 	src/model/DeactivateScalingConfigurationRequest.cc
 	src/model/DeactivateScalingConfigurationResult.cc
+	src/model/CreateNotificationConfigurationRequest.cc
+	src/model/CreateNotificationConfigurationResult.cc
 	src/model/VerifyAuthenticationRequest.cc
 	src/model/VerifyAuthenticationResult.cc
 	src/model/CreateScheduledTaskRequest.cc
 	src/model/CreateScheduledTaskResult.cc
 	src/model/DeleteScheduledTaskRequest.cc
 	src/model/DeleteScheduledTaskResult.cc
+	src/model/ModifyNotificationConfigurationRequest.cc
+	src/model/ModifyNotificationConfigurationResult.cc
 	src/model/CreateScalingRuleRequest.cc
 	src/model/CreateScalingRuleResult.cc
 	src/model/DescribeScalingConfigurationsRequest.cc
@@ -118,6 +142,8 @@ set(ess_src
 	src/model/ModifyScheduledTaskResult.cc
 	src/model/RemoveInstancesRequest.cc
 	src/model/RemoveInstancesResult.cc
+	src/model/DescribeNotificationTypesRequest.cc
+	src/model/DescribeNotificationTypesResult.cc
 	src/model/ExecuteScalingRuleRequest.cc
 	src/model/ExecuteScalingRuleResult.cc
 	src/model/DeleteScalingGroupRequest.cc
@@ -132,6 +158,8 @@ set(ess_src
 	src/model/DescribeRegionsResult.cc
 	src/model/DescribeScheduledTasksRequest.cc
 	src/model/DescribeScheduledTasksResult.cc
+	src/model/DeleteNotificationConfigurationRequest.cc
+	src/model/DeleteNotificationConfigurationResult.cc
 	src/model/DescribeAccountAttributesRequest.cc
 	src/model/DescribeAccountAttributesResult.cc
 	src/model/DetachInstancesRequest.cc

ess/include/alibabacloud/ess/EssClient.h

@@ -26,8 +26,14 @@
 #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"
@@ -36,12 +42,16 @@
 #include "model/EnableScalingGroupResult.h"
 #include "model/DeactivateScalingConfigurationRequest.h"
 #include "model/DeactivateScalingConfigurationResult.h"
+#include "model/CreateNotificationConfigurationRequest.h"
+#include "model/CreateNotificationConfigurationResult.h"
 #include "model/VerifyAuthenticationRequest.h"
 #include "model/VerifyAuthenticationResult.h"
 #include "model/CreateScheduledTaskRequest.h"
 #include "model/CreateScheduledTaskResult.h"
 #include "model/DeleteScheduledTaskRequest.h"
 #include "model/DeleteScheduledTaskResult.h"
+#include "model/ModifyNotificationConfigurationRequest.h"
+#include "model/ModifyNotificationConfigurationResult.h"
 #include "model/CreateScalingRuleRequest.h"
 #include "model/CreateScalingRuleResult.h"
 #include "model/DescribeScalingConfigurationsRequest.h"
@@ -50,6 +60,8 @@
 #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"
@@ -64,6 +76,8 @@
 #include "model/DescribeRegionsResult.h"
 #include "model/DescribeScheduledTasksRequest.h"
 #include "model/DescribeScheduledTasksResult.h"
+#include "model/DeleteNotificationConfigurationRequest.h"
+#include "model/DeleteNotificationConfigurationResult.h"
 #include "model/DescribeAccountAttributesRequest.h"
 #include "model/DescribeAccountAttributesResult.h"
 #include "model/DetachInstancesRequest.h"
@@ -97,209 +111,251 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_ESS_EXPORT EssClient : public RpcServiceClient
 		{
 		public:
-			typedef Outcome<Error, Model::AttachInstancesResult> AttachInstancesOutcome;			
-			typedef std::future<AttachInstancesOutcome> AttachInstancesOutcomeCallable;			
+			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 Outcome<Error, Model::DescribeScalingGroupsResult> DescribeScalingGroupsOutcome;			
-			typedef std::future<DescribeScalingGroupsOutcome> DescribeScalingGroupsOutcomeCallable;			
+			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 Outcome<Error, Model::DescribeScalingActivitiesResult> DescribeScalingActivitiesOutcome;			
-			typedef std::future<DescribeScalingActivitiesOutcome> DescribeScalingActivitiesOutcomeCallable;			
+			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 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 Outcome<Error, Model::DescribeScalingRulesResult> DescribeScalingRulesOutcome;			
-			typedef std::future<DescribeScalingRulesOutcome> DescribeScalingRulesOutcomeCallable;			
+			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 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 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 Outcome<Error, Model::ModifyScalingGroupResult> ModifyScalingGroupOutcome;			
-			typedef std::future<ModifyScalingGroupOutcome> ModifyScalingGroupOutcomeCallable;			
+			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 Outcome<Error, Model::EnableScalingGroupResult> EnableScalingGroupOutcome;			
-			typedef std::future<EnableScalingGroupOutcome> EnableScalingGroupOutcomeCallable;			
+			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 Outcome<Error, Model::DeactivateScalingConfigurationResult> DeactivateScalingConfigurationOutcome;			
-			typedef std::future<DeactivateScalingConfigurationOutcome> DeactivateScalingConfigurationOutcomeCallable;			
+			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 Outcome<Error, Model::VerifyAuthenticationResult> VerifyAuthenticationOutcome;			
-			typedef std::future<VerifyAuthenticationOutcome> VerifyAuthenticationOutcomeCallable;			
+			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 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 Outcome<Error, Model::CreateScheduledTaskResult> CreateScheduledTaskOutcome;			
-			typedef std::future<CreateScheduledTaskOutcome> CreateScheduledTaskOutcomeCallable;			
+			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 Outcome<Error, Model::DeleteScheduledTaskResult> DeleteScheduledTaskOutcome;			
-			typedef std::future<DeleteScheduledTaskOutcome> DeleteScheduledTaskOutcomeCallable;			
+			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 Outcome<Error, Model::CreateScalingRuleResult> CreateScalingRuleOutcome;			
-			typedef std::future<CreateScalingRuleOutcome> CreateScalingRuleOutcomeCallable;			
+			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 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 Outcome<Error, Model::DescribeScalingConfigurationsResult> DescribeScalingConfigurationsOutcome;			
-			typedef std::future<DescribeScalingConfigurationsOutcome> DescribeScalingConfigurationsOutcomeCallable;			
+			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 Outcome<Error, Model::ModifyScheduledTaskResult> ModifyScheduledTaskOutcome;			
-			typedef std::future<ModifyScheduledTaskOutcome> ModifyScheduledTaskOutcomeCallable;			
+			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 Outcome<Error, Model::RemoveInstancesResult> RemoveInstancesOutcome;			
-			typedef std::future<RemoveInstancesOutcome> RemoveInstancesOutcomeCallable;			
+			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 Outcome<Error, Model::ExecuteScalingRuleResult> ExecuteScalingRuleOutcome;			
-			typedef std::future<ExecuteScalingRuleOutcome> ExecuteScalingRuleOutcomeCallable;			
+			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 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 Outcome<Error, Model::DeleteScalingGroupResult> DeleteScalingGroupOutcome;			
-			typedef std::future<DeleteScalingGroupOutcome> DeleteScalingGroupOutcomeCallable;			
+			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 Outcome<Error, Model::DescribeScalingInstancesResult> DescribeScalingInstancesOutcome;			
-			typedef std::future<DescribeScalingInstancesOutcome> DescribeScalingInstancesOutcomeCallable;			
+			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 Outcome<Error, Model::CreateScalingConfigurationResult> CreateScalingConfigurationOutcome;			
-			typedef std::future<CreateScalingConfigurationOutcome> CreateScalingConfigurationOutcomeCallable;			
+			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 Outcome<Error, Model::DescribeCapacityHistoryResult> DescribeCapacityHistoryOutcome;			
-			typedef std::future<DescribeCapacityHistoryOutcome> DescribeCapacityHistoryOutcomeCallable;			
+			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 Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;			
-			typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;			
+			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 Outcome<Error, Model::DescribeScheduledTasksResult> DescribeScheduledTasksOutcome;			
-			typedef std::future<DescribeScheduledTasksOutcome> DescribeScheduledTasksOutcomeCallable;			
+			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 Outcome<Error, Model::DescribeAccountAttributesResult> DescribeAccountAttributesOutcome;			
-			typedef std::future<DescribeAccountAttributesOutcome> DescribeAccountAttributesOutcomeCallable;			
+			typedef Outcome<Error, Model::DeleteNotificationConfigurationResult> DeleteNotificationConfigurationOutcome;
+			typedef std::future<DeleteNotificationConfigurationOutcome> DeleteNotificationConfigurationOutcomeCallable;
+			typedef std::function<void(const EssClient*, const Model::DeleteNotificationConfigurationRequest&, const DeleteNotificationConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteNotificationConfigurationAsyncHandler;
+			typedef Outcome<Error, Model::DescribeAccountAttributesResult> DescribeAccountAttributesOutcome;
+			typedef std::future<DescribeAccountAttributesOutcome> DescribeAccountAttributesOutcomeCallable;
 			typedef std::function<void(const EssClient*, const Model::DescribeAccountAttributesRequest&, const DescribeAccountAttributesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccountAttributesAsyncHandler;
-			typedef Outcome<Error, Model::DetachInstancesResult> DetachInstancesOutcome;			
-			typedef std::future<DetachInstancesOutcome> DetachInstancesOutcomeCallable;			
+			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 Outcome<Error, Model::DescribeLimitationResult> DescribeLimitationOutcome;			
-			typedef std::future<DescribeLimitationOutcome> DescribeLimitationOutcomeCallable;			
+			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 Outcome<Error, Model::DescribeScalingActivityDetailResult> DescribeScalingActivityDetailOutcome;			
-			typedef std::future<DescribeScalingActivityDetailOutcome> DescribeScalingActivityDetailOutcomeCallable;			
+			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 Outcome<Error, Model::DescribeAlertConfigResult> DescribeAlertConfigOutcome;			
-			typedef std::future<DescribeAlertConfigOutcome> DescribeAlertConfigOutcomeCallable;			
+			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 Outcome<Error, Model::CreateScalingGroupResult> CreateScalingGroupOutcome;			
-			typedef std::future<CreateScalingGroupOutcome> CreateScalingGroupOutcomeCallable;			
+			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 Outcome<Error, Model::DeleteScalingConfigurationResult> DeleteScalingConfigurationOutcome;			
-			typedef std::future<DeleteScalingConfigurationOutcome> DeleteScalingConfigurationOutcomeCallable;			
+			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 Outcome<Error, Model::DisableScalingGroupResult> DisableScalingGroupOutcome;			
-			typedef std::future<DisableScalingGroupOutcome> DisableScalingGroupOutcomeCallable;			
+			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 Outcome<Error, Model::ModifyScalingRuleResult> ModifyScalingRuleOutcome;			
-			typedef std::future<ModifyScalingRuleOutcome> ModifyScalingRuleOutcomeCallable;			
+			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 Outcome<Error, Model::DeleteScalingRuleResult> DeleteScalingRuleOutcome;			
-			typedef std::future<DeleteScalingRuleOutcome> DeleteScalingRuleOutcomeCallable;			
+			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 Outcome<Error, Model::VerifyUserResult> VerifyUserOutcome;			
-			typedef std::future<VerifyUserOutcome> VerifyUserOutcomeCallable;			
+			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 Outcome<Error, Model::ModifyAlertConfigResult> ModifyAlertConfigOutcome;			
-			typedef std::future<ModifyAlertConfigOutcome> ModifyAlertConfigOutcomeCallable;			
+			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;
 
 			EssClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			EssClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			EssClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
-            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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			DeleteNotificationConfigurationOutcome deleteNotificationConfiguration(const Model::DeleteNotificationConfigurationRequest &request)const;
+			void deleteNotificationConfigurationAsync(const Model::DeleteNotificationConfigurationRequest& request, const DeleteNotificationConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteNotificationConfigurationOutcomeCallable deleteNotificationConfigurationCallable(const Model::DeleteNotificationConfigurationRequest& request) const;
+			DescribeAccountAttributesOutcome describeAccountAttributes(const Model::DescribeAccountAttributesRequest &request)const;
+			void describeAccountAttributesAsync(const Model::DescribeAccountAttributesRequest& request, const DescribeAccountAttributesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeAccountAttributesOutcomeCallable describeAccountAttributesCallable(const Model::DescribeAccountAttributesRequest& request) const;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
+			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;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

ess/include/alibabacloud/ess/model/AttachInstancesResult.h

@@ -37,12 +37,12 @@ namespace AlibabaCloud
 				AttachInstancesResult();
 				explicit AttachInstancesResult(const std::string &payload);
 				~AttachInstancesResult();
-				std::string getScalingActivityId()const;
+				std::string getScalingActivityId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string scalingActivityId_;
+				std::string scalingActivityId_;
 
 			};
 		}

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

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ESS_MODEL_CREATENOTIFICATIONCONFIGURATIONREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_CREATENOTIFICATIONCONFIGURATIONREQUEST_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 CreateNotificationConfigurationRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateNotificationConfigurationRequest();
+				~CreateNotificationConfigurationRequest();
+
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				std::string getNotificationArn()const;
+				void setNotificationArn(const std::string& notificationArn);
+				std::vector<std::string> getNotificationType()const;
+				void setNotificationType(const std::vector<std::string>& notificationType);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string resourceOwnerAccount_;
+				std::string scalingGroupId_;
+				std::string notificationArn_;
+				std::vector<std::string> notificationType_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_CREATENOTIFICATIONCONFIGURATIONREQUEST_H_

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

ess/include/alibabacloud/ess/model/CreateScalingConfigurationRequest.h

@@ -30,6 +30,11 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_ESS_EXPORT CreateScalingConfigurationRequest : public RpcServiceRequest
 			{
+				struct SpotPriceLimit
+				{
+					std::string instanceType;
+					float priceLimit;
+				};
 
 			public:
 				CreateScalingConfigurationRequest();
@@ -61,6 +66,8 @@ namespace AlibabaCloud
 				void setSecurityEnhancementStrategy(const std::string& securityEnhancementStrategy);
 				std::string getKeyPairName()const;
 				void setKeyPairName(const std::string& keyPairName);
+				std::vector<SpotPriceLimit> getSpotPriceLimit()const;
+				void setSpotPriceLimit(const std::vector<SpotPriceLimit>& spotPriceLimit);
 				std::string getSystemDiskCategory()const;
 				void setSystemDiskCategory(const std::string& systemDiskCategory);
 				std::string getAccessKeyId()const;
@@ -97,6 +104,8 @@ namespace AlibabaCloud
 				void setTags(const std::string& tags);
 				std::string getDataDisk2DeleteWithInstance()const;
 				void setDataDisk2DeleteWithInstance(const std::string& dataDisk2DeleteWithInstance);
+				std::string getSpotStrategy()const;
+				void setSpotStrategy(const std::string& spotStrategy);
 				std::string getDataDisk1Category()const;
 				void setDataDisk1Category(const std::string& dataDisk1Category);
 				std::string getDataDisk3DeleteWithInstance()const;
@@ -136,6 +145,7 @@ namespace AlibabaCloud
 				int internetMaxBandwidthOut_;
 				std::string securityEnhancementStrategy_;
 				std::string keyPairName_;
+				std::vector<SpotPriceLimit> spotPriceLimit_;
 				std::string systemDiskCategory_;
 				std::string accessKeyId_;
 				std::string userData_;
@@ -154,6 +164,7 @@ namespace AlibabaCloud
 				std::string scalingConfigurationName_;
 				std::string tags_;
 				std::string dataDisk2DeleteWithInstance_;
+				std::string spotStrategy_;
 				std::string dataDisk1Category_;
 				std::string dataDisk3DeleteWithInstance_;
 				int loadBalancerWeight_;

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

@@ -37,12 +37,12 @@ namespace AlibabaCloud
 				CreateScalingConfigurationResult();
 				explicit CreateScalingConfigurationResult(const std::string &payload);
 				~CreateScalingConfigurationResult();
-				std::string getScalingConfigurationId()const;
+				std::string getScalingConfigurationId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string scalingConfigurationId_;
+				std::string scalingConfigurationId_;
 
 			};
 		}

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

@@ -37,12 +37,12 @@ namespace AlibabaCloud
 				CreateScalingGroupResult();
 				explicit CreateScalingGroupResult(const std::string &payload);
 				~CreateScalingGroupResult();
-				std::string getScalingGroupId()const;
+				std::string getScalingGroupId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string scalingGroupId_;
+				std::string scalingGroupId_;
 
 			};
 		}

ess/include/alibabacloud/ess/model/CreateScalingRuleResult.h

@@ -37,14 +37,14 @@ namespace AlibabaCloud
 				CreateScalingRuleResult();
 				explicit CreateScalingRuleResult(const std::string &payload);
 				~CreateScalingRuleResult();
-				std::string getScalingRuleAri()const;
-				std::string getScalingRuleId()const;
+				std::string getScalingRuleAri()const;
+				std::string getScalingRuleId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string scalingRuleAri_;
-				std::string scalingRuleId_;
+				std::string scalingRuleAri_;
+				std::string scalingRuleId_;
 
 			};
 		}

ess/include/alibabacloud/ess/model/CreateScheduledTaskResult.h

@@ -37,12 +37,12 @@ namespace AlibabaCloud
 				CreateScheduledTaskResult();
 				explicit CreateScheduledTaskResult(const std::string &payload);
 				~CreateScheduledTaskResult();
-				std::string getScheduledTaskId()const;
+				std::string getScheduledTaskId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string scheduledTaskId_;
+				std::string scheduledTaskId_;
 
 			};
 		}

ess/include/alibabacloud/ess/model/DeleteNotificationConfigurationRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ESS_MODEL_DELETENOTIFICATIONCONFIGURATIONREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DELETENOTIFICATIONCONFIGURATIONREQUEST_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 DeleteNotificationConfigurationRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteNotificationConfigurationRequest();
+				~DeleteNotificationConfigurationRequest();
+
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				std::string getNotificationArn()const;
+				void setNotificationArn(const std::string& notificationArn);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string resourceOwnerAccount_;
+				std::string scalingGroupId_;
+				std::string notificationArn_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DELETENOTIFICATIONCONFIGURATIONREQUEST_H_

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

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

@@ -37,28 +37,28 @@ namespace AlibabaCloud
 				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;
+				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_;
+				int maxNumberOfScalingRules_;
+				int maxNumberOfScalingInstances_;
+				int maxNumberOfScheduledTasks_;
+				int maxNumberOfLoadBalancers_;
+				int maxNumberOfMinSize_;
+				int maxNumberOfScalingGroups_;
+				int maxNumberOfScalingConfigurations_;
+				int maxNumberOfDBInstances_;
+				int maxNumberOfMaxSize_;
 
 			};
 		}

ess/include/alibabacloud/ess/model/DescribeAlertConfigResult.h

@@ -37,16 +37,16 @@ namespace AlibabaCloud
 				DescribeAlertConfigResult();
 				explicit DescribeAlertConfigResult(const std::string &payload);
 				~DescribeAlertConfigResult();
-				int getFailConfig()const;
-				int getRejectConfig()const;
-				int getSuccessConfig()const;
+				int getFailConfig()const;
+				int getRejectConfig()const;
+				int getSuccessConfig()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				int failConfig_;
-				int rejectConfig_;
-				int successConfig_;
+				int failConfig_;
+				int rejectConfig_;
+				int successConfig_;
 
 			};
 		}

ess/include/alibabacloud/ess/model/DescribeCapacityHistoryResult.h

@@ -32,31 +32,31 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_ESS_EXPORT DescribeCapacityHistoryResult : public ServiceResult
 			{
 			public:
-				struct CapacityHistoryModel
-				{
-					int attachedCapacity;
-					std::string scalingGroupId;
-					int totalCapacity;
-					int autoCreatedCapacity;
-					std::string timestamp;
-				};
+				struct CapacityHistoryModel
+				{
+					int attachedCapacity;
+					std::string scalingGroupId;
+					int totalCapacity;
+					int autoCreatedCapacity;
+					std::string timestamp;
+				};
 
 
 				DescribeCapacityHistoryResult();
 				explicit DescribeCapacityHistoryResult(const std::string &payload);
 				~DescribeCapacityHistoryResult();
-				int getTotalCount()const;
-				int getPageSize()const;
-				int getPageNumber()const;
-				std::vector<CapacityHistoryModel> getCapacityHistoryItems()const;
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<CapacityHistoryModel> getCapacityHistoryItems()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				int totalCount_;
-				int pageSize_;
-				int pageNumber_;
-				std::vector<CapacityHistoryModel> capacityHistoryItems_;
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<CapacityHistoryModel> capacityHistoryItems_;
 
 			};
 		}

ess/include/alibabacloud/ess/model/DescribeLimitationResult.h

@@ -37,28 +37,28 @@ namespace AlibabaCloud
 				DescribeLimitationResult();
 				explicit DescribeLimitationResult(const std::string &payload);
 				~DescribeLimitationResult();
-				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;
+				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_;
+				int maxNumberOfScalingRules_;
+				int maxNumberOfScalingInstances_;
+				int maxNumberOfScheduledTasks_;
+				int maxNumberOfLoadBalancers_;
+				int maxNumberOfMinSize_;
+				int maxNumberOfScalingGroups_;
+				int maxNumberOfScalingConfigurations_;
+				int maxNumberOfDBInstances_;
+				int maxNumberOfMaxSize_;
 
 			};
 		}

ess/include/alibabacloud/ess/model/DescribeNotificationConfigurationsRequest.h

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

ess/include/alibabacloud/ess/model/DescribeNotificationConfigurationsResult.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBENOTIFICATIONCONFIGURATIONSRESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBENOTIFICATIONCONFIGURATIONSRESULT_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 DescribeNotificationConfigurationsResult : public ServiceResult
+			{
+			public:
+				struct NotificationConfigurationModel
+				{
+					std::string notificationArn;
+					std::string scalingGroupId;
+					std::vector<std::string> notificationTypes;
+				};
+
+
+				DescribeNotificationConfigurationsResult();
+				explicit DescribeNotificationConfigurationsResult(const std::string &payload);
+				~DescribeNotificationConfigurationsResult();
+				std::vector<NotificationConfigurationModel> getNotificationConfigurationModels()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<NotificationConfigurationModel> notificationConfigurationModels_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBENOTIFICATIONCONFIGURATIONSRESULT_H_

ess/include/alibabacloud/ess/model/DescribeNotificationTypesRequest.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_DESCRIBENOTIFICATIONTYPESREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBENOTIFICATIONTYPESREQUEST_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 DescribeNotificationTypesRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeNotificationTypesRequest();
+				~DescribeNotificationTypesRequest();
+
+				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_DESCRIBENOTIFICATIONTYPESREQUEST_H_

ess/include/alibabacloud/ess/model/DescribeNotificationTypesResult.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_DESCRIBENOTIFICATIONTYPESRESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBENOTIFICATIONTYPESRESULT_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 DescribeNotificationTypesResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeNotificationTypesResult();
+				explicit DescribeNotificationTypesResult(const std::string &payload);
+				~DescribeNotificationTypesResult();
+				std::vector<std::string> getNotificationTypes()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<std::string> notificationTypes_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBENOTIFICATIONTYPESRESULT_H_

ess/include/alibabacloud/ess/model/DescribeRegionsResult.h

@@ -32,23 +32,23 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_ESS_EXPORT DescribeRegionsResult : public ServiceResult
 			{
 			public:
-				struct Region
-				{
-					bool vpcUnavailable;
-					bool classicUnavailable;
-					std::string regionId;
-				};
+				struct Region
+				{
+					bool vpcUnavailable;
+					bool classicUnavailable;
+					std::string regionId;
+				};
 
 
 				DescribeRegionsResult();
 				explicit DescribeRegionsResult(const std::string &payload);
 				~DescribeRegionsResult();
-				std::vector<Region> getRegions()const;
+				std::vector<Region> getRegions()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::vector<Region> regions_;
+				std::vector<Region> regions_;
 
 			};
 		}

ess/include/alibabacloud/ess/model/DescribeScalingActivitiesResult.h

@@ -32,38 +32,38 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_ESS_EXPORT DescribeScalingActivitiesResult : public ServiceResult
 			{
 			public:
-				struct ScalingActivity
-				{
-					int progress;
-					std::string description;
-					std::string endTime;
-					std::string attachedCapacity;
-					std::string scalingActivityId;
-					std::string scalingGroupId;
-					std::string cause;
-					std::string startTime;
-					std::string totalCapacity;
-					std::string statusCode;
-					std::string autoCreatedCapacity;
-					std::string statusMessage;
-				};
+				struct ScalingActivity
+				{
+					int progress;
+					std::string description;
+					std::string endTime;
+					std::string attachedCapacity;
+					std::string scalingActivityId;
+					std::string scalingGroupId;
+					std::string cause;
+					std::string startTime;
+					std::string totalCapacity;
+					std::string statusCode;
+					std::string autoCreatedCapacity;
+					std::string statusMessage;
+				};
 
 
 				DescribeScalingActivitiesResult();
 				explicit DescribeScalingActivitiesResult(const std::string &payload);
 				~DescribeScalingActivitiesResult();
-				int getTotalCount()const;
-				int getPageSize()const;
-				int getPageNumber()const;
-				std::vector<ScalingActivity> getScalingActivities()const;
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<ScalingActivity> getScalingActivities()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				int totalCount_;
-				int pageSize_;
-				int pageNumber_;
-				std::vector<ScalingActivity> scalingActivities_;
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<ScalingActivity> scalingActivities_;
 
 			};
 		}

ess/include/alibabacloud/ess/model/DescribeScalingActivityDetailResult.h

@@ -37,14 +37,14 @@ namespace AlibabaCloud
 				DescribeScalingActivityDetailResult();
 				explicit DescribeScalingActivityDetailResult(const std::string &payload);
 				~DescribeScalingActivityDetailResult();
-				std::string getScalingActivityId()const;
-				std::string getDetail()const;
+				std::string getScalingActivityId()const;
+				std::string getDetail()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string scalingActivityId_;
-				std::string detail_;
+				std::string scalingActivityId_;
+				std::string detail_;
 
 			};
 		}

ess/include/alibabacloud/ess/model/DescribeScalingConfigurationsResult.h

@@ -32,63 +32,70 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_ESS_EXPORT DescribeScalingConfigurationsResult : public ServiceResult
 			{
 			public:
-				struct ScalingConfiguration
-				{
-					struct DataDisk
-					{
-						std::string snapshotId;
-						std::string category;
-						int size;
-						std::string device;
-					};
-					struct Tag
-					{
-						std::string value;
-						std::string key;
-					};
-					std::string scalingConfigurationName;
-					std::vector<ScalingConfiguration::DataDisk> dataDisks;
-					int systemDiskSize;
-					std::string userData;
-					std::string lifecycleState;
-					std::string ramRoleName;
-					std::string imageId;
-					std::vector<std::string> instanceTypes;
-					std::string instanceType;
-					std::vector<ScalingConfiguration::Tag> tags;
-					std::string keyPairName;
-					int loadBalancerWeight;
-					std::string ioOptimized;
-					std::string scalingGroupId;
-					std::string securityGroupId;
-					std::string internetChargeType;
-					std::string systemDiskCategory;
-					std::string instanceName;
-					std::string deploymentSetId;
-					int internetMaxBandwidthOut;
-					int internetMaxBandwidthIn;
-					std::string creationTime;
-					std::string instanceGeneration;
-					std::string scalingConfigurationId;
-					std::string securityEnhancementStrategy;
-				};
+				struct ScalingConfiguration
+				{
+					struct DataDisk
+					{
+						std::string snapshotId;
+						std::string category;
+						int size;
+						std::string device;
+					};
+					struct Tag
+					{
+						std::string value;
+						std::string key;
+					};
+					struct SpotPriceModel
+					{
+						float priceLimit;
+						std::string instanceType;
+					};
+					std::string scalingConfigurationName;
+					std::vector<ScalingConfiguration::DataDisk> dataDisks;
+					int systemDiskSize;
+					std::string userData;
+					std::string lifecycleState;
+					std::string ramRoleName;
+					std::string imageId;
+					std::vector<ScalingConfiguration::SpotPriceModel> spotPriceLimit;
+					std::vector<std::string> instanceTypes;
+					std::string instanceType;
+					std::vector<ScalingConfiguration::Tag> tags;
+					std::string spotStrategy;
+					std::string keyPairName;
+					int loadBalancerWeight;
+					std::string ioOptimized;
+					std::string scalingGroupId;
+					std::string securityGroupId;
+					std::string internetChargeType;
+					std::string systemDiskCategory;
+					std::string instanceName;
+					std::string deploymentSetId;
+					int internetMaxBandwidthOut;
+					int internetMaxBandwidthIn;
+					std::string creationTime;
+					std::string instanceGeneration;
+					std::string scalingConfigurationId;
+					std::string securityEnhancementStrategy;
+				};
 
 
 				DescribeScalingConfigurationsResult();
 				explicit DescribeScalingConfigurationsResult(const std::string &payload);
 				~DescribeScalingConfigurationsResult();
-				int getTotalCount()const;
-				int getPageSize()const;
-				int getPageNumber()const;
-				std::vector<ScalingConfiguration> getScalingConfigurations()const;
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<ScalingConfiguration> getScalingConfigurations()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				int totalCount_;
-				int pageSize_;
-				int pageNumber_;
-				std::vector<ScalingConfiguration> scalingConfigurations_;
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<ScalingConfiguration> scalingConfigurations_;
 
 			};
 		}

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

@@ -32,46 +32,47 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_ESS_EXPORT DescribeScalingGroupsResult : public ServiceResult
 			{
 			public:
-				struct ScalingGroup
-				{
-					int removingCapacity;
-					std::string activeScalingConfigurationId;
-					std::vector<std::string> vSwitchIds;
-					int pendingCapacity;
-					std::string scalingGroupId;
-					std::string vSwitchId;
-					std::vector<std::string> loadBalancerIds;
-					std::string lifecycleState;
-					std::string modificationTime;
-					int maxSize;
-					std::string scalingGroupName;
-					int activeCapacity;
-					int minSize;
-					int defaultCooldown;
-					std::string vpcId;
-					std::vector<std::string> removalPolicies;
-					std::string creationTime;
-					int totalCapacity;
-					std::string regionId;
-					std::vector<std::string> dBInstanceIds;
-				};
+				struct ScalingGroup
+				{
+					int removingCapacity;
+					std::string activeScalingConfigurationId;
+					std::vector<std::string> vSwitchIds;
+					int pendingCapacity;
+					std::string scalingGroupId;
+					std::string vSwitchId;
+					std::vector<std::string> loadBalancerIds;
+					std::string lifecycleState;
+					std::string modificationTime;
+					int maxSize;
+					std::string scalingGroupName;
+					int activeCapacity;
+					int minSize;
+					int defaultCooldown;
+					std::string vpcId;
+					std::vector<std::string> removalPolicies;
+					std::string creationTime;
+					int totalCapacity;
+					std::string regionId;
+					std::vector<std::string> dBInstanceIds;
+					int standbyCapacity;
+				};
 
 
 				DescribeScalingGroupsResult();
 				explicit DescribeScalingGroupsResult(const std::string &payload);
 				~DescribeScalingGroupsResult();
-				int getTotalCount()const;
-				std::vector<ScalingGroup> getScalingGroups()const;
-				int getPageSize()const;
-				int getPageNumber()const;
+				int getTotalCount()const;
+				std::vector<ScalingGroup> getScalingGroups()const;
+				int getPageSize()const;
+				int getPageNumber()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				int totalCount_;
-				std::vector<ScalingGroup> scalingGroups_;
-				int pageSize_;
-				int pageNumber_;
+				int totalCount_;
+				std::vector<ScalingGroup> scalingGroups_;
+				int pageSize_;
+				int pageNumber_;
 
 			};
 		}

ess/include/alibabacloud/ess/model/DescribeScalingInstancesResult.h

@@ -32,34 +32,34 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_ESS_EXPORT DescribeScalingInstancesResult : public ServiceResult
 			{
 			public:
-				struct ScalingInstance
-				{
-					int loadBalancerWeight;
-					std::string instanceId;
-					std::string scalingGroupId;
-					std::string healthStatus;
-					std::string creationTime;
-					std::string lifecycleState;
-					std::string scalingConfigurationId;
-					std::string creationType;
-				};
+				struct ScalingInstance
+				{
+					int loadBalancerWeight;
+					std::string instanceId;
+					std::string scalingGroupId;
+					std::string healthStatus;
+					std::string creationTime;
+					std::string lifecycleState;
+					std::string scalingConfigurationId;
+					std::string creationType;
+				};
 
 
 				DescribeScalingInstancesResult();
 				explicit DescribeScalingInstancesResult(const std::string &payload);
 				~DescribeScalingInstancesResult();
-				int getTotalCount()const;
-				int getPageSize()const;
-				int getPageNumber()const;
-				std::vector<ScalingInstance> getScalingInstances()const;
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<ScalingInstance> getScalingInstances()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				int totalCount_;
-				int pageSize_;
-				int pageNumber_;
-				std::vector<ScalingInstance> scalingInstances_;
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<ScalingInstance> scalingInstances_;
 
 			};
 		}

ess/include/alibabacloud/ess/model/DescribeScalingRulesResult.h

@@ -32,35 +32,35 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_ESS_EXPORT DescribeScalingRulesResult : public ServiceResult
 			{
 			public:
-				struct ScalingRule
-				{
-					std::string scalingRuleAri;
-					int minSize;
-					std::string scalingRuleName;
-					int adjustmentValue;
-					std::string scalingGroupId;
-					int cooldown;
-					std::string scalingRuleId;
-					int maxSize;
-					std::string adjustmentType;
-				};
+				struct ScalingRule
+				{
+					std::string scalingRuleAri;
+					int minSize;
+					std::string scalingRuleName;
+					int adjustmentValue;
+					std::string scalingGroupId;
+					int cooldown;
+					std::string scalingRuleId;
+					int maxSize;
+					std::string adjustmentType;
+				};
 
 
 				DescribeScalingRulesResult();
 				explicit DescribeScalingRulesResult(const std::string &payload);
 				~DescribeScalingRulesResult();
-				std::vector<ScalingRule> getScalingRules()const;
-				int getTotalCount()const;
-				int getPageSize()const;
-				int getPageNumber()const;
+				std::vector<ScalingRule> getScalingRules()const;
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::vector<ScalingRule> scalingRules_;
-				int totalCount_;
-				int pageSize_;
-				int pageNumber_;
+				std::vector<ScalingRule> scalingRules_;
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
 
 			};
 		}

ess/include/alibabacloud/ess/model/DescribeScheduledTasksResult.h

@@ -32,36 +32,36 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_ESS_EXPORT DescribeScheduledTasksResult : public ServiceResult
 			{
 			public:
-				struct ScheduledTask
-				{
-					std::string description;
-					std::string launchTime;
-					std::string scheduledTaskId;
-					std::string recurrenceType;
-					std::string scheduledTaskName;
-					std::string scheduledAction;
-					std::string recurrenceEndTime;
-					std::string recurrenceValue;
-					int launchExpirationTime;
-					bool taskEnabled;
-				};
+				struct ScheduledTask
+				{
+					std::string description;
+					std::string launchTime;
+					std::string scheduledTaskId;
+					std::string recurrenceType;
+					std::string scheduledTaskName;
+					std::string scheduledAction;
+					std::string recurrenceEndTime;
+					std::string recurrenceValue;
+					int launchExpirationTime;
+					bool taskEnabled;
+				};
 
 
 				DescribeScheduledTasksResult();
 				explicit DescribeScheduledTasksResult(const std::string &payload);
 				~DescribeScheduledTasksResult();
-				int getTotalCount()const;
-				int getPageSize()const;
-				int getPageNumber()const;
-				std::vector<ScheduledTask> getScheduledTasks()const;
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<ScheduledTask> getScheduledTasks()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				int totalCount_;
-				int pageSize_;
-				int pageNumber_;
-				std::vector<ScheduledTask> scheduledTasks_;
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<ScheduledTask> scheduledTasks_;
 
 			};
 		}

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

@@ -37,12 +37,12 @@ namespace AlibabaCloud
 				DetachInstancesResult();
 				explicit DetachInstancesResult(const std::string &payload);
 				~DetachInstancesResult();
-				std::string getScalingActivityId()const;
+				std::string getScalingActivityId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string scalingActivityId_;
+				std::string scalingActivityId_;
 
 			};
 		}

ess/include/alibabacloud/ess/model/EnterStandbyRequest.h

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

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

ess/include/alibabacloud/ess/model/ExecuteScalingRuleResult.h

@@ -37,12 +37,12 @@ namespace AlibabaCloud
 				ExecuteScalingRuleResult();
 				explicit ExecuteScalingRuleResult(const std::string &payload);
 				~ExecuteScalingRuleResult();
-				std::string getScalingActivityId()const;
+				std::string getScalingActivityId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string scalingActivityId_;
+				std::string scalingActivityId_;
 
 			};
 		}

ess/include/alibabacloud/ess/model/ExitStandbyRequest.h

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

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

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

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ESS_MODEL_MODIFYNOTIFICATIONCONFIGURATIONREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_MODIFYNOTIFICATIONCONFIGURATIONREQUEST_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 ModifyNotificationConfigurationRequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifyNotificationConfigurationRequest();
+				~ModifyNotificationConfigurationRequest();
+
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				std::string getNotificationArn()const;
+				void setNotificationArn(const std::string& notificationArn);
+				std::vector<std::string> getNotificationType()const;
+				void setNotificationType(const std::vector<std::string>& notificationType);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string resourceOwnerAccount_;
+				std::string scalingGroupId_;
+				std::string notificationArn_;
+				std::vector<std::string> notificationType_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_MODIFYNOTIFICATIONCONFIGURATIONREQUEST_H_

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

ess/include/alibabacloud/ess/model/RemoveInstancesResult.h

@@ -37,12 +37,12 @@ namespace AlibabaCloud
 				RemoveInstancesResult();
 				explicit RemoveInstancesResult(const std::string &payload);
 				~RemoveInstancesResult();
-				std::string getScalingActivityId()const;
+				std::string getScalingActivityId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string scalingActivityId_;
+				std::string scalingActivityId_;
 
 			};
 		}

ess/src/EssClient.cc

@@ -24,7 +24,7 @@ using namespace AlibabaCloud::Ess::Model;
 
 namespace
 {
-	const std::string SERVICE_NAME = "Ess";
+	const std::string SERVICE_NAME = "Ess";
 }
 
 EssClient::EssClient(const Credentials &credentials, const ClientConfiguration &configuration) :
@@ -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,43 @@ 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();
+	if (!endpointOutcome.isSuccess())
+		return EnterStandbyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EnterStandbyOutcome(EnterStandbyResult(outcome.result()));
+	else
+		return EnterStandbyOutcome(outcome.error());
+}
+
+void EssClient::enterStandbyAsync(const EnterStandbyRequest& request, const EnterStandbyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, enterStandby(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
 
+EssClient::EnterStandbyOutcomeCallable EssClient::enterStandbyCallable(const EnterStandbyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EnterStandbyOutcome()>>(
+			[this, request]()
+			{
+			return this->enterStandby(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::DescribeScalingActivitiesOutcome EssClient::describeScalingActivities(const DescribeScalingActivitiesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -158,7 +194,79 @@ 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();
+	if (!endpointOutcome.isSuccess())
+		return ExitStandbyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ExitStandbyOutcome(ExitStandbyResult(outcome.result()));
+	else
+		return ExitStandbyOutcome(outcome.error());
+}
+
+void EssClient::exitStandbyAsync(const ExitStandbyRequest& request, const ExitStandbyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, exitStandby(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::ExitStandbyOutcomeCallable EssClient::exitStandbyCallable(const ExitStandbyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ExitStandbyOutcome()>>(
+			[this, request]()
+			{
+			return this->exitStandby(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::DescribeNotificationConfigurationsOutcome EssClient::describeNotificationConfigurations(const DescribeNotificationConfigurationsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeNotificationConfigurationsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeNotificationConfigurationsOutcome(DescribeNotificationConfigurationsResult(outcome.result()));
+	else
+		return DescribeNotificationConfigurationsOutcome(outcome.error());
+}
+
+void EssClient::describeNotificationConfigurationsAsync(const DescribeNotificationConfigurationsRequest& request, const DescribeNotificationConfigurationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeNotificationConfigurations(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
 
+EssClient::DescribeNotificationConfigurationsOutcomeCallable EssClient::describeNotificationConfigurationsCallable(const DescribeNotificationConfigurationsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeNotificationConfigurationsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeNotificationConfigurations(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::DescribeScalingRulesOutcome EssClient::describeScalingRules(const DescribeScalingRulesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -194,7 +302,7 @@ EssClient::DescribeScalingRulesOutcomeCallable EssClient::describeScalingRulesCa
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::ModifyScalingGroupOutcome EssClient::modifyScalingGroup(const ModifyScalingGroupRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -230,7 +338,7 @@ EssClient::ModifyScalingGroupOutcomeCallable EssClient::modifyScalingGroupCallab
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::EnableScalingGroupOutcome EssClient::enableScalingGroup(const EnableScalingGroupRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -266,7 +374,7 @@ EssClient::EnableScalingGroupOutcomeCallable EssClient::enableScalingGroupCallab
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DeactivateScalingConfigurationOutcome EssClient::deactivateScalingConfiguration(const DeactivateScalingConfigurationRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -302,7 +410,43 @@ EssClient::DeactivateScalingConfigurationOutcomeCallable EssClient::deactivateSc
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
+
+EssClient::CreateNotificationConfigurationOutcome EssClient::createNotificationConfiguration(const CreateNotificationConfigurationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateNotificationConfigurationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateNotificationConfigurationOutcome(CreateNotificationConfigurationResult(outcome.result()));
+	else
+		return CreateNotificationConfigurationOutcome(outcome.error());
+}
+
+void EssClient::createNotificationConfigurationAsync(const CreateNotificationConfigurationRequest& request, const CreateNotificationConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createNotificationConfiguration(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::CreateNotificationConfigurationOutcomeCallable EssClient::createNotificationConfigurationCallable(const CreateNotificationConfigurationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateNotificationConfigurationOutcome()>>(
+			[this, request]()
+			{
+			return this->createNotificationConfiguration(request);
+			});
 
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::VerifyAuthenticationOutcome EssClient::verifyAuthentication(const VerifyAuthenticationRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -338,7 +482,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();
@@ -374,7 +518,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();
@@ -410,7 +554,43 @@ 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();
+	if (!endpointOutcome.isSuccess())
+		return ModifyNotificationConfigurationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyNotificationConfigurationOutcome(ModifyNotificationConfigurationResult(outcome.result()));
+	else
+		return ModifyNotificationConfigurationOutcome(outcome.error());
+}
 
+void EssClient::modifyNotificationConfigurationAsync(const ModifyNotificationConfigurationRequest& request, const ModifyNotificationConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyNotificationConfiguration(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::ModifyNotificationConfigurationOutcomeCallable EssClient::modifyNotificationConfigurationCallable(const ModifyNotificationConfigurationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyNotificationConfigurationOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyNotificationConfiguration(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::CreateScalingRuleOutcome EssClient::createScalingRule(const CreateScalingRuleRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -446,7 +626,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();
@@ -482,7 +662,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();
@@ -518,7 +698,7 @@ EssClient::ModifyScheduledTaskOutcomeCallable EssClient::modifyScheduledTaskCall
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::RemoveInstancesOutcome EssClient::removeInstances(const RemoveInstancesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -554,7 +734,43 @@ 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();
+	if (!endpointOutcome.isSuccess())
+		return DescribeNotificationTypesOutcome(endpointOutcome.error());
 
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeNotificationTypesOutcome(DescribeNotificationTypesResult(outcome.result()));
+	else
+		return DescribeNotificationTypesOutcome(outcome.error());
+}
+
+void EssClient::describeNotificationTypesAsync(const DescribeNotificationTypesRequest& request, const DescribeNotificationTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeNotificationTypes(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DescribeNotificationTypesOutcomeCallable EssClient::describeNotificationTypesCallable(const DescribeNotificationTypesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeNotificationTypesOutcome()>>(
+			[this, request]()
+			{
+			return this->describeNotificationTypes(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::ExecuteScalingRuleOutcome EssClient::executeScalingRule(const ExecuteScalingRuleRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -590,7 +806,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();
@@ -626,7 +842,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();
@@ -662,7 +878,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();
@@ -698,7 +914,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();
@@ -734,7 +950,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();
@@ -770,7 +986,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();
@@ -806,7 +1022,43 @@ EssClient::DescribeScheduledTasksOutcomeCallable EssClient::describeScheduledTas
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
+
+EssClient::DeleteNotificationConfigurationOutcome EssClient::deleteNotificationConfiguration(const DeleteNotificationConfigurationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteNotificationConfigurationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteNotificationConfigurationOutcome(DeleteNotificationConfigurationResult(outcome.result()));
+	else
+		return DeleteNotificationConfigurationOutcome(outcome.error());
+}
+
+void EssClient::deleteNotificationConfigurationAsync(const DeleteNotificationConfigurationRequest& request, const DeleteNotificationConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteNotificationConfiguration(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
 
+EssClient::DeleteNotificationConfigurationOutcomeCallable EssClient::deleteNotificationConfigurationCallable(const DeleteNotificationConfigurationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteNotificationConfigurationOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteNotificationConfiguration(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::DescribeAccountAttributesOutcome EssClient::describeAccountAttributes(const DescribeAccountAttributesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -842,7 +1094,7 @@ EssClient::DescribeAccountAttributesOutcomeCallable EssClient::describeAccountAt
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::DetachInstancesOutcome EssClient::detachInstances(const DetachInstancesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -878,7 +1130,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();
@@ -914,7 +1166,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();
@@ -950,7 +1202,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();
@@ -986,7 +1238,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();
@@ -1022,7 +1274,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();
@@ -1058,7 +1310,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();
@@ -1094,7 +1346,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();
@@ -1130,7 +1382,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();
@@ -1166,7 +1418,7 @@ EssClient::DeleteScalingRuleOutcomeCallable EssClient::deleteScalingRuleCallable
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+
 EssClient::VerifyUserOutcome EssClient::verifyUser(const VerifyUserRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1202,7 +1454,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();
@@ -1238,4 +1490,4 @@ EssClient::ModifyAlertConfigOutcomeCallable EssClient::modifyAlertConfigCallable
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
-
+

ess/src/model/AttachInstancesResult.cc

@@ -40,13 +40,13 @@ void AttachInstancesResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["ScalingActivityId"].isNull())
-		scalingActivityId_ = value["ScalingActivityId"].asString();
+	if(!value["ScalingActivityId"].isNull())
+		scalingActivityId_ = value["ScalingActivityId"].asString();
 
 }
 
-std::string AttachInstancesResult::getScalingActivityId()const
-{
-	return scalingActivityId_;
-}
-
+std::string AttachInstancesResult::getScalingActivityId()const
+{
+	return scalingActivityId_;
+}
+

ess/src/model/CreateNotificationConfigurationRequest.cc

@@ -0,0 +1,94 @@
+/*
+ * 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/CreateNotificationConfigurationRequest.h>
+
+using AlibabaCloud::Ess::Model::CreateNotificationConfigurationRequest;
+
+CreateNotificationConfigurationRequest::CreateNotificationConfigurationRequest() :
+	RpcServiceRequest("ess", "2014-08-28", "CreateNotificationConfiguration")
+{}
+
+CreateNotificationConfigurationRequest::~CreateNotificationConfigurationRequest()
+{}
+
+std::string CreateNotificationConfigurationRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateNotificationConfigurationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateNotificationConfigurationRequest::getScalingGroupId()const
+{
+	return scalingGroupId_;
+}
+
+void CreateNotificationConfigurationRequest::setScalingGroupId(const std::string& scalingGroupId)
+{
+	scalingGroupId_ = scalingGroupId;
+	setParameter("ScalingGroupId", scalingGroupId);
+}
+
+std::string CreateNotificationConfigurationRequest::getNotificationArn()const
+{
+	return notificationArn_;
+}
+
+void CreateNotificationConfigurationRequest::setNotificationArn(const std::string& notificationArn)
+{
+	notificationArn_ = notificationArn;
+	setParameter("NotificationArn", notificationArn);
+}
+
+std::vector<std::string> CreateNotificationConfigurationRequest::getNotificationType()const
+{
+	return notificationType_;
+}
+
+void CreateNotificationConfigurationRequest::setNotificationType(const std::vector<std::string>& notificationType)
+{
+	notificationType_ = notificationType;
+	for(int i = 0; i!= notificationType.size(); i++)
+		setParameter("NotificationType."+ std::to_string(i), notificationType.at(i));
+}
+
+long CreateNotificationConfigurationRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateNotificationConfigurationRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateNotificationConfigurationRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CreateNotificationConfigurationRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

ess/src/model/CreateNotificationConfigurationResult.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/CreateNotificationConfigurationResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ess;
+using namespace AlibabaCloud::Ess::Model;
+
+CreateNotificationConfigurationResult::CreateNotificationConfigurationResult() :
+	ServiceResult()
+{}
+
+CreateNotificationConfigurationResult::CreateNotificationConfigurationResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateNotificationConfigurationResult::~CreateNotificationConfigurationResult()
+{}
+
+void CreateNotificationConfigurationResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+
+}
+

ess/src/model/CreateScalingConfigurationRequest.cc

@@ -169,6 +169,23 @@ void CreateScalingConfigurationRequest::setKeyPairName(const std::string& keyPai
 	setParameter("KeyPairName", keyPairName);
 }
 
+std::vector<CreateScalingConfigurationRequest::SpotPriceLimit> CreateScalingConfigurationRequest::getSpotPriceLimit()const
+{
+	return spotPriceLimit_;
+}
+
+void CreateScalingConfigurationRequest::setSpotPriceLimit(const std::vector<SpotPriceLimit>& spotPriceLimit)
+{
+	spotPriceLimit_ = spotPriceLimit;
+	int i = 0;
+	for(int i = 0; i!= spotPriceLimit.size(); i++)	{
+		auto obj = spotPriceLimit.at(i);
+		std::string str ="SpotPriceLimit."+ std::to_string(i);
+		setParameter(str + ".InstanceType", obj.instanceType);
+		setParameter(str + ".PriceLimit", std::to_string(obj.priceLimit));
+	}
+}
+
 std::string CreateScalingConfigurationRequest::getSystemDiskCategory()const
 {
 	return systemDiskCategory_;
@@ -367,6 +384,17 @@ void CreateScalingConfigurationRequest::setDataDisk2DeleteWithInstance(const std
 	setParameter("DataDisk2DeleteWithInstance", dataDisk2DeleteWithInstance);
 }
 
+std::string CreateScalingConfigurationRequest::getSpotStrategy()const
+{
+	return spotStrategy_;
+}
+
+void CreateScalingConfigurationRequest::setSpotStrategy(const std::string& spotStrategy)
+{
+	spotStrategy_ = spotStrategy;
+	setParameter("SpotStrategy", spotStrategy);
+}
+
 std::string CreateScalingConfigurationRequest::getDataDisk1Category()const
 {
 	return dataDisk1Category_;

ess/src/model/CreateScalingConfigurationResult.cc

@@ -40,13 +40,13 @@ void CreateScalingConfigurationResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["ScalingConfigurationId"].isNull())
-		scalingConfigurationId_ = value["ScalingConfigurationId"].asString();
+	if(!value["ScalingConfigurationId"].isNull())
+		scalingConfigurationId_ = value["ScalingConfigurationId"].asString();
 
 }
 
-std::string CreateScalingConfigurationResult::getScalingConfigurationId()const
-{
-	return scalingConfigurationId_;
-}
-
+std::string CreateScalingConfigurationResult::getScalingConfigurationId()const
+{
+	return scalingConfigurationId_;
+}
+

ess/src/model/CreateScalingGroupResult.cc

@@ -40,13 +40,13 @@ void CreateScalingGroupResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["ScalingGroupId"].isNull())
-		scalingGroupId_ = value["ScalingGroupId"].asString();
+	if(!value["ScalingGroupId"].isNull())
+		scalingGroupId_ = value["ScalingGroupId"].asString();
 
 }
 
-std::string CreateScalingGroupResult::getScalingGroupId()const
-{
-	return scalingGroupId_;
-}
-
+std::string CreateScalingGroupResult::getScalingGroupId()const
+{
+	return scalingGroupId_;
+}
+

ess/src/model/CreateScalingRuleResult.cc

@@ -40,20 +40,20 @@ void CreateScalingRuleResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["ScalingRuleId"].isNull())
-		scalingRuleId_ = value["ScalingRuleId"].asString();
-	if(!value["ScalingRuleAri"].isNull())
-		scalingRuleAri_ = value["ScalingRuleAri"].asString();
+	if(!value["ScalingRuleId"].isNull())
+		scalingRuleId_ = value["ScalingRuleId"].asString();
+	if(!value["ScalingRuleAri"].isNull())
+		scalingRuleAri_ = value["ScalingRuleAri"].asString();
 
 }
 
-std::string CreateScalingRuleResult::getScalingRuleAri()const
-{
-	return scalingRuleAri_;
-}
-
-std::string CreateScalingRuleResult::getScalingRuleId()const
-{
-	return scalingRuleId_;
-}
-
+std::string CreateScalingRuleResult::getScalingRuleAri()const
+{
+	return scalingRuleAri_;
+}
+
+std::string CreateScalingRuleResult::getScalingRuleId()const
+{
+	return scalingRuleId_;
+}
+

ess/src/model/CreateScheduledTaskResult.cc

@@ -40,13 +40,13 @@ void CreateScheduledTaskResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["ScheduledTaskId"].isNull())
-		scheduledTaskId_ = value["ScheduledTaskId"].asString();
+	if(!value["ScheduledTaskId"].isNull())
+		scheduledTaskId_ = value["ScheduledTaskId"].asString();
 
 }
 
-std::string CreateScheduledTaskResult::getScheduledTaskId()const
-{
-	return scheduledTaskId_;
-}
-
+std::string CreateScheduledTaskResult::getScheduledTaskId()const
+{
+	return scheduledTaskId_;
+}
+

ess/src/model/DeleteNotificationConfigurationRequest.cc

@@ -0,0 +1,82 @@
+/*
+ * 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/DeleteNotificationConfigurationRequest.h>
+
+using AlibabaCloud::Ess::Model::DeleteNotificationConfigurationRequest;
+
+DeleteNotificationConfigurationRequest::DeleteNotificationConfigurationRequest() :
+	RpcServiceRequest("ess", "2014-08-28", "DeleteNotificationConfiguration")
+{}
+
+DeleteNotificationConfigurationRequest::~DeleteNotificationConfigurationRequest()
+{}
+
+std::string DeleteNotificationConfigurationRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DeleteNotificationConfigurationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DeleteNotificationConfigurationRequest::getScalingGroupId()const
+{
+	return scalingGroupId_;
+}
+
+void DeleteNotificationConfigurationRequest::setScalingGroupId(const std::string& scalingGroupId)
+{
+	scalingGroupId_ = scalingGroupId;
+	setParameter("ScalingGroupId", scalingGroupId);
+}
+
+std::string DeleteNotificationConfigurationRequest::getNotificationArn()const
+{
+	return notificationArn_;
+}
+
+void DeleteNotificationConfigurationRequest::setNotificationArn(const std::string& notificationArn)
+{
+	notificationArn_ = notificationArn;
+	setParameter("NotificationArn", notificationArn);
+}
+
+long DeleteNotificationConfigurationRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DeleteNotificationConfigurationRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DeleteNotificationConfigurationRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DeleteNotificationConfigurationRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

ess/src/model/DeleteNotificationConfigurationResult.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/DeleteNotificationConfigurationResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ess;
+using namespace AlibabaCloud::Ess::Model;
+
+DeleteNotificationConfigurationResult::DeleteNotificationConfigurationResult() :
+	ServiceResult()
+{}
+
+DeleteNotificationConfigurationResult::DeleteNotificationConfigurationResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteNotificationConfigurationResult::~DeleteNotificationConfigurationResult()
+{}
+
+void DeleteNotificationConfigurationResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+
+}
+

ess/src/model/DescribeAccountAttributesResult.cc

@@ -40,69 +40,69 @@ void DescribeAccountAttributesResult::parse(const std::string &payload)
 	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());
+	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_;
-}
-
+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/DescribeAlertConfigResult.cc

@@ -40,27 +40,27 @@ void DescribeAlertConfigResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["SuccessConfig"].isNull())
-		successConfig_ = std::stoi(value["SuccessConfig"].asString());
-	if(!value["FailConfig"].isNull())
-		failConfig_ = std::stoi(value["FailConfig"].asString());
-	if(!value["RejectConfig"].isNull())
-		rejectConfig_ = std::stoi(value["RejectConfig"].asString());
+	if(!value["SuccessConfig"].isNull())
+		successConfig_ = std::stoi(value["SuccessConfig"].asString());
+	if(!value["FailConfig"].isNull())
+		failConfig_ = std::stoi(value["FailConfig"].asString());
+	if(!value["RejectConfig"].isNull())
+		rejectConfig_ = std::stoi(value["RejectConfig"].asString());
 
 }
 
-int DescribeAlertConfigResult::getFailConfig()const
-{
-	return failConfig_;
-}
-
-int DescribeAlertConfigResult::getRejectConfig()const
-{
-	return rejectConfig_;
-}
-
-int DescribeAlertConfigResult::getSuccessConfig()const
-{
-	return successConfig_;
-}
-
+int DescribeAlertConfigResult::getFailConfig()const
+{
+	return failConfig_;
+}
+
+int DescribeAlertConfigResult::getRejectConfig()const
+{
+	return rejectConfig_;
+}
+
+int DescribeAlertConfigResult::getSuccessConfig()const
+{
+	return successConfig_;
+}
+

ess/src/model/DescribeCapacityHistoryResult.cc

@@ -40,48 +40,48 @@ void DescribeCapacityHistoryResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allCapacityHistoryItems = value["CapacityHistoryItems"]["CapacityHistoryModel"];
-	for (auto value : allCapacityHistoryItems)
-	{
-		CapacityHistoryModel capacityHistoryItemsObject;
-		if(!value["ScalingGroupId"].isNull())
-			capacityHistoryItemsObject.scalingGroupId = value["ScalingGroupId"].asString();
-		if(!value["TotalCapacity"].isNull())
-			capacityHistoryItemsObject.totalCapacity = std::stoi(value["TotalCapacity"].asString());
-		if(!value["AttachedCapacity"].isNull())
-			capacityHistoryItemsObject.attachedCapacity = std::stoi(value["AttachedCapacity"].asString());
-		if(!value["AutoCreatedCapacity"].isNull())
-			capacityHistoryItemsObject.autoCreatedCapacity = std::stoi(value["AutoCreatedCapacity"].asString());
-		if(!value["Timestamp"].isNull())
-			capacityHistoryItemsObject.timestamp = value["Timestamp"].asString();
-		capacityHistoryItems_.push_back(capacityHistoryItemsObject);
-	}
-	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());
+	auto allCapacityHistoryItems = value["CapacityHistoryItems"]["CapacityHistoryModel"];
+	for (auto value : allCapacityHistoryItems)
+	{
+		CapacityHistoryModel capacityHistoryItemsObject;
+		if(!value["ScalingGroupId"].isNull())
+			capacityHistoryItemsObject.scalingGroupId = value["ScalingGroupId"].asString();
+		if(!value["TotalCapacity"].isNull())
+			capacityHistoryItemsObject.totalCapacity = std::stoi(value["TotalCapacity"].asString());
+		if(!value["AttachedCapacity"].isNull())
+			capacityHistoryItemsObject.attachedCapacity = std::stoi(value["AttachedCapacity"].asString());
+		if(!value["AutoCreatedCapacity"].isNull())
+			capacityHistoryItemsObject.autoCreatedCapacity = std::stoi(value["AutoCreatedCapacity"].asString());
+		if(!value["Timestamp"].isNull())
+			capacityHistoryItemsObject.timestamp = value["Timestamp"].asString();
+		capacityHistoryItems_.push_back(capacityHistoryItemsObject);
+	}
+	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 DescribeCapacityHistoryResult::getTotalCount()const
-{
-	return totalCount_;
-}
-
-int DescribeCapacityHistoryResult::getPageSize()const
-{
-	return pageSize_;
-}
-
-int DescribeCapacityHistoryResult::getPageNumber()const
-{
-	return pageNumber_;
-}
-
-std::vector<DescribeCapacityHistoryResult::CapacityHistoryModel> DescribeCapacityHistoryResult::getCapacityHistoryItems()const
-{
-	return capacityHistoryItems_;
-}
-
+int DescribeCapacityHistoryResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeCapacityHistoryResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeCapacityHistoryResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeCapacityHistoryResult::CapacityHistoryModel> DescribeCapacityHistoryResult::getCapacityHistoryItems()const
+{
+	return capacityHistoryItems_;
+}
+

ess/src/model/DescribeLimitationResult.cc

@@ -40,69 +40,69 @@ void DescribeLimitationResult::parse(const std::string &payload)
 	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());
+	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 DescribeLimitationResult::getMaxNumberOfScalingRules()const
-{
-	return maxNumberOfScalingRules_;
-}
-
-int DescribeLimitationResult::getMaxNumberOfScalingInstances()const
-{
-	return maxNumberOfScalingInstances_;
-}
-
-int DescribeLimitationResult::getMaxNumberOfScheduledTasks()const
-{
-	return maxNumberOfScheduledTasks_;
-}
-
-int DescribeLimitationResult::getMaxNumberOfLoadBalancers()const
-{
-	return maxNumberOfLoadBalancers_;
-}
-
-int DescribeLimitationResult::getMaxNumberOfMinSize()const
-{
-	return maxNumberOfMinSize_;
-}
-
-int DescribeLimitationResult::getMaxNumberOfScalingGroups()const
-{
-	return maxNumberOfScalingGroups_;
-}
-
-int DescribeLimitationResult::getMaxNumberOfScalingConfigurations()const
-{
-	return maxNumberOfScalingConfigurations_;
-}
-
-int DescribeLimitationResult::getMaxNumberOfDBInstances()const
-{
-	return maxNumberOfDBInstances_;
-}
-
-int DescribeLimitationResult::getMaxNumberOfMaxSize()const
-{
-	return maxNumberOfMaxSize_;
-}
-
+int DescribeLimitationResult::getMaxNumberOfScalingRules()const
+{
+	return maxNumberOfScalingRules_;
+}
+
+int DescribeLimitationResult::getMaxNumberOfScalingInstances()const
+{
+	return maxNumberOfScalingInstances_;
+}
+
+int DescribeLimitationResult::getMaxNumberOfScheduledTasks()const
+{
+	return maxNumberOfScheduledTasks_;
+}
+
+int DescribeLimitationResult::getMaxNumberOfLoadBalancers()const
+{
+	return maxNumberOfLoadBalancers_;
+}
+
+int DescribeLimitationResult::getMaxNumberOfMinSize()const
+{
+	return maxNumberOfMinSize_;
+}
+
+int DescribeLimitationResult::getMaxNumberOfScalingGroups()const
+{
+	return maxNumberOfScalingGroups_;
+}
+
+int DescribeLimitationResult::getMaxNumberOfScalingConfigurations()const
+{
+	return maxNumberOfScalingConfigurations_;
+}
+
+int DescribeLimitationResult::getMaxNumberOfDBInstances()const
+{
+	return maxNumberOfDBInstances_;
+}
+
+int DescribeLimitationResult::getMaxNumberOfMaxSize()const
+{
+	return maxNumberOfMaxSize_;
+}
+

ess/src/model/DescribeNotificationConfigurationsRequest.cc

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ess/model/DescribeNotificationConfigurationsRequest.h>
+
+using AlibabaCloud::Ess::Model::DescribeNotificationConfigurationsRequest;
+
+DescribeNotificationConfigurationsRequest::DescribeNotificationConfigurationsRequest() :
+	RpcServiceRequest("ess", "2014-08-28", "DescribeNotificationConfigurations")
+{}
+
+DescribeNotificationConfigurationsRequest::~DescribeNotificationConfigurationsRequest()
+{}
+
+std::string DescribeNotificationConfigurationsRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeNotificationConfigurationsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeNotificationConfigurationsRequest::getScalingGroupId()const
+{
+	return scalingGroupId_;
+}
+
+void DescribeNotificationConfigurationsRequest::setScalingGroupId(const std::string& scalingGroupId)
+{
+	scalingGroupId_ = scalingGroupId;
+	setParameter("ScalingGroupId", scalingGroupId);
+}
+
+long DescribeNotificationConfigurationsRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeNotificationConfigurationsRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeNotificationConfigurationsRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeNotificationConfigurationsRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

ess/src/model/DescribeNotificationConfigurationsResult.cc

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

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

ess/src/model/DescribeNotificationTypesResult.cc

@@ -0,0 +1,53 @@
+/*
+ * 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/DescribeNotificationTypesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ess;
+using namespace AlibabaCloud::Ess::Model;
+
+DescribeNotificationTypesResult::DescribeNotificationTypesResult() :
+	ServiceResult()
+{}
+
+DescribeNotificationTypesResult::DescribeNotificationTypesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeNotificationTypesResult::~DescribeNotificationTypesResult()
+{}
+
+void DescribeNotificationTypesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allNotificationTypes = value["NotificationTypes"]["NotificationType"];
+	for (const auto &item : allNotificationTypes)
+		notificationTypes_.push_back(item.asString());
+
+}
+
+std::vector<std::string> DescribeNotificationTypesResult::getNotificationTypes()const
+{
+	return notificationTypes_;
+}
+

ess/src/model/DescribeRegionsResult.cc

@@ -40,23 +40,23 @@ void DescribeRegionsResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allRegions = value["Regions"]["Region"];
-	for (auto value : allRegions)
-	{
-		Region regionsObject;
-		if(!value["RegionId"].isNull())
-			regionsObject.regionId = value["RegionId"].asString();
-		if(!value["ClassicUnavailable"].isNull())
-			regionsObject.classicUnavailable = value["ClassicUnavailable"].asString() == "true";
-		if(!value["VpcUnavailable"].isNull())
-			regionsObject.vpcUnavailable = value["VpcUnavailable"].asString() == "true";
-		regions_.push_back(regionsObject);
-	}
+	auto allRegions = value["Regions"]["Region"];
+	for (auto value : allRegions)
+	{
+		Region regionsObject;
+		if(!value["RegionId"].isNull())
+			regionsObject.regionId = value["RegionId"].asString();
+		if(!value["ClassicUnavailable"].isNull())
+			regionsObject.classicUnavailable = value["ClassicUnavailable"].asString() == "true";
+		if(!value["VpcUnavailable"].isNull())
+			regionsObject.vpcUnavailable = value["VpcUnavailable"].asString() == "true";
+		regions_.push_back(regionsObject);
+	}
 
 }
 
-std::vector<DescribeRegionsResult::Region> DescribeRegionsResult::getRegions()const
-{
-	return regions_;
-}
-
+std::vector<DescribeRegionsResult::Region> DescribeRegionsResult::getRegions()const
+{
+	return regions_;
+}
+

ess/src/model/DescribeScalingActivitiesResult.cc

@@ -40,62 +40,62 @@ void DescribeScalingActivitiesResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allScalingActivities = value["ScalingActivities"]["ScalingActivity"];
-	for (auto value : allScalingActivities)
-	{
-		ScalingActivity scalingActivitiesObject;
-		if(!value["ScalingActivityId"].isNull())
-			scalingActivitiesObject.scalingActivityId = value["ScalingActivityId"].asString();
-		if(!value["ScalingGroupId"].isNull())
-			scalingActivitiesObject.scalingGroupId = value["ScalingGroupId"].asString();
-		if(!value["Description"].isNull())
-			scalingActivitiesObject.description = value["Description"].asString();
-		if(!value["Cause"].isNull())
-			scalingActivitiesObject.cause = value["Cause"].asString();
-		if(!value["StartTime"].isNull())
-			scalingActivitiesObject.startTime = value["StartTime"].asString();
-		if(!value["EndTime"].isNull())
-			scalingActivitiesObject.endTime = value["EndTime"].asString();
-		if(!value["Progress"].isNull())
-			scalingActivitiesObject.progress = std::stoi(value["Progress"].asString());
-		if(!value["StatusCode"].isNull())
-			scalingActivitiesObject.statusCode = value["StatusCode"].asString();
-		if(!value["StatusMessage"].isNull())
-			scalingActivitiesObject.statusMessage = value["StatusMessage"].asString();
-		if(!value["TotalCapacity"].isNull())
-			scalingActivitiesObject.totalCapacity = value["TotalCapacity"].asString();
-		if(!value["AttachedCapacity"].isNull())
-			scalingActivitiesObject.attachedCapacity = value["AttachedCapacity"].asString();
-		if(!value["AutoCreatedCapacity"].isNull())
-			scalingActivitiesObject.autoCreatedCapacity = value["AutoCreatedCapacity"].asString();
-		scalingActivities_.push_back(scalingActivitiesObject);
-	}
-	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());
+	auto allScalingActivities = value["ScalingActivities"]["ScalingActivity"];
+	for (auto value : allScalingActivities)
+	{
+		ScalingActivity scalingActivitiesObject;
+		if(!value["ScalingActivityId"].isNull())
+			scalingActivitiesObject.scalingActivityId = value["ScalingActivityId"].asString();
+		if(!value["ScalingGroupId"].isNull())
+			scalingActivitiesObject.scalingGroupId = value["ScalingGroupId"].asString();
+		if(!value["Description"].isNull())
+			scalingActivitiesObject.description = value["Description"].asString();
+		if(!value["Cause"].isNull())
+			scalingActivitiesObject.cause = value["Cause"].asString();
+		if(!value["StartTime"].isNull())
+			scalingActivitiesObject.startTime = value["StartTime"].asString();
+		if(!value["EndTime"].isNull())
+			scalingActivitiesObject.endTime = value["EndTime"].asString();
+		if(!value["Progress"].isNull())
+			scalingActivitiesObject.progress = std::stoi(value["Progress"].asString());
+		if(!value["StatusCode"].isNull())
+			scalingActivitiesObject.statusCode = value["StatusCode"].asString();
+		if(!value["StatusMessage"].isNull())
+			scalingActivitiesObject.statusMessage = value["StatusMessage"].asString();
+		if(!value["TotalCapacity"].isNull())
+			scalingActivitiesObject.totalCapacity = value["TotalCapacity"].asString();
+		if(!value["AttachedCapacity"].isNull())
+			scalingActivitiesObject.attachedCapacity = value["AttachedCapacity"].asString();
+		if(!value["AutoCreatedCapacity"].isNull())
+			scalingActivitiesObject.autoCreatedCapacity = value["AutoCreatedCapacity"].asString();
+		scalingActivities_.push_back(scalingActivitiesObject);
+	}
+	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 DescribeScalingActivitiesResult::getTotalCount()const
-{
-	return totalCount_;
-}
-
-int DescribeScalingActivitiesResult::getPageSize()const
-{
-	return pageSize_;
-}
-
-int DescribeScalingActivitiesResult::getPageNumber()const
-{
-	return pageNumber_;
-}
-
-std::vector<DescribeScalingActivitiesResult::ScalingActivity> DescribeScalingActivitiesResult::getScalingActivities()const
-{
-	return scalingActivities_;
-}
-
+int DescribeScalingActivitiesResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeScalingActivitiesResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeScalingActivitiesResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeScalingActivitiesResult::ScalingActivity> DescribeScalingActivitiesResult::getScalingActivities()const
+{
+	return scalingActivities_;
+}
+

ess/src/model/DescribeScalingActivityDetailResult.cc

@@ -40,20 +40,20 @@ void DescribeScalingActivityDetailResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["ScalingActivityId"].isNull())
-		scalingActivityId_ = value["ScalingActivityId"].asString();
-	if(!value["Detail"].isNull())
-		detail_ = value["Detail"].asString();
+	if(!value["ScalingActivityId"].isNull())
+		scalingActivityId_ = value["ScalingActivityId"].asString();
+	if(!value["Detail"].isNull())
+		detail_ = value["Detail"].asString();
 
 }
 
-std::string DescribeScalingActivityDetailResult::getScalingActivityId()const
-{
-	return scalingActivityId_;
-}
-
-std::string DescribeScalingActivityDetailResult::getDetail()const
-{
-	return detail_;
-}
-
+std::string DescribeScalingActivityDetailResult::getScalingActivityId()const
+{
+	return scalingActivityId_;
+}
+
+std::string DescribeScalingActivityDetailResult::getDetail()const
+{
+	return detail_;
+}
+

ess/src/model/DescribeScalingConfigurationsResult.cc

@@ -40,109 +40,121 @@ void DescribeScalingConfigurationsResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allScalingConfigurations = value["ScalingConfigurations"]["ScalingConfiguration"];
-	for (auto value : allScalingConfigurations)
-	{
-		ScalingConfiguration scalingConfigurationsObject;
-		if(!value["ScalingConfigurationId"].isNull())
-			scalingConfigurationsObject.scalingConfigurationId = value["ScalingConfigurationId"].asString();
-		if(!value["ScalingConfigurationName"].isNull())
-			scalingConfigurationsObject.scalingConfigurationName = value["ScalingConfigurationName"].asString();
-		if(!value["ScalingGroupId"].isNull())
-			scalingConfigurationsObject.scalingGroupId = value["ScalingGroupId"].asString();
-		if(!value["InstanceName"].isNull())
-			scalingConfigurationsObject.instanceName = value["InstanceName"].asString();
-		if(!value["ImageId"].isNull())
-			scalingConfigurationsObject.imageId = value["ImageId"].asString();
-		if(!value["InstanceType"].isNull())
-			scalingConfigurationsObject.instanceType = value["InstanceType"].asString();
-		if(!value["InstanceGeneration"].isNull())
-			scalingConfigurationsObject.instanceGeneration = value["InstanceGeneration"].asString();
-		if(!value["SecurityGroupId"].isNull())
-			scalingConfigurationsObject.securityGroupId = value["SecurityGroupId"].asString();
-		if(!value["IoOptimized"].isNull())
-			scalingConfigurationsObject.ioOptimized = value["IoOptimized"].asString();
-		if(!value["InternetChargeType"].isNull())
-			scalingConfigurationsObject.internetChargeType = value["InternetChargeType"].asString();
-		if(!value["InternetMaxBandwidthIn"].isNull())
-			scalingConfigurationsObject.internetMaxBandwidthIn = std::stoi(value["InternetMaxBandwidthIn"].asString());
-		if(!value["InternetMaxBandwidthOut"].isNull())
-			scalingConfigurationsObject.internetMaxBandwidthOut = std::stoi(value["InternetMaxBandwidthOut"].asString());
-		if(!value["SystemDiskCategory"].isNull())
-			scalingConfigurationsObject.systemDiskCategory = value["SystemDiskCategory"].asString();
-		if(!value["SystemDiskSize"].isNull())
-			scalingConfigurationsObject.systemDiskSize = std::stoi(value["SystemDiskSize"].asString());
-		if(!value["LifecycleState"].isNull())
-			scalingConfigurationsObject.lifecycleState = value["LifecycleState"].asString();
-		if(!value["CreationTime"].isNull())
-			scalingConfigurationsObject.creationTime = value["CreationTime"].asString();
-		if(!value["LoadBalancerWeight"].isNull())
-			scalingConfigurationsObject.loadBalancerWeight = std::stoi(value["LoadBalancerWeight"].asString());
-		if(!value["UserData"].isNull())
-			scalingConfigurationsObject.userData = value["UserData"].asString();
-		if(!value["KeyPairName"].isNull())
-			scalingConfigurationsObject.keyPairName = value["KeyPairName"].asString();
-		if(!value["RamRoleName"].isNull())
-			scalingConfigurationsObject.ramRoleName = value["RamRoleName"].asString();
-		if(!value["DeploymentSetId"].isNull())
-			scalingConfigurationsObject.deploymentSetId = value["DeploymentSetId"].asString();
-		if(!value["SecurityEnhancementStrategy"].isNull())
-			scalingConfigurationsObject.securityEnhancementStrategy = value["SecurityEnhancementStrategy"].asString();
-		auto allDataDisks = value["DataDisks"]["DataDisk"];
-		for (auto value : allDataDisks)
-		{
-			ScalingConfiguration::DataDisk dataDisksObject;
-			if(!value["Size"].isNull())
-				dataDisksObject.size = std::stoi(value["Size"].asString());
-			if(!value["Category"].isNull())
-				dataDisksObject.category = value["Category"].asString();
-			if(!value["SnapshotId"].isNull())
-				dataDisksObject.snapshotId = value["SnapshotId"].asString();
-			if(!value["Device"].isNull())
-				dataDisksObject.device = value["Device"].asString();
-			scalingConfigurationsObject.dataDisks.push_back(dataDisksObject);
-		}
-		auto allTags = value["Tags"]["Tag"];
-		for (auto value : allTags)
-		{
-			ScalingConfiguration::Tag tagsObject;
-			if(!value["Key"].isNull())
-				tagsObject.key = value["Key"].asString();
-			if(!value["Value"].isNull())
-				tagsObject.value = value["Value"].asString();
-			scalingConfigurationsObject.tags.push_back(tagsObject);
-		}
-		auto allInstanceTypes = value["InstanceTypes"]["InstanceType"];
-		for (auto value : allInstanceTypes)
-			scalingConfigurationsObject.instanceTypes.push_back(value.asString());
-		scalingConfigurations_.push_back(scalingConfigurationsObject);
-	}
-	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());
+	auto allScalingConfigurations = value["ScalingConfigurations"]["ScalingConfiguration"];
+	for (auto value : allScalingConfigurations)
+	{
+		ScalingConfiguration scalingConfigurationsObject;
+		if(!value["ScalingConfigurationId"].isNull())
+			scalingConfigurationsObject.scalingConfigurationId = value["ScalingConfigurationId"].asString();
+		if(!value["ScalingConfigurationName"].isNull())
+			scalingConfigurationsObject.scalingConfigurationName = value["ScalingConfigurationName"].asString();
+		if(!value["ScalingGroupId"].isNull())
+			scalingConfigurationsObject.scalingGroupId = value["ScalingGroupId"].asString();
+		if(!value["InstanceName"].isNull())
+			scalingConfigurationsObject.instanceName = value["InstanceName"].asString();
+		if(!value["ImageId"].isNull())
+			scalingConfigurationsObject.imageId = value["ImageId"].asString();
+		if(!value["InstanceType"].isNull())
+			scalingConfigurationsObject.instanceType = value["InstanceType"].asString();
+		if(!value["InstanceGeneration"].isNull())
+			scalingConfigurationsObject.instanceGeneration = value["InstanceGeneration"].asString();
+		if(!value["SecurityGroupId"].isNull())
+			scalingConfigurationsObject.securityGroupId = value["SecurityGroupId"].asString();
+		if(!value["IoOptimized"].isNull())
+			scalingConfigurationsObject.ioOptimized = value["IoOptimized"].asString();
+		if(!value["InternetChargeType"].isNull())
+			scalingConfigurationsObject.internetChargeType = value["InternetChargeType"].asString();
+		if(!value["InternetMaxBandwidthIn"].isNull())
+			scalingConfigurationsObject.internetMaxBandwidthIn = std::stoi(value["InternetMaxBandwidthIn"].asString());
+		if(!value["InternetMaxBandwidthOut"].isNull())
+			scalingConfigurationsObject.internetMaxBandwidthOut = std::stoi(value["InternetMaxBandwidthOut"].asString());
+		if(!value["SystemDiskCategory"].isNull())
+			scalingConfigurationsObject.systemDiskCategory = value["SystemDiskCategory"].asString();
+		if(!value["SystemDiskSize"].isNull())
+			scalingConfigurationsObject.systemDiskSize = std::stoi(value["SystemDiskSize"].asString());
+		if(!value["LifecycleState"].isNull())
+			scalingConfigurationsObject.lifecycleState = value["LifecycleState"].asString();
+		if(!value["CreationTime"].isNull())
+			scalingConfigurationsObject.creationTime = value["CreationTime"].asString();
+		if(!value["LoadBalancerWeight"].isNull())
+			scalingConfigurationsObject.loadBalancerWeight = std::stoi(value["LoadBalancerWeight"].asString());
+		if(!value["UserData"].isNull())
+			scalingConfigurationsObject.userData = value["UserData"].asString();
+		if(!value["KeyPairName"].isNull())
+			scalingConfigurationsObject.keyPairName = value["KeyPairName"].asString();
+		if(!value["RamRoleName"].isNull())
+			scalingConfigurationsObject.ramRoleName = value["RamRoleName"].asString();
+		if(!value["DeploymentSetId"].isNull())
+			scalingConfigurationsObject.deploymentSetId = value["DeploymentSetId"].asString();
+		if(!value["SecurityEnhancementStrategy"].isNull())
+			scalingConfigurationsObject.securityEnhancementStrategy = value["SecurityEnhancementStrategy"].asString();
+		if(!value["SpotStrategy"].isNull())
+			scalingConfigurationsObject.spotStrategy = value["SpotStrategy"].asString();
+		auto allDataDisks = value["DataDisks"]["DataDisk"];
+		for (auto value : allDataDisks)
+		{
+			ScalingConfiguration::DataDisk dataDisksObject;
+			if(!value["Size"].isNull())
+				dataDisksObject.size = std::stoi(value["Size"].asString());
+			if(!value["Category"].isNull())
+				dataDisksObject.category = value["Category"].asString();
+			if(!value["SnapshotId"].isNull())
+				dataDisksObject.snapshotId = value["SnapshotId"].asString();
+			if(!value["Device"].isNull())
+				dataDisksObject.device = value["Device"].asString();
+			scalingConfigurationsObject.dataDisks.push_back(dataDisksObject);
+		}
+		auto allTags = value["Tags"]["Tag"];
+		for (auto value : allTags)
+		{
+			ScalingConfiguration::Tag tagsObject;
+			if(!value["Key"].isNull())
+				tagsObject.key = value["Key"].asString();
+			if(!value["Value"].isNull())
+				tagsObject.value = value["Value"].asString();
+			scalingConfigurationsObject.tags.push_back(tagsObject);
+		}
+		auto allSpotPriceLimit = value["SpotPriceLimit"]["SpotPriceModel"];
+		for (auto value : allSpotPriceLimit)
+		{
+			ScalingConfiguration::SpotPriceModel spotPriceLimitObject;
+			if(!value["InstanceType"].isNull())
+				spotPriceLimitObject.instanceType = value["InstanceType"].asString();
+			if(!value["PriceLimit"].isNull())
+				spotPriceLimitObject.priceLimit = std::stof(value["PriceLimit"].asString());
+			scalingConfigurationsObject.spotPriceLimit.push_back(spotPriceLimitObject);
+		}
+		auto allInstanceTypes = value["InstanceTypes"]["InstanceType"];
+		for (auto value : allInstanceTypes)
+			scalingConfigurationsObject.instanceTypes.push_back(value.asString());
+		scalingConfigurations_.push_back(scalingConfigurationsObject);
+	}
+	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 DescribeScalingConfigurationsResult::getTotalCount()const
-{
-	return totalCount_;
-}
-
-int DescribeScalingConfigurationsResult::getPageSize()const
-{
-	return pageSize_;
-}
-
-int DescribeScalingConfigurationsResult::getPageNumber()const
-{
-	return pageNumber_;
-}
-
-std::vector<DescribeScalingConfigurationsResult::ScalingConfiguration> DescribeScalingConfigurationsResult::getScalingConfigurations()const
-{
-	return scalingConfigurations_;
-}
-
+int DescribeScalingConfigurationsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeScalingConfigurationsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeScalingConfigurationsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeScalingConfigurationsResult::ScalingConfiguration> DescribeScalingConfigurationsResult::getScalingConfigurations()const
+{
+	return scalingConfigurations_;
+}
+

ess/src/model/DescribeScalingGroupsResult.cc

@@ -40,82 +40,84 @@ void DescribeScalingGroupsResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allScalingGroups = value["ScalingGroups"]["ScalingGroup"];
-	for (auto value : allScalingGroups)
-	{
-		ScalingGroup scalingGroupsObject;
-		if(!value["DefaultCooldown"].isNull())
-			scalingGroupsObject.defaultCooldown = std::stoi(value["DefaultCooldown"].asString());
-		if(!value["MaxSize"].isNull())
-			scalingGroupsObject.maxSize = std::stoi(value["MaxSize"].asString());
-		if(!value["PendingCapacity"].isNull())
-			scalingGroupsObject.pendingCapacity = std::stoi(value["PendingCapacity"].asString());
-		if(!value["RemovingCapacity"].isNull())
-			scalingGroupsObject.removingCapacity = std::stoi(value["RemovingCapacity"].asString());
-		if(!value["ScalingGroupName"].isNull())
-			scalingGroupsObject.scalingGroupName = value["ScalingGroupName"].asString();
-		if(!value["ActiveCapacity"].isNull())
-			scalingGroupsObject.activeCapacity = std::stoi(value["ActiveCapacity"].asString());
-		if(!value["ActiveScalingConfigurationId"].isNull())
-			scalingGroupsObject.activeScalingConfigurationId = value["ActiveScalingConfigurationId"].asString();
-		if(!value["ScalingGroupId"].isNull())
-			scalingGroupsObject.scalingGroupId = value["ScalingGroupId"].asString();
-		if(!value["RegionId"].isNull())
-			scalingGroupsObject.regionId = value["RegionId"].asString();
-		if(!value["TotalCapacity"].isNull())
-			scalingGroupsObject.totalCapacity = std::stoi(value["TotalCapacity"].asString());
-		if(!value["MinSize"].isNull())
-			scalingGroupsObject.minSize = std::stoi(value["MinSize"].asString());
-		if(!value["LifecycleState"].isNull())
-			scalingGroupsObject.lifecycleState = value["LifecycleState"].asString();
-		if(!value["CreationTime"].isNull())
-			scalingGroupsObject.creationTime = value["CreationTime"].asString();
-		if(!value["ModificationTime"].isNull())
-			scalingGroupsObject.modificationTime = value["ModificationTime"].asString();
-		if(!value["VpcId"].isNull())
-			scalingGroupsObject.vpcId = value["VpcId"].asString();
-		if(!value["VSwitchId"].isNull())
-			scalingGroupsObject.vSwitchId = value["VSwitchId"].asString();
-		auto allVSwitchIds = value["VSwitchIds"]["VSwitchId"];
-		for (auto value : allVSwitchIds)
-			scalingGroupsObject.vSwitchIds.push_back(value.asString());
-		auto allRemovalPolicies = value["RemovalPolicies"]["RemovalPolicy"];
-		for (auto value : allRemovalPolicies)
-			scalingGroupsObject.removalPolicies.push_back(value.asString());
-		auto allDBInstanceIds = value["DBInstanceIds"]["DBInstanceId"];
-		for (auto value : allDBInstanceIds)
-			scalingGroupsObject.dBInstanceIds.push_back(value.asString());
-		auto allLoadBalancerIds = value["LoadBalancerIds"]["LoadBalancerId"];
-		for (auto value : allLoadBalancerIds)
-			scalingGroupsObject.loadBalancerIds.push_back(value.asString());
-		scalingGroups_.push_back(scalingGroupsObject);
-	}
-	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());
+	auto allScalingGroups = value["ScalingGroups"]["ScalingGroup"];
+	for (auto value : allScalingGroups)
+	{
+		ScalingGroup scalingGroupsObject;
+		if(!value["DefaultCooldown"].isNull())
+			scalingGroupsObject.defaultCooldown = std::stoi(value["DefaultCooldown"].asString());
+		if(!value["MaxSize"].isNull())
+			scalingGroupsObject.maxSize = std::stoi(value["MaxSize"].asString());
+		if(!value["PendingCapacity"].isNull())
+			scalingGroupsObject.pendingCapacity = std::stoi(value["PendingCapacity"].asString());
+		if(!value["RemovingCapacity"].isNull())
+			scalingGroupsObject.removingCapacity = std::stoi(value["RemovingCapacity"].asString());
+		if(!value["ScalingGroupName"].isNull())
+			scalingGroupsObject.scalingGroupName = value["ScalingGroupName"].asString();
+		if(!value["ActiveCapacity"].isNull())
+			scalingGroupsObject.activeCapacity = std::stoi(value["ActiveCapacity"].asString());
+		if(!value["StandbyCapacity"].isNull())
+			scalingGroupsObject.standbyCapacity = std::stoi(value["StandbyCapacity"].asString());
+		if(!value["ActiveScalingConfigurationId"].isNull())
+			scalingGroupsObject.activeScalingConfigurationId = value["ActiveScalingConfigurationId"].asString();
+		if(!value["ScalingGroupId"].isNull())
+			scalingGroupsObject.scalingGroupId = value["ScalingGroupId"].asString();
+		if(!value["RegionId"].isNull())
+			scalingGroupsObject.regionId = value["RegionId"].asString();
+		if(!value["TotalCapacity"].isNull())
+			scalingGroupsObject.totalCapacity = std::stoi(value["TotalCapacity"].asString());
+		if(!value["MinSize"].isNull())
+			scalingGroupsObject.minSize = std::stoi(value["MinSize"].asString());
+		if(!value["LifecycleState"].isNull())
+			scalingGroupsObject.lifecycleState = value["LifecycleState"].asString();
+		if(!value["CreationTime"].isNull())
+			scalingGroupsObject.creationTime = value["CreationTime"].asString();
+		if(!value["ModificationTime"].isNull())
+			scalingGroupsObject.modificationTime = value["ModificationTime"].asString();
+		if(!value["VpcId"].isNull())
+			scalingGroupsObject.vpcId = value["VpcId"].asString();
+		if(!value["VSwitchId"].isNull())
+			scalingGroupsObject.vSwitchId = value["VSwitchId"].asString();
+		auto allVSwitchIds = value["VSwitchIds"]["VSwitchId"];
+		for (auto value : allVSwitchIds)
+			scalingGroupsObject.vSwitchIds.push_back(value.asString());
+		auto allRemovalPolicies = value["RemovalPolicies"]["RemovalPolicy"];
+		for (auto value : allRemovalPolicies)
+			scalingGroupsObject.removalPolicies.push_back(value.asString());
+		auto allDBInstanceIds = value["DBInstanceIds"]["DBInstanceId"];
+		for (auto value : allDBInstanceIds)
+			scalingGroupsObject.dBInstanceIds.push_back(value.asString());
+		auto allLoadBalancerIds = value["LoadBalancerIds"]["LoadBalancerId"];
+		for (auto value : allLoadBalancerIds)
+			scalingGroupsObject.loadBalancerIds.push_back(value.asString());
+		scalingGroups_.push_back(scalingGroupsObject);
+	}
+	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 DescribeScalingGroupsResult::getTotalCount()const
-{
-	return totalCount_;
-}
-
-std::vector<DescribeScalingGroupsResult::ScalingGroup> DescribeScalingGroupsResult::getScalingGroups()const
-{
-	return scalingGroups_;
-}
-
-int DescribeScalingGroupsResult::getPageSize()const
-{
-	return pageSize_;
-}
-
-int DescribeScalingGroupsResult::getPageNumber()const
-{
-	return pageNumber_;
-}
-
+int DescribeScalingGroupsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::vector<DescribeScalingGroupsResult::ScalingGroup> DescribeScalingGroupsResult::getScalingGroups()const
+{
+	return scalingGroups_;
+}
+
+int DescribeScalingGroupsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeScalingGroupsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

ess/src/model/DescribeScalingInstancesResult.cc

@@ -40,54 +40,54 @@ void DescribeScalingInstancesResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allScalingInstances = value["ScalingInstances"]["ScalingInstance"];
-	for (auto value : allScalingInstances)
-	{
-		ScalingInstance scalingInstancesObject;
-		if(!value["InstanceId"].isNull())
-			scalingInstancesObject.instanceId = value["InstanceId"].asString();
-		if(!value["ScalingConfigurationId"].isNull())
-			scalingInstancesObject.scalingConfigurationId = value["ScalingConfigurationId"].asString();
-		if(!value["ScalingGroupId"].isNull())
-			scalingInstancesObject.scalingGroupId = value["ScalingGroupId"].asString();
-		if(!value["HealthStatus"].isNull())
-			scalingInstancesObject.healthStatus = value["HealthStatus"].asString();
-		if(!value["LoadBalancerWeight"].isNull())
-			scalingInstancesObject.loadBalancerWeight = std::stoi(value["LoadBalancerWeight"].asString());
-		if(!value["LifecycleState"].isNull())
-			scalingInstancesObject.lifecycleState = value["LifecycleState"].asString();
-		if(!value["CreationTime"].isNull())
-			scalingInstancesObject.creationTime = value["CreationTime"].asString();
-		if(!value["CreationType"].isNull())
-			scalingInstancesObject.creationType = value["CreationType"].asString();
-		scalingInstances_.push_back(scalingInstancesObject);
-	}
-	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());
+	auto allScalingInstances = value["ScalingInstances"]["ScalingInstance"];
+	for (auto value : allScalingInstances)
+	{
+		ScalingInstance scalingInstancesObject;
+		if(!value["InstanceId"].isNull())
+			scalingInstancesObject.instanceId = value["InstanceId"].asString();
+		if(!value["ScalingConfigurationId"].isNull())
+			scalingInstancesObject.scalingConfigurationId = value["ScalingConfigurationId"].asString();
+		if(!value["ScalingGroupId"].isNull())
+			scalingInstancesObject.scalingGroupId = value["ScalingGroupId"].asString();
+		if(!value["HealthStatus"].isNull())
+			scalingInstancesObject.healthStatus = value["HealthStatus"].asString();
+		if(!value["LoadBalancerWeight"].isNull())
+			scalingInstancesObject.loadBalancerWeight = std::stoi(value["LoadBalancerWeight"].asString());
+		if(!value["LifecycleState"].isNull())
+			scalingInstancesObject.lifecycleState = value["LifecycleState"].asString();
+		if(!value["CreationTime"].isNull())
+			scalingInstancesObject.creationTime = value["CreationTime"].asString();
+		if(!value["CreationType"].isNull())
+			scalingInstancesObject.creationType = value["CreationType"].asString();
+		scalingInstances_.push_back(scalingInstancesObject);
+	}
+	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 DescribeScalingInstancesResult::getTotalCount()const
-{
-	return totalCount_;
-}
-
-int DescribeScalingInstancesResult::getPageSize()const
-{
-	return pageSize_;
-}
-
-int DescribeScalingInstancesResult::getPageNumber()const
-{
-	return pageNumber_;
-}
-
-std::vector<DescribeScalingInstancesResult::ScalingInstance> DescribeScalingInstancesResult::getScalingInstances()const
-{
-	return scalingInstances_;
-}
-
+int DescribeScalingInstancesResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeScalingInstancesResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeScalingInstancesResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeScalingInstancesResult::ScalingInstance> DescribeScalingInstancesResult::getScalingInstances()const
+{
+	return scalingInstances_;
+}
+

ess/src/model/DescribeScalingRulesResult.cc

@@ -40,56 +40,56 @@ void DescribeScalingRulesResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allScalingRules = value["ScalingRules"]["ScalingRule"];
-	for (auto value : allScalingRules)
-	{
-		ScalingRule scalingRulesObject;
-		if(!value["ScalingRuleId"].isNull())
-			scalingRulesObject.scalingRuleId = value["ScalingRuleId"].asString();
-		if(!value["ScalingGroupId"].isNull())
-			scalingRulesObject.scalingGroupId = value["ScalingGroupId"].asString();
-		if(!value["ScalingRuleName"].isNull())
-			scalingRulesObject.scalingRuleName = value["ScalingRuleName"].asString();
-		if(!value["Cooldown"].isNull())
-			scalingRulesObject.cooldown = std::stoi(value["Cooldown"].asString());
-		if(!value["AdjustmentType"].isNull())
-			scalingRulesObject.adjustmentType = value["AdjustmentType"].asString();
-		if(!value["AdjustmentValue"].isNull())
-			scalingRulesObject.adjustmentValue = std::stoi(value["AdjustmentValue"].asString());
-		if(!value["MinSize"].isNull())
-			scalingRulesObject.minSize = std::stoi(value["MinSize"].asString());
-		if(!value["MaxSize"].isNull())
-			scalingRulesObject.maxSize = std::stoi(value["MaxSize"].asString());
-		if(!value["ScalingRuleAri"].isNull())
-			scalingRulesObject.scalingRuleAri = value["ScalingRuleAri"].asString();
-		scalingRules_.push_back(scalingRulesObject);
-	}
-	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());
+	auto allScalingRules = value["ScalingRules"]["ScalingRule"];
+	for (auto value : allScalingRules)
+	{
+		ScalingRule scalingRulesObject;
+		if(!value["ScalingRuleId"].isNull())
+			scalingRulesObject.scalingRuleId = value["ScalingRuleId"].asString();
+		if(!value["ScalingGroupId"].isNull())
+			scalingRulesObject.scalingGroupId = value["ScalingGroupId"].asString();
+		if(!value["ScalingRuleName"].isNull())
+			scalingRulesObject.scalingRuleName = value["ScalingRuleName"].asString();
+		if(!value["Cooldown"].isNull())
+			scalingRulesObject.cooldown = std::stoi(value["Cooldown"].asString());
+		if(!value["AdjustmentType"].isNull())
+			scalingRulesObject.adjustmentType = value["AdjustmentType"].asString();
+		if(!value["AdjustmentValue"].isNull())
+			scalingRulesObject.adjustmentValue = std::stoi(value["AdjustmentValue"].asString());
+		if(!value["MinSize"].isNull())
+			scalingRulesObject.minSize = std::stoi(value["MinSize"].asString());
+		if(!value["MaxSize"].isNull())
+			scalingRulesObject.maxSize = std::stoi(value["MaxSize"].asString());
+		if(!value["ScalingRuleAri"].isNull())
+			scalingRulesObject.scalingRuleAri = value["ScalingRuleAri"].asString();
+		scalingRules_.push_back(scalingRulesObject);
+	}
+	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());
 
 }
 
-std::vector<DescribeScalingRulesResult::ScalingRule> DescribeScalingRulesResult::getScalingRules()const
-{
-	return scalingRules_;
-}
-
-int DescribeScalingRulesResult::getTotalCount()const
-{
-	return totalCount_;
-}
-
-int DescribeScalingRulesResult::getPageSize()const
-{
-	return pageSize_;
-}
-
-int DescribeScalingRulesResult::getPageNumber()const
-{
-	return pageNumber_;
-}
-
+std::vector<DescribeScalingRulesResult::ScalingRule> DescribeScalingRulesResult::getScalingRules()const
+{
+	return scalingRules_;
+}
+
+int DescribeScalingRulesResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeScalingRulesResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeScalingRulesResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

ess/src/model/DescribeScheduledTasksResult.cc

@@ -40,58 +40,58 @@ void DescribeScheduledTasksResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allScheduledTasks = value["ScheduledTasks"]["ScheduledTask"];
-	for (auto value : allScheduledTasks)
-	{
-		ScheduledTask scheduledTasksObject;
-		if(!value["ScheduledTaskId"].isNull())
-			scheduledTasksObject.scheduledTaskId = value["ScheduledTaskId"].asString();
-		if(!value["ScheduledTaskName"].isNull())
-			scheduledTasksObject.scheduledTaskName = value["ScheduledTaskName"].asString();
-		if(!value["Description"].isNull())
-			scheduledTasksObject.description = value["Description"].asString();
-		if(!value["ScheduledAction"].isNull())
-			scheduledTasksObject.scheduledAction = value["ScheduledAction"].asString();
-		if(!value["RecurrenceEndTime"].isNull())
-			scheduledTasksObject.recurrenceEndTime = value["RecurrenceEndTime"].asString();
-		if(!value["LaunchTime"].isNull())
-			scheduledTasksObject.launchTime = value["LaunchTime"].asString();
-		if(!value["RecurrenceType"].isNull())
-			scheduledTasksObject.recurrenceType = value["RecurrenceType"].asString();
-		if(!value["RecurrenceValue"].isNull())
-			scheduledTasksObject.recurrenceValue = value["RecurrenceValue"].asString();
-		if(!value["LaunchExpirationTime"].isNull())
-			scheduledTasksObject.launchExpirationTime = std::stoi(value["LaunchExpirationTime"].asString());
-		if(!value["TaskEnabled"].isNull())
-			scheduledTasksObject.taskEnabled = value["TaskEnabled"].asString() == "true";
-		scheduledTasks_.push_back(scheduledTasksObject);
-	}
-	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());
+	auto allScheduledTasks = value["ScheduledTasks"]["ScheduledTask"];
+	for (auto value : allScheduledTasks)
+	{
+		ScheduledTask scheduledTasksObject;
+		if(!value["ScheduledTaskId"].isNull())
+			scheduledTasksObject.scheduledTaskId = value["ScheduledTaskId"].asString();
+		if(!value["ScheduledTaskName"].isNull())
+			scheduledTasksObject.scheduledTaskName = value["ScheduledTaskName"].asString();
+		if(!value["Description"].isNull())
+			scheduledTasksObject.description = value["Description"].asString();
+		if(!value["ScheduledAction"].isNull())
+			scheduledTasksObject.scheduledAction = value["ScheduledAction"].asString();
+		if(!value["RecurrenceEndTime"].isNull())
+			scheduledTasksObject.recurrenceEndTime = value["RecurrenceEndTime"].asString();
+		if(!value["LaunchTime"].isNull())
+			scheduledTasksObject.launchTime = value["LaunchTime"].asString();
+		if(!value["RecurrenceType"].isNull())
+			scheduledTasksObject.recurrenceType = value["RecurrenceType"].asString();
+		if(!value["RecurrenceValue"].isNull())
+			scheduledTasksObject.recurrenceValue = value["RecurrenceValue"].asString();
+		if(!value["LaunchExpirationTime"].isNull())
+			scheduledTasksObject.launchExpirationTime = std::stoi(value["LaunchExpirationTime"].asString());
+		if(!value["TaskEnabled"].isNull())
+			scheduledTasksObject.taskEnabled = value["TaskEnabled"].asString() == "true";
+		scheduledTasks_.push_back(scheduledTasksObject);
+	}
+	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 DescribeScheduledTasksResult::getTotalCount()const
-{
-	return totalCount_;
-}
-
-int DescribeScheduledTasksResult::getPageSize()const
-{
-	return pageSize_;
-}
-
-int DescribeScheduledTasksResult::getPageNumber()const
-{
-	return pageNumber_;
-}
-
-std::vector<DescribeScheduledTasksResult::ScheduledTask> DescribeScheduledTasksResult::getScheduledTasks()const
-{
-	return scheduledTasks_;
-}
-
+int DescribeScheduledTasksResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeScheduledTasksResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeScheduledTasksResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeScheduledTasksResult::ScheduledTask> DescribeScheduledTasksResult::getScheduledTasks()const
+{
+	return scheduledTasks_;
+}
+

ess/src/model/DetachInstancesResult.cc

@@ -40,13 +40,13 @@ void DetachInstancesResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["ScalingActivityId"].isNull())
-		scalingActivityId_ = value["ScalingActivityId"].asString();
+	if(!value["ScalingActivityId"].isNull())
+		scalingActivityId_ = value["ScalingActivityId"].asString();
 
 }
 
-std::string DetachInstancesResult::getScalingActivityId()const
-{
-	return scalingActivityId_;
-}
-
+std::string DetachInstancesResult::getScalingActivityId()const
+{
+	return scalingActivityId_;
+}
+

ess/src/model/EnterStandbyRequest.cc

@@ -0,0 +1,83 @@
+/*
+ * 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/EnterStandbyRequest.h>
+
+using AlibabaCloud::Ess::Model::EnterStandbyRequest;
+
+EnterStandbyRequest::EnterStandbyRequest() :
+	RpcServiceRequest("ess", "2014-08-28", "EnterStandby")
+{}
+
+EnterStandbyRequest::~EnterStandbyRequest()
+{}
+
+std::vector<std::string> EnterStandbyRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void EnterStandbyRequest::setInstanceId(const std::vector<std::string>& instanceId)
+{
+	instanceId_ = instanceId;
+	for(int i = 0; i!= instanceId.size(); i++)
+		setParameter("InstanceId."+ std::to_string(i), instanceId.at(i));
+}
+
+std::string EnterStandbyRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void EnterStandbyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string EnterStandbyRequest::getScalingGroupId()const
+{
+	return scalingGroupId_;
+}
+
+void EnterStandbyRequest::setScalingGroupId(const std::string& scalingGroupId)
+{
+	scalingGroupId_ = scalingGroupId;
+	setParameter("ScalingGroupId", scalingGroupId);
+}
+
+long EnterStandbyRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void EnterStandbyRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string EnterStandbyRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void EnterStandbyRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

ess/src/model/EnterStandbyResult.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/EnterStandbyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ess;
+using namespace AlibabaCloud::Ess::Model;
+
+EnterStandbyResult::EnterStandbyResult() :
+	ServiceResult()
+{}
+
+EnterStandbyResult::EnterStandbyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+EnterStandbyResult::~EnterStandbyResult()
+{}
+
+void EnterStandbyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+
+}
+

ess/src/model/ExecuteScalingRuleResult.cc

@@ -40,13 +40,13 @@ void ExecuteScalingRuleResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["ScalingActivityId"].isNull())
-		scalingActivityId_ = value["ScalingActivityId"].asString();
+	if(!value["ScalingActivityId"].isNull())
+		scalingActivityId_ = value["ScalingActivityId"].asString();
 
 }
 
-std::string ExecuteScalingRuleResult::getScalingActivityId()const
-{
-	return scalingActivityId_;
-}
-
+std::string ExecuteScalingRuleResult::getScalingActivityId()const
+{
+	return scalingActivityId_;
+}
+

ess/src/model/ExitStandbyRequest.cc

@@ -0,0 +1,83 @@
+/*
+ * 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/ExitStandbyRequest.h>
+
+using AlibabaCloud::Ess::Model::ExitStandbyRequest;
+
+ExitStandbyRequest::ExitStandbyRequest() :
+	RpcServiceRequest("ess", "2014-08-28", "ExitStandby")
+{}
+
+ExitStandbyRequest::~ExitStandbyRequest()
+{}
+
+std::vector<std::string> ExitStandbyRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void ExitStandbyRequest::setInstanceId(const std::vector<std::string>& instanceId)
+{
+	instanceId_ = instanceId;
+	for(int i = 0; i!= instanceId.size(); i++)
+		setParameter("InstanceId."+ std::to_string(i), instanceId.at(i));
+}
+
+std::string ExitStandbyRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void ExitStandbyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string ExitStandbyRequest::getScalingGroupId()const
+{
+	return scalingGroupId_;
+}
+
+void ExitStandbyRequest::setScalingGroupId(const std::string& scalingGroupId)
+{
+	scalingGroupId_ = scalingGroupId;
+	setParameter("ScalingGroupId", scalingGroupId);
+}
+
+long ExitStandbyRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ExitStandbyRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string ExitStandbyRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void ExitStandbyRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

ess/src/model/ExitStandbyResult.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/ExitStandbyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ess;
+using namespace AlibabaCloud::Ess::Model;
+
+ExitStandbyResult::ExitStandbyResult() :
+	ServiceResult()
+{}
+
+ExitStandbyResult::ExitStandbyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ExitStandbyResult::~ExitStandbyResult()
+{}
+
+void ExitStandbyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+
+}
+

ess/src/model/ModifyNotificationConfigurationRequest.cc

@@ -0,0 +1,94 @@
+/*
+ * 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/ModifyNotificationConfigurationRequest.h>
+
+using AlibabaCloud::Ess::Model::ModifyNotificationConfigurationRequest;
+
+ModifyNotificationConfigurationRequest::ModifyNotificationConfigurationRequest() :
+	RpcServiceRequest("ess", "2014-08-28", "ModifyNotificationConfiguration")
+{}
+
+ModifyNotificationConfigurationRequest::~ModifyNotificationConfigurationRequest()
+{}
+
+std::string ModifyNotificationConfigurationRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void ModifyNotificationConfigurationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string ModifyNotificationConfigurationRequest::getScalingGroupId()const
+{
+	return scalingGroupId_;
+}
+
+void ModifyNotificationConfigurationRequest::setScalingGroupId(const std::string& scalingGroupId)
+{
+	scalingGroupId_ = scalingGroupId;
+	setParameter("ScalingGroupId", scalingGroupId);
+}
+
+std::string ModifyNotificationConfigurationRequest::getNotificationArn()const
+{
+	return notificationArn_;
+}
+
+void ModifyNotificationConfigurationRequest::setNotificationArn(const std::string& notificationArn)
+{
+	notificationArn_ = notificationArn;
+	setParameter("NotificationArn", notificationArn);
+}
+
+std::vector<std::string> ModifyNotificationConfigurationRequest::getNotificationType()const
+{
+	return notificationType_;
+}
+
+void ModifyNotificationConfigurationRequest::setNotificationType(const std::vector<std::string>& notificationType)
+{
+	notificationType_ = notificationType;
+	for(int i = 0; i!= notificationType.size(); i++)
+		setParameter("NotificationType."+ std::to_string(i), notificationType.at(i));
+}
+
+long ModifyNotificationConfigurationRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ModifyNotificationConfigurationRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string ModifyNotificationConfigurationRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void ModifyNotificationConfigurationRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

ess/src/model/ModifyNotificationConfigurationResult.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/ModifyNotificationConfigurationResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ess;
+using namespace AlibabaCloud::Ess::Model;
+
+ModifyNotificationConfigurationResult::ModifyNotificationConfigurationResult() :
+	ServiceResult()
+{}
+
+ModifyNotificationConfigurationResult::ModifyNotificationConfigurationResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ModifyNotificationConfigurationResult::~ModifyNotificationConfigurationResult()
+{}
+
+void ModifyNotificationConfigurationResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+
+}
+

ess/src/model/RemoveInstancesResult.cc

@@ -40,13 +40,13 @@ void RemoveInstancesResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	if(!value["ScalingActivityId"].isNull())
-		scalingActivityId_ = value["ScalingActivityId"].asString();
+	if(!value["ScalingActivityId"].isNull())
+		scalingActivityId_ = value["ScalingActivityId"].asString();
 
 }
 
-std::string RemoveInstancesResult::getScalingActivityId()const
-{
-	return scalingActivityId_;
-}
-
+std::string RemoveInstancesResult::getScalingActivityId()const
+{
+	return scalingActivityId_;
+}
+