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

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

CHANGELOG

@@ -1,3 +1,7 @@
+2019-04-04 Version: 1.35.5
+1, ScalingConf systemDisk add DiskName and Description  parameters.
+2, ScalingConf dataDisk add DiskName & Description & Encrypted & KMSKeyId  parameters.
+
 2019-04-03 Version: 1.35.4
 1, Add interfaces related to vulnerability whitelist
 2, Add interfaces related to vulnerability auto-del configuration

VERSION

@@ -1 +1 @@
-1.35.4
+1.35.5

ess/CMakeLists.txt

@@ -23,6 +23,8 @@ set(ess_public_header
 set(ess_public_header_model 
 	include/alibabacloud/ess/model/EnterStandbyRequest.h
 	include/alibabacloud/ess/model/EnterStandbyResult.h
+	include/alibabacloud/ess/model/DetachVServerGroupsRequest.h
+	include/alibabacloud/ess/model/DetachVServerGroupsResult.h
 	include/alibabacloud/ess/model/ModifyScalingGroupRequest.h
 	include/alibabacloud/ess/model/ModifyScalingGroupResult.h
 	include/alibabacloud/ess/model/RebalanceInstancesRequest.h
@@ -33,6 +35,8 @@ set(ess_public_header_model
 	include/alibabacloud/ess/model/CreateScheduledTaskResult.h
 	include/alibabacloud/ess/model/DeleteScheduledTaskRequest.h
 	include/alibabacloud/ess/model/DeleteScheduledTaskResult.h
+	include/alibabacloud/ess/model/AttachVServerGroupsRequest.h
+	include/alibabacloud/ess/model/AttachVServerGroupsResult.h
 	include/alibabacloud/ess/model/ModifyNotificationConfigurationRequest.h
 	include/alibabacloud/ess/model/ModifyNotificationConfigurationResult.h
 	include/alibabacloud/ess/model/CreateScalingRuleRequest.h
@@ -49,16 +53,18 @@ set(ess_public_header_model
 	include/alibabacloud/ess/model/DescribeScalingInstancesResult.h
 	include/alibabacloud/ess/model/DescribeCapacityHistoryRequest.h
 	include/alibabacloud/ess/model/DescribeCapacityHistoryResult.h
-	include/alibabacloud/ess/model/DescribeScheduledTasksRequest.h
-	include/alibabacloud/ess/model/DescribeScheduledTasksResult.h
 	include/alibabacloud/ess/model/DeleteLifecycleHookRequest.h
 	include/alibabacloud/ess/model/DeleteLifecycleHookResult.h
+	include/alibabacloud/ess/model/DescribeScheduledTasksRequest.h
+	include/alibabacloud/ess/model/DescribeScheduledTasksResult.h
 	include/alibabacloud/ess/model/DeleteNotificationConfigurationRequest.h
 	include/alibabacloud/ess/model/DeleteNotificationConfigurationResult.h
 	include/alibabacloud/ess/model/DescribeLifecycleHooksRequest.h
 	include/alibabacloud/ess/model/DescribeLifecycleHooksResult.h
 	include/alibabacloud/ess/model/ModifyAlarmRequest.h
 	include/alibabacloud/ess/model/ModifyAlarmResult.h
+	include/alibabacloud/ess/model/DescribeAccountAttributesRequest.h
+	include/alibabacloud/ess/model/DescribeAccountAttributesResult.h
 	include/alibabacloud/ess/model/DeleteAlarmRequest.h
 	include/alibabacloud/ess/model/DeleteAlarmResult.h
 	include/alibabacloud/ess/model/DescribeScalingActivityDetailRequest.h
@@ -69,10 +75,10 @@ set(ess_public_header_model
 	include/alibabacloud/ess/model/VerifyUserResult.h
 	include/alibabacloud/ess/model/DescribeAlarmsRequest.h
 	include/alibabacloud/ess/model/DescribeAlarmsResult.h
-	include/alibabacloud/ess/model/AttachInstancesRequest.h
-	include/alibabacloud/ess/model/AttachInstancesResult.h
 	include/alibabacloud/ess/model/DescribeScalingGroupsRequest.h
 	include/alibabacloud/ess/model/DescribeScalingGroupsResult.h
+	include/alibabacloud/ess/model/AttachInstancesRequest.h
+	include/alibabacloud/ess/model/AttachInstancesResult.h
 	include/alibabacloud/ess/model/DescribeScalingActivitiesRequest.h
 	include/alibabacloud/ess/model/DescribeScalingActivitiesResult.h
 	include/alibabacloud/ess/model/ExitStandbyRequest.h
@@ -111,10 +117,10 @@ set(ess_public_header_model
 	include/alibabacloud/ess/model/AttachLoadBalancersResult.h
 	include/alibabacloud/ess/model/CompleteLifecycleActionRequest.h
 	include/alibabacloud/ess/model/CompleteLifecycleActionResult.h
-	include/alibabacloud/ess/model/ModifyScalingConfigurationRequest.h
-	include/alibabacloud/ess/model/ModifyScalingConfigurationResult.h
 	include/alibabacloud/ess/model/DetachInstancesRequest.h
 	include/alibabacloud/ess/model/DetachInstancesResult.h
+	include/alibabacloud/ess/model/ModifyScalingConfigurationRequest.h
+	include/alibabacloud/ess/model/ModifyScalingConfigurationResult.h
 	include/alibabacloud/ess/model/DescribeLimitationRequest.h
 	include/alibabacloud/ess/model/DescribeLimitationResult.h
 	include/alibabacloud/ess/model/DescribeAlertConfigRequest.h
@@ -142,6 +148,8 @@ set(ess_src
 	src/EssClient.cc
 	src/model/EnterStandbyRequest.cc
 	src/model/EnterStandbyResult.cc
+	src/model/DetachVServerGroupsRequest.cc
+	src/model/DetachVServerGroupsResult.cc
 	src/model/ModifyScalingGroupRequest.cc
 	src/model/ModifyScalingGroupResult.cc
 	src/model/RebalanceInstancesRequest.cc
@@ -152,6 +160,8 @@ set(ess_src
 	src/model/CreateScheduledTaskResult.cc
 	src/model/DeleteScheduledTaskRequest.cc
 	src/model/DeleteScheduledTaskResult.cc
+	src/model/AttachVServerGroupsRequest.cc
+	src/model/AttachVServerGroupsResult.cc
 	src/model/ModifyNotificationConfigurationRequest.cc
 	src/model/ModifyNotificationConfigurationResult.cc
 	src/model/CreateScalingRuleRequest.cc
@@ -168,16 +178,18 @@ set(ess_src
 	src/model/DescribeScalingInstancesResult.cc
 	src/model/DescribeCapacityHistoryRequest.cc
 	src/model/DescribeCapacityHistoryResult.cc
-	src/model/DescribeScheduledTasksRequest.cc
-	src/model/DescribeScheduledTasksResult.cc
 	src/model/DeleteLifecycleHookRequest.cc
 	src/model/DeleteLifecycleHookResult.cc
+	src/model/DescribeScheduledTasksRequest.cc
+	src/model/DescribeScheduledTasksResult.cc
 	src/model/DeleteNotificationConfigurationRequest.cc
 	src/model/DeleteNotificationConfigurationResult.cc
 	src/model/DescribeLifecycleHooksRequest.cc
 	src/model/DescribeLifecycleHooksResult.cc
 	src/model/ModifyAlarmRequest.cc
 	src/model/ModifyAlarmResult.cc
+	src/model/DescribeAccountAttributesRequest.cc
+	src/model/DescribeAccountAttributesResult.cc
 	src/model/DeleteAlarmRequest.cc
 	src/model/DeleteAlarmResult.cc
 	src/model/DescribeScalingActivityDetailRequest.cc
@@ -188,10 +200,10 @@ set(ess_src
 	src/model/VerifyUserResult.cc
 	src/model/DescribeAlarmsRequest.cc
 	src/model/DescribeAlarmsResult.cc
-	src/model/AttachInstancesRequest.cc
-	src/model/AttachInstancesResult.cc
 	src/model/DescribeScalingGroupsRequest.cc
 	src/model/DescribeScalingGroupsResult.cc
+	src/model/AttachInstancesRequest.cc
+	src/model/AttachInstancesResult.cc
 	src/model/DescribeScalingActivitiesRequest.cc
 	src/model/DescribeScalingActivitiesResult.cc
 	src/model/ExitStandbyRequest.cc
@@ -230,10 +242,10 @@ set(ess_src
 	src/model/AttachLoadBalancersResult.cc
 	src/model/CompleteLifecycleActionRequest.cc
 	src/model/CompleteLifecycleActionResult.cc
-	src/model/ModifyScalingConfigurationRequest.cc
-	src/model/ModifyScalingConfigurationResult.cc
 	src/model/DetachInstancesRequest.cc
 	src/model/DetachInstancesResult.cc
+	src/model/ModifyScalingConfigurationRequest.cc
+	src/model/ModifyScalingConfigurationResult.cc
 	src/model/DescribeLimitationRequest.cc
 	src/model/DescribeLimitationResult.cc
 	src/model/DescribeAlertConfigRequest.cc
@@ -311,4 +323,4 @@ install(TARGETS ess
 	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
 	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
 	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-	)
+	)

ess/include/alibabacloud/ess/EssClient.h

@@ -24,6 +24,8 @@
 #include "EssExport.h"
 #include "model/EnterStandbyRequest.h"
 #include "model/EnterStandbyResult.h"
+#include "model/DetachVServerGroupsRequest.h"
+#include "model/DetachVServerGroupsResult.h"
 #include "model/ModifyScalingGroupRequest.h"
 #include "model/ModifyScalingGroupResult.h"
 #include "model/RebalanceInstancesRequest.h"
@@ -34,6 +36,8 @@
 #include "model/CreateScheduledTaskResult.h"
 #include "model/DeleteScheduledTaskRequest.h"
 #include "model/DeleteScheduledTaskResult.h"
+#include "model/AttachVServerGroupsRequest.h"
+#include "model/AttachVServerGroupsResult.h"
 #include "model/ModifyNotificationConfigurationRequest.h"
 #include "model/ModifyNotificationConfigurationResult.h"
 #include "model/CreateScalingRuleRequest.h"
@@ -50,16 +54,18 @@
 #include "model/DescribeScalingInstancesResult.h"
 #include "model/DescribeCapacityHistoryRequest.h"
 #include "model/DescribeCapacityHistoryResult.h"
-#include "model/DescribeScheduledTasksRequest.h"
-#include "model/DescribeScheduledTasksResult.h"
 #include "model/DeleteLifecycleHookRequest.h"
 #include "model/DeleteLifecycleHookResult.h"
+#include "model/DescribeScheduledTasksRequest.h"
+#include "model/DescribeScheduledTasksResult.h"
 #include "model/DeleteNotificationConfigurationRequest.h"
 #include "model/DeleteNotificationConfigurationResult.h"
 #include "model/DescribeLifecycleHooksRequest.h"
 #include "model/DescribeLifecycleHooksResult.h"
 #include "model/ModifyAlarmRequest.h"
 #include "model/ModifyAlarmResult.h"
+#include "model/DescribeAccountAttributesRequest.h"
+#include "model/DescribeAccountAttributesResult.h"
 #include "model/DeleteAlarmRequest.h"
 #include "model/DeleteAlarmResult.h"
 #include "model/DescribeScalingActivityDetailRequest.h"
@@ -70,10 +76,10 @@
 #include "model/VerifyUserResult.h"
 #include "model/DescribeAlarmsRequest.h"
 #include "model/DescribeAlarmsResult.h"
-#include "model/AttachInstancesRequest.h"
-#include "model/AttachInstancesResult.h"
 #include "model/DescribeScalingGroupsRequest.h"
 #include "model/DescribeScalingGroupsResult.h"
+#include "model/AttachInstancesRequest.h"
+#include "model/AttachInstancesResult.h"
 #include "model/DescribeScalingActivitiesRequest.h"
 #include "model/DescribeScalingActivitiesResult.h"
 #include "model/ExitStandbyRequest.h"
@@ -112,10 +118,10 @@
 #include "model/AttachLoadBalancersResult.h"
 #include "model/CompleteLifecycleActionRequest.h"
 #include "model/CompleteLifecycleActionResult.h"
-#include "model/ModifyScalingConfigurationRequest.h"
-#include "model/ModifyScalingConfigurationResult.h"
 #include "model/DetachInstancesRequest.h"
 #include "model/DetachInstancesResult.h"
+#include "model/ModifyScalingConfigurationRequest.h"
+#include "model/ModifyScalingConfigurationResult.h"
 #include "model/DescribeLimitationRequest.h"
 #include "model/DescribeLimitationResult.h"
 #include "model/DescribeAlertConfigRequest.h"
@@ -150,6 +156,9 @@ namespace AlibabaCloud
 			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::DetachVServerGroupsResult> DetachVServerGroupsOutcome;
+			typedef std::future<DetachVServerGroupsOutcome> DetachVServerGroupsOutcomeCallable;
+			typedef std::function<void(const EssClient*, const Model::DetachVServerGroupsRequest&, const DetachVServerGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachVServerGroupsAsyncHandler;
 			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;
@@ -165,6 +174,9 @@ namespace AlibabaCloud
 			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::AttachVServerGroupsResult> AttachVServerGroupsOutcome;
+			typedef std::future<AttachVServerGroupsOutcome> AttachVServerGroupsOutcomeCallable;
+			typedef std::function<void(const EssClient*, const Model::AttachVServerGroupsRequest&, const AttachVServerGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachVServerGroupsAsyncHandler;
 			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;
@@ -189,12 +201,12 @@ namespace AlibabaCloud
 			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::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::DeleteLifecycleHookResult> DeleteLifecycleHookOutcome;
 			typedef std::future<DeleteLifecycleHookOutcome> DeleteLifecycleHookOutcomeCallable;
 			typedef std::function<void(const EssClient*, const Model::DeleteLifecycleHookRequest&, const DeleteLifecycleHookOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLifecycleHookAsyncHandler;
+			typedef Outcome<Error, Model::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::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;
@@ -204,6 +216,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ModifyAlarmResult> ModifyAlarmOutcome;
 			typedef std::future<ModifyAlarmOutcome> ModifyAlarmOutcomeCallable;
 			typedef std::function<void(const EssClient*, const Model::ModifyAlarmRequest&, const ModifyAlarmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAlarmAsyncHandler;
+			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::DeleteAlarmResult> DeleteAlarmOutcome;
 			typedef std::future<DeleteAlarmOutcome> DeleteAlarmOutcomeCallable;
 			typedef std::function<void(const EssClient*, const Model::DeleteAlarmRequest&, const DeleteAlarmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAlarmAsyncHandler;
@@ -219,12 +234,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeAlarmsResult> DescribeAlarmsOutcome;
 			typedef std::future<DescribeAlarmsOutcome> DescribeAlarmsOutcomeCallable;
 			typedef std::function<void(const EssClient*, const Model::DescribeAlarmsRequest&, const DescribeAlarmsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAlarmsAsyncHandler;
-			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 std::function<void(const EssClient*, const Model::DescribeScalingGroupsRequest&, const DescribeScalingGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingGroupsAsyncHandler;
+			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::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;
@@ -282,12 +297,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CompleteLifecycleActionResult> CompleteLifecycleActionOutcome;
 			typedef std::future<CompleteLifecycleActionOutcome> CompleteLifecycleActionOutcomeCallable;
 			typedef std::function<void(const EssClient*, const Model::CompleteLifecycleActionRequest&, const CompleteLifecycleActionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CompleteLifecycleActionAsyncHandler;
-			typedef Outcome<Error, Model::ModifyScalingConfigurationResult> ModifyScalingConfigurationOutcome;
-			typedef std::future<ModifyScalingConfigurationOutcome> ModifyScalingConfigurationOutcomeCallable;
-			typedef std::function<void(const EssClient*, const Model::ModifyScalingConfigurationRequest&, const ModifyScalingConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyScalingConfigurationAsyncHandler;
 			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::ModifyScalingConfigurationResult> ModifyScalingConfigurationOutcome;
+			typedef std::future<ModifyScalingConfigurationOutcome> ModifyScalingConfigurationOutcomeCallable;
+			typedef std::function<void(const EssClient*, const Model::ModifyScalingConfigurationRequest&, const ModifyScalingConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyScalingConfigurationAsyncHandler;
 			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;
@@ -329,6 +344,9 @@ namespace AlibabaCloud
 			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;
+			DetachVServerGroupsOutcome detachVServerGroups(const Model::DetachVServerGroupsRequest &request)const;
+			void detachVServerGroupsAsync(const Model::DetachVServerGroupsRequest& request, const DetachVServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetachVServerGroupsOutcomeCallable detachVServerGroupsCallable(const Model::DetachVServerGroupsRequest& 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;
@@ -344,6 +362,9 @@ namespace AlibabaCloud
 			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;
+			AttachVServerGroupsOutcome attachVServerGroups(const Model::AttachVServerGroupsRequest &request)const;
+			void attachVServerGroupsAsync(const Model::AttachVServerGroupsRequest& request, const AttachVServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AttachVServerGroupsOutcomeCallable attachVServerGroupsCallable(const Model::AttachVServerGroupsRequest& 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;
@@ -368,12 +389,12 @@ namespace AlibabaCloud
 			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;
-			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;
 			DeleteLifecycleHookOutcome deleteLifecycleHook(const Model::DeleteLifecycleHookRequest &request)const;
 			void deleteLifecycleHookAsync(const Model::DeleteLifecycleHookRequest& request, const DeleteLifecycleHookAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteLifecycleHookOutcomeCallable deleteLifecycleHookCallable(const Model::DeleteLifecycleHookRequest& request) const;
+			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;
@@ -383,6 +404,9 @@ namespace AlibabaCloud
 			ModifyAlarmOutcome modifyAlarm(const Model::ModifyAlarmRequest &request)const;
 			void modifyAlarmAsync(const Model::ModifyAlarmRequest& request, const ModifyAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyAlarmOutcomeCallable modifyAlarmCallable(const Model::ModifyAlarmRequest& 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;
 			DeleteAlarmOutcome deleteAlarm(const Model::DeleteAlarmRequest &request)const;
 			void deleteAlarmAsync(const Model::DeleteAlarmRequest& request, const DeleteAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteAlarmOutcomeCallable deleteAlarmCallable(const Model::DeleteAlarmRequest& request) const;
@@ -398,12 +422,12 @@ namespace AlibabaCloud
 			DescribeAlarmsOutcome describeAlarms(const Model::DescribeAlarmsRequest &request)const;
 			void describeAlarmsAsync(const Model::DescribeAlarmsRequest& request, const DescribeAlarmsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeAlarmsOutcomeCallable describeAlarmsCallable(const Model::DescribeAlarmsRequest& 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;
+			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;
 			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;
@@ -461,12 +485,12 @@ namespace AlibabaCloud
 			CompleteLifecycleActionOutcome completeLifecycleAction(const Model::CompleteLifecycleActionRequest &request)const;
 			void completeLifecycleActionAsync(const Model::CompleteLifecycleActionRequest& request, const CompleteLifecycleActionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CompleteLifecycleActionOutcomeCallable completeLifecycleActionCallable(const Model::CompleteLifecycleActionRequest& request) const;
-			ModifyScalingConfigurationOutcome modifyScalingConfiguration(const Model::ModifyScalingConfigurationRequest &request)const;
-			void modifyScalingConfigurationAsync(const Model::ModifyScalingConfigurationRequest& request, const ModifyScalingConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			ModifyScalingConfigurationOutcomeCallable modifyScalingConfigurationCallable(const Model::ModifyScalingConfigurationRequest& 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;
+			ModifyScalingConfigurationOutcome modifyScalingConfiguration(const Model::ModifyScalingConfigurationRequest &request)const;
+			void modifyScalingConfigurationAsync(const Model::ModifyScalingConfigurationRequest& request, const ModifyScalingConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyScalingConfigurationOutcomeCallable modifyScalingConfigurationCallable(const Model::ModifyScalingConfigurationRequest& 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;

ess/include/alibabacloud/ess/model/AttachVServerGroupsRequest.h

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

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

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

@@ -37,9 +37,13 @@ namespace AlibabaCloud
 				};
 				struct DataDisk
 				{
+					std::string diskName;
 					std::string snapshotId;
 					int size;
+					std::string encrypted;
+					std::string description;
 					std::string category;
+					std::string kMSKeyId;
 					std::string device;
 					bool deleteWithInstance;
 				};
@@ -74,6 +78,8 @@ namespace AlibabaCloud
 				void setAccessKeyId(const std::string& accessKeyId);
 				std::string getUserData()const;
 				void setUserData(const std::string& userData);
+				std::string getResourceGroupId()const;
+				void setResourceGroupId(const std::string& resourceGroupId);
 				std::string getHostName()const;
 				void setHostName(const std::string& hostName);
 				std::string getPassword()const;
@@ -92,6 +98,8 @@ namespace AlibabaCloud
 				void setOwnerAccount(const std::string& ownerAccount);
 				int getCpu()const;
 				void setCpu(int cpu);
+				std::string getSystemDiskDiskName()const;
+				void setSystemDiskDiskName(const std::string& systemDiskDiskName);
 				std::string getRamRoleName()const;
 				void setRamRoleName(const std::string& ramRoleName);
 				long getOwnerId()const;
@@ -114,6 +122,8 @@ namespace AlibabaCloud
 				void setInternetChargeType(const std::string& internetChargeType);
 				int getInternetMaxBandwidthIn()const;
 				void setInternetMaxBandwidthIn(int internetMaxBandwidthIn);
+				std::string getSystemDiskDescription()const;
+				void setSystemDiskDescription(const std::string& systemDiskDescription);
 
             private:
 				std::string imageId_;
@@ -129,6 +139,7 @@ namespace AlibabaCloud
 				std::string systemDiskCategory_;
 				std::string accessKeyId_;
 				std::string userData_;
+				std::string resourceGroupId_;
 				std::string hostName_;
 				std::string password_;
 				bool passwordInherit_;
@@ -138,6 +149,7 @@ namespace AlibabaCloud
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
 				int cpu_;
+				std::string systemDiskDiskName_;
 				std::string ramRoleName_;
 				long ownerId_;
 				std::vector<DataDisk> dataDisk_;
@@ -149,6 +161,7 @@ namespace AlibabaCloud
 				int systemDiskSize_;
 				std::string internetChargeType_;
 				int internetMaxBandwidthIn_;
+				std::string systemDiskDescription_;
 
 			};
 		}

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

@@ -39,6 +39,11 @@ namespace AlibabaCloud
 					std::string notificationMetadata;
 					std::string lifecycleTransition;
 				};
+				struct VServerGroup
+				{
+					std::string loadBalancerId;
+					RepeatList vServerGroupAttribute;
+				};
 
 			public:
 				CreateScalingGroupRequest();
@@ -58,6 +63,8 @@ namespace AlibabaCloud
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getScalingGroupName()const;
 				void setScalingGroupName(const std::string& scalingGroupName);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
 				std::vector<std::string> getVSwitchIds()const;
 				void setVSwitchIds(const std::vector<std::string>& vSwitchIds);
 				std::string getOwnerAccount()const;
@@ -84,6 +91,8 @@ namespace AlibabaCloud
 				void setDefaultCooldown(int defaultCooldown);
 				std::string getRemovalPolicy1()const;
 				void setRemovalPolicy1(const std::string& removalPolicy1);
+				std::vector<VServerGroup> getVServerGroup()const;
+				void setVServerGroup(const std::vector<VServerGroup>& vServerGroup);
 				std::string getRemovalPolicy2()const;
 				void setRemovalPolicy2(const std::string& removalPolicy2);
 
@@ -95,6 +104,7 @@ namespace AlibabaCloud
 				std::string healthCheckType_;
 				std::string resourceOwnerAccount_;
 				std::string scalingGroupName_;
+				std::string clientToken_;
 				std::vector<std::string> vSwitchIds_;
 				std::string ownerAccount_;
 				int minSize_;
@@ -108,6 +118,7 @@ namespace AlibabaCloud
 				std::vector<LifecycleHook> lifecycleHook_;
 				int defaultCooldown_;
 				std::string removalPolicy1_;
+				std::vector<VServerGroup> vServerGroup_;
 				std::string removalPolicy2_;
 
 			};

ess/include/alibabacloud/ess/model/CreateScalingRuleRequest.h

@@ -30,40 +30,67 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_ESS_EXPORT CreateScalingRuleRequest : public RpcServiceRequest
 			{
+				struct StepAdjustment
+				{
+					float metricIntervalLowerBound;
+					float metricIntervalUpperBound;
+					int scalingAdjustment;
+				};
 
 			public:
 				CreateScalingRuleRequest();
 				~CreateScalingRuleRequest();
 
-				std::string getScalingRuleName()const;
-				void setScalingRuleName(const std::string& scalingRuleName);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				int getAdjustmentValue()const;
 				void setAdjustmentValue(int adjustmentValue);
+				std::vector<StepAdjustment> getStepAdjustment()const;
+				void setStepAdjustment(const std::vector<StepAdjustment>& stepAdjustment);
 				std::string getScalingGroupId()const;
 				void setScalingGroupId(const std::string& scalingGroupId);
+				int getEstimatedInstanceWarmup()const;
+				void setEstimatedInstanceWarmup(int estimatedInstanceWarmup);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
-				int getCooldown()const;
-				void setCooldown(int cooldown);
 				std::string getAdjustmentType()const;
 				void setAdjustmentType(const std::string& adjustmentType);
+				bool getDisableScaleIn()const;
+				void setDisableScaleIn(bool disableScaleIn);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getScalingRuleName()const;
+				void setScalingRuleName(const std::string& scalingRuleName);
+				int getCooldown()const;
+				void setCooldown(int cooldown);
+				int getMinAdjustmentMagnitude()const;
+				void setMinAdjustmentMagnitude(int minAdjustmentMagnitude);
+				float getTargetValue()const;
+				void setTargetValue(float targetValue);
+				std::string getScalingRuleType()const;
+				void setScalingRuleType(const std::string& scalingRuleType);
+				std::string getMetricName()const;
+				void setMetricName(const std::string& metricName);
 
             private:
-				std::string scalingRuleName_;
 				std::string resourceOwnerAccount_;
 				int adjustmentValue_;
+				std::vector<StepAdjustment> stepAdjustment_;
 				std::string scalingGroupId_;
+				int estimatedInstanceWarmup_;
 				std::string ownerAccount_;
-				int cooldown_;
 				std::string adjustmentType_;
+				bool disableScaleIn_;
 				long ownerId_;
 				std::string accessKeyId_;
+				std::string scalingRuleName_;
+				int cooldown_;
+				int minAdjustmentMagnitude_;
+				float targetValue_;
+				std::string scalingRuleType_;
+				std::string metricName_;
 
 			};
 		}

ess/include/alibabacloud/ess/model/DescribeAccountAttributesRequest.h

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

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

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

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

@@ -37,12 +37,15 @@ namespace AlibabaCloud
 				DescribeLimitationResult();
 				explicit DescribeLimitationResult(const std::string &payload);
 				~DescribeLimitationResult();
+				int getMaxNumberOfLifecycleHooks()const;
 				int getMaxNumberOfScalingRules()const;
 				int getMaxNumberOfScalingInstances()const;
 				int getMaxNumberOfScheduledTasks()const;
+				int getMaxNumberOfVServerGroups()const;
 				int getMaxNumberOfLoadBalancers()const;
 				int getMaxNumberOfMinSize()const;
 				int getMaxNumberOfScalingGroups()const;
+				int getMaxNumberOfNotificationConfigurations()const;
 				int getMaxNumberOfScalingConfigurations()const;
 				int getMaxNumberOfDBInstances()const;
 				int getMaxNumberOfMaxSize()const;
@@ -50,12 +53,15 @@ namespace AlibabaCloud
 			protected:
 				void parse(const std::string &payload);
 			private:
+				int maxNumberOfLifecycleHooks_;
 				int maxNumberOfScalingRules_;
 				int maxNumberOfScalingInstances_;
 				int maxNumberOfScheduledTasks_;
+				int maxNumberOfVServerGroups_;
 				int maxNumberOfLoadBalancers_;
 				int maxNumberOfMinSize_;
 				int maxNumberOfScalingGroups_;
+				int maxNumberOfNotificationConfigurations_;
 				int maxNumberOfScalingConfigurations_;
 				int maxNumberOfDBInstances_;
 				int maxNumberOfMaxSize_;

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

@@ -34,18 +34,19 @@ namespace AlibabaCloud
 			public:
 				struct ScalingActivity
 				{
+					int scalingInstanceNumber;
 					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;
+					std::string cause;
+					std::string totalCapacity;
 				};
 
 

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

@@ -38,9 +38,13 @@ namespace AlibabaCloud
 					{
 						std::string snapshotId;
 						std::string category;
+						std::string kMSKeyId;
+						std::string description;
 						int size;
 						std::string device;
+						std::string encrypted;
 						bool deleteWithInstance;
+						std::string diskName;
 					};
 					struct Tag
 					{
@@ -54,11 +58,14 @@ namespace AlibabaCloud
 					};
 					std::string scalingConfigurationName;
 					std::vector<ScalingConfiguration::DataDisk> dataDisks;
+					std::string resourceGroupId;
 					int systemDiskSize;
+					std::string systemDiskDescription;
 					std::string userData;
 					int memory;
 					int cpu;
 					std::string lifecycleState;
+					std::string systemDiskName;
 					std::string ramRoleName;
 					std::string imageId;
 					std::vector<ScalingConfiguration::SpotPriceModel> spotPriceLimit;

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

@@ -34,6 +34,17 @@ namespace AlibabaCloud
 			public:
 				struct ScalingGroup
 				{
+					struct VServerGroup
+					{
+						struct VServerGroupAttribute
+						{
+							std::string vServerGroupId;
+							int port;
+							int weight;
+						};
+						std::string loadBalancerId;
+						std::vector<VServerGroup::VServerGroupAttribute> vServerGroupAttributes;
+					};
 					std::string activeScalingConfigurationId;
 					std::string lifecycleState;
 					std::string modificationTime;
@@ -61,6 +72,7 @@ namespace AlibabaCloud
 					std::string creationTime;
 					std::string multiAZPolicy;
 					int stoppedCapacity;
+					std::vector<ScalingGroup::VServerGroup> vServerGroups;
 					std::string regionId;
 					std::vector<std::string> dBInstanceIds;
 					std::string healthCheckType;

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

@@ -35,6 +35,7 @@ namespace AlibabaCloud
 				struct ScalingInstance
 				{
 					int loadBalancerWeight;
+					std::string warmupState;
 					std::string instanceId;
 					std::string scalingGroupId;
 					std::string healthStatus;

ess/include/alibabacloud/ess/model/DescribeScalingRulesRequest.h

@@ -67,6 +67,8 @@ namespace AlibabaCloud
 				void setRegionId(const std::string& regionId);
 				int getPageSize()const;
 				void setPageSize(int pageSize);
+				std::string getScalingRuleType()const;
+				void setScalingRuleType(const std::string& scalingRuleType);
 				std::string getScalingRuleId10()const;
 				void setScalingRuleId10(const std::string& scalingRuleId10);
 				std::string getResourceOwnerAccount()const;
@@ -101,6 +103,8 @@ namespace AlibabaCloud
 				void setScalingRuleAri8(const std::string& scalingRuleAri8);
 				std::string getScalingRuleId4()const;
 				void setScalingRuleId4(const std::string& scalingRuleId4);
+				bool getShowAlarmRules()const;
+				void setShowAlarmRules(bool showAlarmRules);
 				std::string getScalingRuleId5()const;
 				void setScalingRuleId5(const std::string& scalingRuleId5);
 				std::string getScalingRuleId6()const;
@@ -131,6 +135,7 @@ namespace AlibabaCloud
 				std::string accessKeyId_;
 				std::string regionId_;
 				int pageSize_;
+				std::string scalingRuleType_;
 				std::string scalingRuleId10_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
@@ -148,6 +153,7 @@ namespace AlibabaCloud
 				std::string scalingRuleAri10_;
 				std::string scalingRuleAri8_;
 				std::string scalingRuleId4_;
+				bool showAlarmRules_;
 				std::string scalingRuleId5_;
 				std::string scalingRuleId6_;
 				std::string scalingRuleId7_;

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

@@ -34,15 +34,34 @@ namespace AlibabaCloud
 			public:
 				struct ScalingRule
 				{
-					std::string scalingRuleAri;
-					int minSize;
-					std::string scalingRuleName;
-					int adjustmentValue;
+					struct Alarm
+					{
+						std::string alarmTaskName;
+						std::string alarmTaskId;
+					};
+					struct StepAdjustment
+					{
+						float metricIntervalUpperBound;
+						float metricIntervalLowerBound;
+						int scalingAdjustment;
+					};
+					float targetValue;
+					std::vector<ScalingRule::StepAdjustment> stepAdjustments;
 					std::string scalingGroupId;
 					int cooldown;
+					std::vector<ScalingRule::Alarm> alarms;
 					std::string scalingRuleId;
+					int minAdjustmentMagnitude;
+					bool disableScaleIn;
 					int maxSize;
 					std::string adjustmentType;
+					std::string scalingRuleAri;
+					int minSize;
+					std::string metricName;
+					std::string scalingRuleName;
+					int adjustmentValue;
+					std::string scalingRuleType;
+					int estimatedInstanceWarmup;
 				};
 
 

ess/include/alibabacloud/ess/model/DetachVServerGroupsRequest.h

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

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

ess/include/alibabacloud/ess/model/ExecuteScalingRuleRequest.h

@@ -43,10 +43,14 @@ namespace AlibabaCloud
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getClientToken()const;
 				void setClientToken(const std::string& clientToken);
+				float getBreachThreshold()const;
+				void setBreachThreshold(float breachThreshold);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
+				float getMetricValue()const;
+				void setMetricValue(float metricValue);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
 
@@ -55,8 +59,10 @@ namespace AlibabaCloud
 				std::string scalingRuleAri_;
 				std::string resourceOwnerAccount_;
 				std::string clientToken_;
+				float breachThreshold_;
 				std::string ownerAccount_;
 				long ownerId_;
+				float metricValue_;
 				std::string accessKeyId_;
 
 			};

ess/include/alibabacloud/ess/model/ModifyAlarmRequest.h

@@ -30,37 +30,69 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_ESS_EXPORT ModifyAlarmRequest : public RpcServiceRequest
 			{
+				struct Dimension
+				{
+					std::string dimensionValue;
+					std::string dimensionKey;
+				};
 
 			public:
 				ModifyAlarmRequest();
 				~ModifyAlarmRequest();
 
+				std::string getMetricType()const;
+				void setMetricType(const std::string& metricType);
+				int getPeriod()const;
+				void setPeriod(int period);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
-				std::string getRegionId()const;
-				void setRegionId(const std::string& regionId);
-				std::string getName()const;
-				void setName(const std::string& name);
+				int getGroupId()const;
+				void setGroupId(int groupId);
 				std::string getDescription()const;
 				void setDescription(const std::string& description);
 				std::vector<std::string> getAlarmAction()const;
 				void setAlarmAction(const std::vector<std::string>& alarmAction);
+				float getThreshold()const;
+				void setThreshold(float threshold);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
 				std::string getAlarmTaskId()const;
 				void setAlarmTaskId(const std::string& alarmTaskId);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getName()const;
+				void setName(const std::string& name);
+				int getEvaluationCount()const;
+				void setEvaluationCount(int evaluationCount);
+				std::string getMetricName()const;
+				void setMetricName(const std::string& metricName);
+				std::string getComparisonOperator()const;
+				void setComparisonOperator(const std::string& comparisonOperator);
+				std::vector<Dimension> getDimension()const;
+				void setDimension(const std::vector<Dimension>& dimension);
+				std::string getStatistics()const;
+				void setStatistics(const std::string& statistics);
 
             private:
+				std::string metricType_;
+				int period_;
 				std::string resourceOwnerAccount_;
-				std::string regionId_;
-				std::string name_;
+				int groupId_;
 				std::string description_;
 				std::vector<std::string> alarmAction_;
+				float threshold_;
 				long ownerId_;
 				std::string alarmTaskId_;
 				std::string accessKeyId_;
+				std::string regionId_;
+				std::string name_;
+				int evaluationCount_;
+				std::string metricName_;
+				std::string comparisonOperator_;
+				std::vector<Dimension> dimension_;
+				std::string statistics_;
 
 			};
 		}

ess/include/alibabacloud/ess/model/ModifyScalingConfigurationRequest.h

@@ -37,9 +37,13 @@ namespace AlibabaCloud
 				};
 				struct DataDisk
 				{
+					std::string diskName;
 					std::string snapshotId;
 					int size;
+					std::string encrypted;
+					std::string description;
 					std::string category;
+					std::string kMSKeyId;
 					std::string device;
 					bool deleteWithInstance;
 				};
@@ -70,6 +74,8 @@ namespace AlibabaCloud
 				void setAccessKeyId(const std::string& accessKeyId);
 				std::string getUserData()const;
 				void setUserData(const std::string& userData);
+				std::string getResourceGroupId()const;
+				void setResourceGroupId(const std::string& resourceGroupId);
 				std::string getHostName()const;
 				void setHostName(const std::string& hostName);
 				bool getPasswordInherit()const;
@@ -86,6 +92,8 @@ namespace AlibabaCloud
 				void setOwnerAccount(const std::string& ownerAccount);
 				int getCpu()const;
 				void setCpu(int cpu);
+				std::string getSystemDiskDiskName()const;
+				void setSystemDiskDiskName(const std::string& systemDiskDiskName);
 				std::string getRamRoleName()const;
 				void setRamRoleName(const std::string& ramRoleName);
 				long getOwnerId()const;
@@ -108,6 +116,8 @@ namespace AlibabaCloud
 				void setSystemDiskSize(int systemDiskSize);
 				std::string getInternetChargeType()const;
 				void setInternetChargeType(const std::string& internetChargeType);
+				std::string getSystemDiskDescription()const;
+				void setSystemDiskDescription(const std::string& systemDiskDescription);
 
             private:
 				std::string imageId_;
@@ -121,6 +131,7 @@ namespace AlibabaCloud
 				std::string systemDiskCategory_;
 				std::string accessKeyId_;
 				std::string userData_;
+				std::string resourceGroupId_;
 				std::string hostName_;
 				bool passwordInherit_;
 				std::string imageName_;
@@ -129,6 +140,7 @@ namespace AlibabaCloud
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
 				int cpu_;
+				std::string systemDiskDiskName_;
 				std::string ramRoleName_;
 				long ownerId_;
 				std::vector<DataDisk> dataDisk_;
@@ -140,6 +152,7 @@ namespace AlibabaCloud
 				int loadBalancerWeight_;
 				int systemDiskSize_;
 				std::string internetChargeType_;
+				std::string systemDiskDescription_;
 
 			};
 		}

ess/include/alibabacloud/ess/model/ModifyScalingGroupRequest.h

@@ -47,6 +47,8 @@ namespace AlibabaCloud
 				void setScalingGroupName(const std::string& scalingGroupName);
 				std::string getScalingGroupId()const;
 				void setScalingGroupId(const std::string& scalingGroupId);
+				std::vector<std::string> getVSwitchIds()const;
+				void setVSwitchIds(const std::vector<std::string>& vSwitchIds);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
 				std::string getActiveScalingConfigurationId()const;
@@ -75,6 +77,7 @@ namespace AlibabaCloud
 				std::string resourceOwnerAccount_;
 				std::string scalingGroupName_;
 				std::string scalingGroupId_;
+				std::vector<std::string> vSwitchIds_;
 				std::string ownerAccount_;
 				std::string activeScalingConfigurationId_;
 				int minSize_;

ess/include/alibabacloud/ess/model/ModifyScalingRuleRequest.h

@@ -30,43 +30,67 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_ESS_EXPORT ModifyScalingRuleRequest : public RpcServiceRequest
 			{
+				struct StepAdjustment
+				{
+					float metricIntervalLowerBound;
+					float metricIntervalUpperBound;
+					int scalingAdjustment;
+				};
 
 			public:
 				ModifyScalingRuleRequest();
 				~ModifyScalingRuleRequest();
 
-				std::string getScalingRuleName()const;
-				void setScalingRuleName(const std::string& scalingRuleName);
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				int getAdjustmentValue()const;
 				void setAdjustmentValue(int adjustmentValue);
+				std::vector<StepAdjustment> getStepAdjustment()const;
+				void setStepAdjustment(const std::vector<StepAdjustment>& stepAdjustment);
+				int getEstimatedInstanceWarmup()const;
+				void setEstimatedInstanceWarmup(int estimatedInstanceWarmup);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
-				int getCooldown()const;
-				void setCooldown(int cooldown);
 				std::string getAdjustmentType()const;
 				void setAdjustmentType(const std::string& adjustmentType);
+				bool getDisableScaleIn()const;
+				void setDisableScaleIn(bool disableScaleIn);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
 				std::string getScalingRuleId()const;
 				void setScalingRuleId(const std::string& scalingRuleId);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getScalingRuleName()const;
+				void setScalingRuleName(const std::string& scalingRuleName);
+				int getCooldown()const;
+				void setCooldown(int cooldown);
+				int getMinAdjustmentMagnitude()const;
+				void setMinAdjustmentMagnitude(int minAdjustmentMagnitude);
+				float getTargetValue()const;
+				void setTargetValue(float targetValue);
+				std::string getMetricName()const;
+				void setMetricName(const std::string& metricName);
 
             private:
-				std::string scalingRuleName_;
 				long resourceOwnerId_;
 				std::string resourceOwnerAccount_;
 				int adjustmentValue_;
+				std::vector<StepAdjustment> stepAdjustment_;
+				int estimatedInstanceWarmup_;
 				std::string ownerAccount_;
-				int cooldown_;
 				std::string adjustmentType_;
+				bool disableScaleIn_;
 				long ownerId_;
 				std::string scalingRuleId_;
 				std::string accessKeyId_;
+				std::string scalingRuleName_;
+				int cooldown_;
+				int minAdjustmentMagnitude_;
+				float targetValue_;
+				std::string metricName_;
 
 			};
 		}

ess/include/alibabacloud/ess/model/RemoveInstancesRequest.h

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

ess/src/EssClient.cc

@@ -31,21 +31,21 @@ EssClient::EssClient(const Credentials &credentials, const ClientConfiguration &
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "ess");
 }
 
 EssClient::EssClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "ess");
 }
 
 EssClient::EssClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "ess");
 }
 
 EssClient::~EssClient()
@@ -87,6 +87,42 @@ EssClient::EnterStandbyOutcomeCallable EssClient::enterStandbyCallable(const Ent
 	return task->get_future();
 }
 
+EssClient::DetachVServerGroupsOutcome EssClient::detachVServerGroups(const DetachVServerGroupsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetachVServerGroupsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetachVServerGroupsOutcome(DetachVServerGroupsResult(outcome.result()));
+	else
+		return DetachVServerGroupsOutcome(outcome.error());
+}
+
+void EssClient::detachVServerGroupsAsync(const DetachVServerGroupsRequest& request, const DetachVServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detachVServerGroups(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DetachVServerGroupsOutcomeCallable EssClient::detachVServerGroupsCallable(const DetachVServerGroupsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetachVServerGroupsOutcome()>>(
+			[this, request]()
+			{
+			return this->detachVServerGroups(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::ModifyScalingGroupOutcome EssClient::modifyScalingGroup(const ModifyScalingGroupRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -267,6 +303,42 @@ EssClient::DeleteScheduledTaskOutcomeCallable EssClient::deleteScheduledTaskCall
 	return task->get_future();
 }
 
+EssClient::AttachVServerGroupsOutcome EssClient::attachVServerGroups(const AttachVServerGroupsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AttachVServerGroupsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AttachVServerGroupsOutcome(AttachVServerGroupsResult(outcome.result()));
+	else
+		return AttachVServerGroupsOutcome(outcome.error());
+}
+
+void EssClient::attachVServerGroupsAsync(const AttachVServerGroupsRequest& request, const AttachVServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, attachVServerGroups(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::AttachVServerGroupsOutcomeCallable EssClient::attachVServerGroupsCallable(const AttachVServerGroupsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AttachVServerGroupsOutcome()>>(
+			[this, request]()
+			{
+			return this->attachVServerGroups(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::ModifyNotificationConfigurationOutcome EssClient::modifyNotificationConfiguration(const ModifyNotificationConfigurationRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -555,72 +627,72 @@ EssClient::DescribeCapacityHistoryOutcomeCallable EssClient::describeCapacityHis
 	return task->get_future();
 }
 
-EssClient::DescribeScheduledTasksOutcome EssClient::describeScheduledTasks(const DescribeScheduledTasksRequest &request) const
+EssClient::DeleteLifecycleHookOutcome EssClient::deleteLifecycleHook(const DeleteLifecycleHookRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return DescribeScheduledTasksOutcome(endpointOutcome.error());
+		return DeleteLifecycleHookOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return DescribeScheduledTasksOutcome(DescribeScheduledTasksResult(outcome.result()));
+		return DeleteLifecycleHookOutcome(DeleteLifecycleHookResult(outcome.result()));
 	else
-		return DescribeScheduledTasksOutcome(outcome.error());
+		return DeleteLifecycleHookOutcome(outcome.error());
 }
 
-void EssClient::describeScheduledTasksAsync(const DescribeScheduledTasksRequest& request, const DescribeScheduledTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void EssClient::deleteLifecycleHookAsync(const DeleteLifecycleHookRequest& request, const DeleteLifecycleHookAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, describeScheduledTasks(request), context);
+		handler(this, request, deleteLifecycleHook(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-EssClient::DescribeScheduledTasksOutcomeCallable EssClient::describeScheduledTasksCallable(const DescribeScheduledTasksRequest &request) const
+EssClient::DeleteLifecycleHookOutcomeCallable EssClient::deleteLifecycleHookCallable(const DeleteLifecycleHookRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<DescribeScheduledTasksOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<DeleteLifecycleHookOutcome()>>(
 			[this, request]()
 			{
-			return this->describeScheduledTasks(request);
+			return this->deleteLifecycleHook(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-EssClient::DeleteLifecycleHookOutcome EssClient::deleteLifecycleHook(const DeleteLifecycleHookRequest &request) const
+EssClient::DescribeScheduledTasksOutcome EssClient::describeScheduledTasks(const DescribeScheduledTasksRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return DeleteLifecycleHookOutcome(endpointOutcome.error());
+		return DescribeScheduledTasksOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return DeleteLifecycleHookOutcome(DeleteLifecycleHookResult(outcome.result()));
+		return DescribeScheduledTasksOutcome(DescribeScheduledTasksResult(outcome.result()));
 	else
-		return DeleteLifecycleHookOutcome(outcome.error());
+		return DescribeScheduledTasksOutcome(outcome.error());
 }
 
-void EssClient::deleteLifecycleHookAsync(const DeleteLifecycleHookRequest& request, const DeleteLifecycleHookAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void EssClient::describeScheduledTasksAsync(const DescribeScheduledTasksRequest& request, const DescribeScheduledTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, deleteLifecycleHook(request), context);
+		handler(this, request, describeScheduledTasks(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-EssClient::DeleteLifecycleHookOutcomeCallable EssClient::deleteLifecycleHookCallable(const DeleteLifecycleHookRequest &request) const
+EssClient::DescribeScheduledTasksOutcomeCallable EssClient::describeScheduledTasksCallable(const DescribeScheduledTasksRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<DeleteLifecycleHookOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<DescribeScheduledTasksOutcome()>>(
 			[this, request]()
 			{
-			return this->deleteLifecycleHook(request);
+			return this->describeScheduledTasks(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -735,6 +807,42 @@ EssClient::ModifyAlarmOutcomeCallable EssClient::modifyAlarmCallable(const Modif
 	return task->get_future();
 }
 
+EssClient::DescribeAccountAttributesOutcome EssClient::describeAccountAttributes(const DescribeAccountAttributesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeAccountAttributesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeAccountAttributesOutcome(DescribeAccountAttributesResult(outcome.result()));
+	else
+		return DescribeAccountAttributesOutcome(outcome.error());
+}
+
+void EssClient::describeAccountAttributesAsync(const DescribeAccountAttributesRequest& request, const DescribeAccountAttributesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeAccountAttributes(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DescribeAccountAttributesOutcomeCallable EssClient::describeAccountAttributesCallable(const DescribeAccountAttributesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeAccountAttributesOutcome()>>(
+			[this, request]()
+			{
+			return this->describeAccountAttributes(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::DeleteAlarmOutcome EssClient::deleteAlarm(const DeleteAlarmRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -915,72 +1023,72 @@ EssClient::DescribeAlarmsOutcomeCallable EssClient::describeAlarmsCallable(const
 	return task->get_future();
 }
 
-EssClient::AttachInstancesOutcome EssClient::attachInstances(const AttachInstancesRequest &request) const
+EssClient::DescribeScalingGroupsOutcome EssClient::describeScalingGroups(const DescribeScalingGroupsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return AttachInstancesOutcome(endpointOutcome.error());
+		return DescribeScalingGroupsOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return AttachInstancesOutcome(AttachInstancesResult(outcome.result()));
+		return DescribeScalingGroupsOutcome(DescribeScalingGroupsResult(outcome.result()));
 	else
-		return AttachInstancesOutcome(outcome.error());
+		return DescribeScalingGroupsOutcome(outcome.error());
 }
 
-void EssClient::attachInstancesAsync(const AttachInstancesRequest& request, const AttachInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void EssClient::describeScalingGroupsAsync(const DescribeScalingGroupsRequest& request, const DescribeScalingGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, attachInstances(request), context);
+		handler(this, request, describeScalingGroups(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-EssClient::AttachInstancesOutcomeCallable EssClient::attachInstancesCallable(const AttachInstancesRequest &request) const
+EssClient::DescribeScalingGroupsOutcomeCallable EssClient::describeScalingGroupsCallable(const DescribeScalingGroupsRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<AttachInstancesOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<DescribeScalingGroupsOutcome()>>(
 			[this, request]()
 			{
-			return this->attachInstances(request);
+			return this->describeScalingGroups(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-EssClient::DescribeScalingGroupsOutcome EssClient::describeScalingGroups(const DescribeScalingGroupsRequest &request) const
+EssClient::AttachInstancesOutcome EssClient::attachInstances(const AttachInstancesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return DescribeScalingGroupsOutcome(endpointOutcome.error());
+		return AttachInstancesOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return DescribeScalingGroupsOutcome(DescribeScalingGroupsResult(outcome.result()));
+		return AttachInstancesOutcome(AttachInstancesResult(outcome.result()));
 	else
-		return DescribeScalingGroupsOutcome(outcome.error());
+		return AttachInstancesOutcome(outcome.error());
 }
 
-void EssClient::describeScalingGroupsAsync(const DescribeScalingGroupsRequest& request, const DescribeScalingGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void EssClient::attachInstancesAsync(const AttachInstancesRequest& request, const AttachInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, describeScalingGroups(request), context);
+		handler(this, request, attachInstances(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-EssClient::DescribeScalingGroupsOutcomeCallable EssClient::describeScalingGroupsCallable(const DescribeScalingGroupsRequest &request) const
+EssClient::AttachInstancesOutcomeCallable EssClient::attachInstancesCallable(const AttachInstancesRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<DescribeScalingGroupsOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<AttachInstancesOutcome()>>(
 			[this, request]()
 			{
-			return this->describeScalingGroups(request);
+			return this->attachInstances(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -1671,72 +1779,72 @@ EssClient::CompleteLifecycleActionOutcomeCallable EssClient::completeLifecycleAc
 	return task->get_future();
 }
 
-EssClient::ModifyScalingConfigurationOutcome EssClient::modifyScalingConfiguration(const ModifyScalingConfigurationRequest &request) const
+EssClient::DetachInstancesOutcome EssClient::detachInstances(const DetachInstancesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return ModifyScalingConfigurationOutcome(endpointOutcome.error());
+		return DetachInstancesOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return ModifyScalingConfigurationOutcome(ModifyScalingConfigurationResult(outcome.result()));
+		return DetachInstancesOutcome(DetachInstancesResult(outcome.result()));
 	else
-		return ModifyScalingConfigurationOutcome(outcome.error());
+		return DetachInstancesOutcome(outcome.error());
 }
 
-void EssClient::modifyScalingConfigurationAsync(const ModifyScalingConfigurationRequest& request, const ModifyScalingConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void EssClient::detachInstancesAsync(const DetachInstancesRequest& request, const DetachInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, modifyScalingConfiguration(request), context);
+		handler(this, request, detachInstances(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-EssClient::ModifyScalingConfigurationOutcomeCallable EssClient::modifyScalingConfigurationCallable(const ModifyScalingConfigurationRequest &request) const
+EssClient::DetachInstancesOutcomeCallable EssClient::detachInstancesCallable(const DetachInstancesRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<ModifyScalingConfigurationOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<DetachInstancesOutcome()>>(
 			[this, request]()
 			{
-			return this->modifyScalingConfiguration(request);
+			return this->detachInstances(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-EssClient::DetachInstancesOutcome EssClient::detachInstances(const DetachInstancesRequest &request) const
+EssClient::ModifyScalingConfigurationOutcome EssClient::modifyScalingConfiguration(const ModifyScalingConfigurationRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return DetachInstancesOutcome(endpointOutcome.error());
+		return ModifyScalingConfigurationOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return DetachInstancesOutcome(DetachInstancesResult(outcome.result()));
+		return ModifyScalingConfigurationOutcome(ModifyScalingConfigurationResult(outcome.result()));
 	else
-		return DetachInstancesOutcome(outcome.error());
+		return ModifyScalingConfigurationOutcome(outcome.error());
 }
 
-void EssClient::detachInstancesAsync(const DetachInstancesRequest& request, const DetachInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void EssClient::modifyScalingConfigurationAsync(const ModifyScalingConfigurationRequest& request, const ModifyScalingConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, detachInstances(request), context);
+		handler(this, request, modifyScalingConfiguration(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-EssClient::DetachInstancesOutcomeCallable EssClient::detachInstancesCallable(const DetachInstancesRequest &request) const
+EssClient::ModifyScalingConfigurationOutcomeCallable EssClient::modifyScalingConfigurationCallable(const ModifyScalingConfigurationRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<DetachInstancesOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<ModifyScalingConfigurationOutcome()>>(
 			[this, request]()
 			{
-			return this->detachInstances(request);
+			return this->modifyScalingConfiguration(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));

ess/src/model/AttachDBInstancesRequest.cc

@@ -33,7 +33,7 @@ std::string AttachDBInstancesRequest::getResourceOwnerAccount()const
 void AttachDBInstancesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string AttachDBInstancesRequest::getScalingGroupId()const
@@ -44,7 +44,7 @@ std::string AttachDBInstancesRequest::getScalingGroupId()const
 void AttachDBInstancesRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 bool AttachDBInstancesRequest::getForceAttach()const
@@ -55,7 +55,7 @@ bool AttachDBInstancesRequest::getForceAttach()const
 void AttachDBInstancesRequest::setForceAttach(bool forceAttach)
 {
 	forceAttach_ = forceAttach;
-	setParameter("ForceAttach", std::to_string(forceAttach));
+	setCoreParameter("ForceAttach", forceAttach ? "true" : "false");
 }
 
 std::vector<std::string> AttachDBInstancesRequest::getDBInstance()const
@@ -67,7 +67,7 @@ void AttachDBInstancesRequest::setDBInstance(const std::vector<std::string>& dBI
 {
 	dBInstance_ = dBInstance;
 	for(int i = 0; i!= dBInstance.size(); i++)
-		setParameter("DBInstance."+ std::to_string(i), dBInstance.at(i));
+		setCoreParameter("DBInstance."+ std::to_string(i), dBInstance.at(i));
 }
 
 long AttachDBInstancesRequest::getOwnerId()const
@@ -78,7 +78,7 @@ long AttachDBInstancesRequest::getOwnerId()const
 void AttachDBInstancesRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string AttachDBInstancesRequest::getAccessKeyId()const
@@ -89,6 +89,6 @@ std::string AttachDBInstancesRequest::getAccessKeyId()const
 void AttachDBInstancesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/AttachInstancesRequest.cc

@@ -33,7 +33,7 @@ std::string AttachInstancesRequest::getInstanceId10()const
 void AttachInstancesRequest::setInstanceId10(const std::string& instanceId10)
 {
 	instanceId10_ = instanceId10;
-	setParameter("InstanceId10", instanceId10);
+	setCoreParameter("InstanceId10", instanceId10);
 }
 
 int AttachInstancesRequest::getLoadBalancerWeight6()const
@@ -44,7 +44,7 @@ int AttachInstancesRequest::getLoadBalancerWeight6()const
 void AttachInstancesRequest::setLoadBalancerWeight6(int loadBalancerWeight6)
 {
 	loadBalancerWeight6_ = loadBalancerWeight6;
-	setParameter("LoadBalancerWeight6", std::to_string(loadBalancerWeight6));
+	setCoreParameter("LoadBalancerWeight6", std::to_string(loadBalancerWeight6));
 }
 
 int AttachInstancesRequest::getLoadBalancerWeight11()const
@@ -55,7 +55,7 @@ int AttachInstancesRequest::getLoadBalancerWeight11()const
 void AttachInstancesRequest::setLoadBalancerWeight11(int loadBalancerWeight11)
 {
 	loadBalancerWeight11_ = loadBalancerWeight11;
-	setParameter("LoadBalancerWeight11", std::to_string(loadBalancerWeight11));
+	setCoreParameter("LoadBalancerWeight11", std::to_string(loadBalancerWeight11));
 }
 
 int AttachInstancesRequest::getLoadBalancerWeight7()const
@@ -66,7 +66,7 @@ int AttachInstancesRequest::getLoadBalancerWeight7()const
 void AttachInstancesRequest::setLoadBalancerWeight7(int loadBalancerWeight7)
 {
 	loadBalancerWeight7_ = loadBalancerWeight7;
-	setParameter("LoadBalancerWeight7", std::to_string(loadBalancerWeight7));
+	setCoreParameter("LoadBalancerWeight7", std::to_string(loadBalancerWeight7));
 }
 
 int AttachInstancesRequest::getLoadBalancerWeight12()const
@@ -77,7 +77,7 @@ int AttachInstancesRequest::getLoadBalancerWeight12()const
 void AttachInstancesRequest::setLoadBalancerWeight12(int loadBalancerWeight12)
 {
 	loadBalancerWeight12_ = loadBalancerWeight12;
-	setParameter("LoadBalancerWeight12", std::to_string(loadBalancerWeight12));
+	setCoreParameter("LoadBalancerWeight12", std::to_string(loadBalancerWeight12));
 }
 
 long AttachInstancesRequest::getResourceOwnerId()const
@@ -88,7 +88,7 @@ long AttachInstancesRequest::getResourceOwnerId()const
 void AttachInstancesRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string AttachInstancesRequest::getInstanceId12()const
@@ -99,7 +99,7 @@ std::string AttachInstancesRequest::getInstanceId12()const
 void AttachInstancesRequest::setInstanceId12(const std::string& instanceId12)
 {
 	instanceId12_ = instanceId12;
-	setParameter("InstanceId12", instanceId12);
+	setCoreParameter("InstanceId12", instanceId12);
 }
 
 int AttachInstancesRequest::getLoadBalancerWeight8()const
@@ -110,7 +110,7 @@ int AttachInstancesRequest::getLoadBalancerWeight8()const
 void AttachInstancesRequest::setLoadBalancerWeight8(int loadBalancerWeight8)
 {
 	loadBalancerWeight8_ = loadBalancerWeight8;
-	setParameter("LoadBalancerWeight8", std::to_string(loadBalancerWeight8));
+	setCoreParameter("LoadBalancerWeight8", std::to_string(loadBalancerWeight8));
 }
 
 std::string AttachInstancesRequest::getInstanceId11()const
@@ -121,7 +121,7 @@ std::string AttachInstancesRequest::getInstanceId11()const
 void AttachInstancesRequest::setInstanceId11(const std::string& instanceId11)
 {
 	instanceId11_ = instanceId11;
-	setParameter("InstanceId11", instanceId11);
+	setCoreParameter("InstanceId11", instanceId11);
 }
 
 int AttachInstancesRequest::getLoadBalancerWeight9()const
@@ -132,7 +132,7 @@ int AttachInstancesRequest::getLoadBalancerWeight9()const
 void AttachInstancesRequest::setLoadBalancerWeight9(int loadBalancerWeight9)
 {
 	loadBalancerWeight9_ = loadBalancerWeight9;
-	setParameter("LoadBalancerWeight9", std::to_string(loadBalancerWeight9));
+	setCoreParameter("LoadBalancerWeight9", std::to_string(loadBalancerWeight9));
 }
 
 int AttachInstancesRequest::getLoadBalancerWeight10()const
@@ -143,7 +143,7 @@ int AttachInstancesRequest::getLoadBalancerWeight10()const
 void AttachInstancesRequest::setLoadBalancerWeight10(int loadBalancerWeight10)
 {
 	loadBalancerWeight10_ = loadBalancerWeight10;
-	setParameter("LoadBalancerWeight10", std::to_string(loadBalancerWeight10));
+	setCoreParameter("LoadBalancerWeight10", std::to_string(loadBalancerWeight10));
 }
 
 int AttachInstancesRequest::getLoadBalancerWeight2()const
@@ -154,7 +154,7 @@ int AttachInstancesRequest::getLoadBalancerWeight2()const
 void AttachInstancesRequest::setLoadBalancerWeight2(int loadBalancerWeight2)
 {
 	loadBalancerWeight2_ = loadBalancerWeight2;
-	setParameter("LoadBalancerWeight2", std::to_string(loadBalancerWeight2));
+	setCoreParameter("LoadBalancerWeight2", std::to_string(loadBalancerWeight2));
 }
 
 int AttachInstancesRequest::getLoadBalancerWeight15()const
@@ -165,7 +165,7 @@ int AttachInstancesRequest::getLoadBalancerWeight15()const
 void AttachInstancesRequest::setLoadBalancerWeight15(int loadBalancerWeight15)
 {
 	loadBalancerWeight15_ = loadBalancerWeight15;
-	setParameter("LoadBalancerWeight15", std::to_string(loadBalancerWeight15));
+	setCoreParameter("LoadBalancerWeight15", std::to_string(loadBalancerWeight15));
 }
 
 int AttachInstancesRequest::getLoadBalancerWeight3()const
@@ -176,7 +176,7 @@ int AttachInstancesRequest::getLoadBalancerWeight3()const
 void AttachInstancesRequest::setLoadBalancerWeight3(int loadBalancerWeight3)
 {
 	loadBalancerWeight3_ = loadBalancerWeight3;
-	setParameter("LoadBalancerWeight3", std::to_string(loadBalancerWeight3));
+	setCoreParameter("LoadBalancerWeight3", std::to_string(loadBalancerWeight3));
 }
 
 int AttachInstancesRequest::getLoadBalancerWeight16()const
@@ -187,7 +187,7 @@ int AttachInstancesRequest::getLoadBalancerWeight16()const
 void AttachInstancesRequest::setLoadBalancerWeight16(int loadBalancerWeight16)
 {
 	loadBalancerWeight16_ = loadBalancerWeight16;
-	setParameter("LoadBalancerWeight16", std::to_string(loadBalancerWeight16));
+	setCoreParameter("LoadBalancerWeight16", std::to_string(loadBalancerWeight16));
 }
 
 std::string AttachInstancesRequest::getScalingGroupId()const
@@ -198,7 +198,7 @@ std::string AttachInstancesRequest::getScalingGroupId()const
 void AttachInstancesRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 int AttachInstancesRequest::getLoadBalancerWeight4()const
@@ -209,7 +209,7 @@ int AttachInstancesRequest::getLoadBalancerWeight4()const
 void AttachInstancesRequest::setLoadBalancerWeight4(int loadBalancerWeight4)
 {
 	loadBalancerWeight4_ = loadBalancerWeight4;
-	setParameter("LoadBalancerWeight4", std::to_string(loadBalancerWeight4));
+	setCoreParameter("LoadBalancerWeight4", std::to_string(loadBalancerWeight4));
 }
 
 int AttachInstancesRequest::getLoadBalancerWeight13()const
@@ -220,7 +220,7 @@ int AttachInstancesRequest::getLoadBalancerWeight13()const
 void AttachInstancesRequest::setLoadBalancerWeight13(int loadBalancerWeight13)
 {
 	loadBalancerWeight13_ = loadBalancerWeight13;
-	setParameter("LoadBalancerWeight13", std::to_string(loadBalancerWeight13));
+	setCoreParameter("LoadBalancerWeight13", std::to_string(loadBalancerWeight13));
 }
 
 int AttachInstancesRequest::getLoadBalancerWeight5()const
@@ -231,7 +231,7 @@ int AttachInstancesRequest::getLoadBalancerWeight5()const
 void AttachInstancesRequest::setLoadBalancerWeight5(int loadBalancerWeight5)
 {
 	loadBalancerWeight5_ = loadBalancerWeight5;
-	setParameter("LoadBalancerWeight5", std::to_string(loadBalancerWeight5));
+	setCoreParameter("LoadBalancerWeight5", std::to_string(loadBalancerWeight5));
 }
 
 int AttachInstancesRequest::getLoadBalancerWeight14()const
@@ -242,7 +242,7 @@ int AttachInstancesRequest::getLoadBalancerWeight14()const
 void AttachInstancesRequest::setLoadBalancerWeight14(int loadBalancerWeight14)
 {
 	loadBalancerWeight14_ = loadBalancerWeight14;
-	setParameter("LoadBalancerWeight14", std::to_string(loadBalancerWeight14));
+	setCoreParameter("LoadBalancerWeight14", std::to_string(loadBalancerWeight14));
 }
 
 int AttachInstancesRequest::getLoadBalancerWeight1()const
@@ -253,7 +253,7 @@ int AttachInstancesRequest::getLoadBalancerWeight1()const
 void AttachInstancesRequest::setLoadBalancerWeight1(int loadBalancerWeight1)
 {
 	loadBalancerWeight1_ = loadBalancerWeight1;
-	setParameter("LoadBalancerWeight1", std::to_string(loadBalancerWeight1));
+	setCoreParameter("LoadBalancerWeight1", std::to_string(loadBalancerWeight1));
 }
 
 std::string AttachInstancesRequest::getAccessKeyId()const
@@ -264,7 +264,7 @@ std::string AttachInstancesRequest::getAccessKeyId()const
 void AttachInstancesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string AttachInstancesRequest::getInstanceId20()const
@@ -275,7 +275,7 @@ std::string AttachInstancesRequest::getInstanceId20()const
 void AttachInstancesRequest::setInstanceId20(const std::string& instanceId20)
 {
 	instanceId20_ = instanceId20;
-	setParameter("InstanceId20", instanceId20);
+	setCoreParameter("InstanceId20", instanceId20);
 }
 
 std::string AttachInstancesRequest::getInstanceId1()const
@@ -286,7 +286,7 @@ std::string AttachInstancesRequest::getInstanceId1()const
 void AttachInstancesRequest::setInstanceId1(const std::string& instanceId1)
 {
 	instanceId1_ = instanceId1;
-	setParameter("InstanceId1", instanceId1);
+	setCoreParameter("InstanceId1", instanceId1);
 }
 
 int AttachInstancesRequest::getLoadBalancerWeight20()const
@@ -297,7 +297,7 @@ int AttachInstancesRequest::getLoadBalancerWeight20()const
 void AttachInstancesRequest::setLoadBalancerWeight20(int loadBalancerWeight20)
 {
 	loadBalancerWeight20_ = loadBalancerWeight20;
-	setParameter("LoadBalancerWeight20", std::to_string(loadBalancerWeight20));
+	setCoreParameter("LoadBalancerWeight20", std::to_string(loadBalancerWeight20));
 }
 
 std::string AttachInstancesRequest::getInstanceId3()const
@@ -308,7 +308,7 @@ std::string AttachInstancesRequest::getInstanceId3()const
 void AttachInstancesRequest::setInstanceId3(const std::string& instanceId3)
 {
 	instanceId3_ = instanceId3;
-	setParameter("InstanceId3", instanceId3);
+	setCoreParameter("InstanceId3", instanceId3);
 }
 
 std::string AttachInstancesRequest::getResourceOwnerAccount()const
@@ -319,7 +319,7 @@ std::string AttachInstancesRequest::getResourceOwnerAccount()const
 void AttachInstancesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string AttachInstancesRequest::getInstanceId2()const
@@ -330,7 +330,7 @@ std::string AttachInstancesRequest::getInstanceId2()const
 void AttachInstancesRequest::setInstanceId2(const std::string& instanceId2)
 {
 	instanceId2_ = instanceId2;
-	setParameter("InstanceId2", instanceId2);
+	setCoreParameter("InstanceId2", instanceId2);
 }
 
 std::string AttachInstancesRequest::getInstanceId5()const
@@ -341,7 +341,7 @@ std::string AttachInstancesRequest::getInstanceId5()const
 void AttachInstancesRequest::setInstanceId5(const std::string& instanceId5)
 {
 	instanceId5_ = instanceId5;
-	setParameter("InstanceId5", instanceId5);
+	setCoreParameter("InstanceId5", instanceId5);
 }
 
 std::string AttachInstancesRequest::getInstanceId4()const
@@ -352,7 +352,7 @@ std::string AttachInstancesRequest::getInstanceId4()const
 void AttachInstancesRequest::setInstanceId4(const std::string& instanceId4)
 {
 	instanceId4_ = instanceId4;
-	setParameter("InstanceId4", instanceId4);
+	setCoreParameter("InstanceId4", instanceId4);
 }
 
 std::string AttachInstancesRequest::getOwnerAccount()const
@@ -363,7 +363,7 @@ std::string AttachInstancesRequest::getOwnerAccount()const
 void AttachInstancesRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 std::string AttachInstancesRequest::getInstanceId7()const
@@ -374,7 +374,7 @@ std::string AttachInstancesRequest::getInstanceId7()const
 void AttachInstancesRequest::setInstanceId7(const std::string& instanceId7)
 {
 	instanceId7_ = instanceId7;
-	setParameter("InstanceId7", instanceId7);
+	setCoreParameter("InstanceId7", instanceId7);
 }
 
 std::string AttachInstancesRequest::getInstanceId6()const
@@ -385,7 +385,7 @@ std::string AttachInstancesRequest::getInstanceId6()const
 void AttachInstancesRequest::setInstanceId6(const std::string& instanceId6)
 {
 	instanceId6_ = instanceId6;
-	setParameter("InstanceId6", instanceId6);
+	setCoreParameter("InstanceId6", instanceId6);
 }
 
 std::string AttachInstancesRequest::getInstanceId9()const
@@ -396,7 +396,7 @@ std::string AttachInstancesRequest::getInstanceId9()const
 void AttachInstancesRequest::setInstanceId9(const std::string& instanceId9)
 {
 	instanceId9_ = instanceId9;
-	setParameter("InstanceId9", instanceId9);
+	setCoreParameter("InstanceId9", instanceId9);
 }
 
 std::string AttachInstancesRequest::getInstanceId8()const
@@ -407,7 +407,7 @@ std::string AttachInstancesRequest::getInstanceId8()const
 void AttachInstancesRequest::setInstanceId8(const std::string& instanceId8)
 {
 	instanceId8_ = instanceId8;
-	setParameter("InstanceId8", instanceId8);
+	setCoreParameter("InstanceId8", instanceId8);
 }
 
 long AttachInstancesRequest::getOwnerId()const
@@ -418,7 +418,7 @@ long AttachInstancesRequest::getOwnerId()const
 void AttachInstancesRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string AttachInstancesRequest::getInstanceId18()const
@@ -429,7 +429,7 @@ std::string AttachInstancesRequest::getInstanceId18()const
 void AttachInstancesRequest::setInstanceId18(const std::string& instanceId18)
 {
 	instanceId18_ = instanceId18;
-	setParameter("InstanceId18", instanceId18);
+	setCoreParameter("InstanceId18", instanceId18);
 }
 
 int AttachInstancesRequest::getLoadBalancerWeight19()const
@@ -440,7 +440,7 @@ int AttachInstancesRequest::getLoadBalancerWeight19()const
 void AttachInstancesRequest::setLoadBalancerWeight19(int loadBalancerWeight19)
 {
 	loadBalancerWeight19_ = loadBalancerWeight19;
-	setParameter("LoadBalancerWeight19", std::to_string(loadBalancerWeight19));
+	setCoreParameter("LoadBalancerWeight19", std::to_string(loadBalancerWeight19));
 }
 
 std::string AttachInstancesRequest::getInstanceId17()const
@@ -451,7 +451,7 @@ std::string AttachInstancesRequest::getInstanceId17()const
 void AttachInstancesRequest::setInstanceId17(const std::string& instanceId17)
 {
 	instanceId17_ = instanceId17;
-	setParameter("InstanceId17", instanceId17);
+	setCoreParameter("InstanceId17", instanceId17);
 }
 
 int AttachInstancesRequest::getLoadBalancerWeight17()const
@@ -462,7 +462,7 @@ int AttachInstancesRequest::getLoadBalancerWeight17()const
 void AttachInstancesRequest::setLoadBalancerWeight17(int loadBalancerWeight17)
 {
 	loadBalancerWeight17_ = loadBalancerWeight17;
-	setParameter("LoadBalancerWeight17", std::to_string(loadBalancerWeight17));
+	setCoreParameter("LoadBalancerWeight17", std::to_string(loadBalancerWeight17));
 }
 
 std::string AttachInstancesRequest::getInstanceId19()const
@@ -473,7 +473,7 @@ std::string AttachInstancesRequest::getInstanceId19()const
 void AttachInstancesRequest::setInstanceId19(const std::string& instanceId19)
 {
 	instanceId19_ = instanceId19;
-	setParameter("InstanceId19", instanceId19);
+	setCoreParameter("InstanceId19", instanceId19);
 }
 
 int AttachInstancesRequest::getLoadBalancerWeight18()const
@@ -484,7 +484,7 @@ int AttachInstancesRequest::getLoadBalancerWeight18()const
 void AttachInstancesRequest::setLoadBalancerWeight18(int loadBalancerWeight18)
 {
 	loadBalancerWeight18_ = loadBalancerWeight18;
-	setParameter("LoadBalancerWeight18", std::to_string(loadBalancerWeight18));
+	setCoreParameter("LoadBalancerWeight18", std::to_string(loadBalancerWeight18));
 }
 
 std::string AttachInstancesRequest::getInstanceId14()const
@@ -495,7 +495,7 @@ std::string AttachInstancesRequest::getInstanceId14()const
 void AttachInstancesRequest::setInstanceId14(const std::string& instanceId14)
 {
 	instanceId14_ = instanceId14;
-	setParameter("InstanceId14", instanceId14);
+	setCoreParameter("InstanceId14", instanceId14);
 }
 
 std::string AttachInstancesRequest::getInstanceId13()const
@@ -506,7 +506,7 @@ std::string AttachInstancesRequest::getInstanceId13()const
 void AttachInstancesRequest::setInstanceId13(const std::string& instanceId13)
 {
 	instanceId13_ = instanceId13;
-	setParameter("InstanceId13", instanceId13);
+	setCoreParameter("InstanceId13", instanceId13);
 }
 
 std::string AttachInstancesRequest::getInstanceId16()const
@@ -517,7 +517,7 @@ std::string AttachInstancesRequest::getInstanceId16()const
 void AttachInstancesRequest::setInstanceId16(const std::string& instanceId16)
 {
 	instanceId16_ = instanceId16;
-	setParameter("InstanceId16", instanceId16);
+	setCoreParameter("InstanceId16", instanceId16);
 }
 
 std::string AttachInstancesRequest::getInstanceId15()const
@@ -528,6 +528,6 @@ std::string AttachInstancesRequest::getInstanceId15()const
 void AttachInstancesRequest::setInstanceId15(const std::string& instanceId15)
 {
 	instanceId15_ = instanceId15;
-	setParameter("InstanceId15", instanceId15);
+	setCoreParameter("InstanceId15", instanceId15);
 }
 

ess/src/model/AttachLoadBalancersRequest.cc

@@ -34,7 +34,7 @@ void AttachLoadBalancersRequest::setLoadBalancer(const std::vector<std::string>&
 {
 	loadBalancer_ = loadBalancer;
 	for(int i = 0; i!= loadBalancer.size(); i++)
-		setParameter("LoadBalancer."+ std::to_string(i), loadBalancer.at(i));
+		setCoreParameter("LoadBalancer."+ std::to_string(i), loadBalancer.at(i));
 }
 
 std::string AttachLoadBalancersRequest::getResourceOwnerAccount()const
@@ -45,7 +45,7 @@ std::string AttachLoadBalancersRequest::getResourceOwnerAccount()const
 void AttachLoadBalancersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string AttachLoadBalancersRequest::getScalingGroupId()const
@@ -56,7 +56,7 @@ std::string AttachLoadBalancersRequest::getScalingGroupId()const
 void AttachLoadBalancersRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 bool AttachLoadBalancersRequest::getForceAttach()const
@@ -67,7 +67,7 @@ bool AttachLoadBalancersRequest::getForceAttach()const
 void AttachLoadBalancersRequest::setForceAttach(bool forceAttach)
 {
 	forceAttach_ = forceAttach;
-	setParameter("ForceAttach", std::to_string(forceAttach));
+	setCoreParameter("ForceAttach", forceAttach ? "true" : "false");
 }
 
 long AttachLoadBalancersRequest::getOwnerId()const
@@ -78,7 +78,7 @@ long AttachLoadBalancersRequest::getOwnerId()const
 void AttachLoadBalancersRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string AttachLoadBalancersRequest::getAccessKeyId()const
@@ -89,6 +89,6 @@ std::string AttachLoadBalancersRequest::getAccessKeyId()const
 void AttachLoadBalancersRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/AttachVServerGroupsRequest.cc

@@ -0,0 +1,110 @@
+/*
+ * 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/AttachVServerGroupsRequest.h>
+
+using AlibabaCloud::Ess::Model::AttachVServerGroupsRequest;
+
+AttachVServerGroupsRequest::AttachVServerGroupsRequest() :
+	RpcServiceRequest("ess", "2014-08-28", "AttachVServerGroups")
+{}
+
+AttachVServerGroupsRequest::~AttachVServerGroupsRequest()
+{}
+
+std::string AttachVServerGroupsRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void AttachVServerGroupsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string AttachVServerGroupsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void AttachVServerGroupsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string AttachVServerGroupsRequest::getScalingGroupId()const
+{
+	return scalingGroupId_;
+}
+
+void AttachVServerGroupsRequest::setScalingGroupId(const std::string& scalingGroupId)
+{
+	scalingGroupId_ = scalingGroupId;
+	setCoreParameter("ScalingGroupId", scalingGroupId);
+}
+
+bool AttachVServerGroupsRequest::getForceAttach()const
+{
+	return forceAttach_;
+}
+
+void AttachVServerGroupsRequest::setForceAttach(bool forceAttach)
+{
+	forceAttach_ = forceAttach;
+	setCoreParameter("ForceAttach", forceAttach ? "true" : "false");
+}
+
+long AttachVServerGroupsRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void AttachVServerGroupsRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setCoreParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::vector<AttachVServerGroupsRequest::VServerGroup> AttachVServerGroupsRequest::getVServerGroup()const
+{
+	return vServerGroup_;
+}
+
+void AttachVServerGroupsRequest::setVServerGroup(const std::vector<VServerGroup>& vServerGroup)
+{
+	vServerGroup_ = vServerGroup;
+	int i = 0;
+	for(int i = 0; i!= vServerGroup.size(); i++)	{
+		auto obj = vServerGroup.at(i);
+		std::string str ="VServerGroup."+ std::to_string(i);
+		setCoreParameter(str + ".LoadBalancerId", obj.loadBalancerId);
+		setCoreParameter(str + ".VServerGroupAttribute", std::to_string(obj.vServerGroupAttribute));
+	}
+}
+
+std::string AttachVServerGroupsRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void AttachVServerGroupsRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setCoreParameter("AccessKeyId", accessKeyId);
+}
+

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

ess/src/model/CompleteLifecycleActionRequest.cc

@@ -33,7 +33,7 @@ std::string CompleteLifecycleActionRequest::getLifecycleActionToken()const
 void CompleteLifecycleActionRequest::setLifecycleActionToken(const std::string& lifecycleActionToken)
 {
 	lifecycleActionToken_ = lifecycleActionToken;
-	setParameter("LifecycleActionToken", lifecycleActionToken);
+	setCoreParameter("LifecycleActionToken", lifecycleActionToken);
 }
 
 std::string CompleteLifecycleActionRequest::getResourceOwnerAccount()const
@@ -44,7 +44,7 @@ std::string CompleteLifecycleActionRequest::getResourceOwnerAccount()const
 void CompleteLifecycleActionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string CompleteLifecycleActionRequest::getLifecycleHookId()const
@@ -55,7 +55,7 @@ std::string CompleteLifecycleActionRequest::getLifecycleHookId()const
 void CompleteLifecycleActionRequest::setLifecycleHookId(const std::string& lifecycleHookId)
 {
 	lifecycleHookId_ = lifecycleHookId;
-	setParameter("LifecycleHookId", lifecycleHookId);
+	setCoreParameter("LifecycleHookId", lifecycleHookId);
 }
 
 std::string CompleteLifecycleActionRequest::getOwnerAccount()const
@@ -66,7 +66,7 @@ std::string CompleteLifecycleActionRequest::getOwnerAccount()const
 void CompleteLifecycleActionRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 long CompleteLifecycleActionRequest::getOwnerId()const
@@ -77,7 +77,7 @@ long CompleteLifecycleActionRequest::getOwnerId()const
 void CompleteLifecycleActionRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string CompleteLifecycleActionRequest::getLifecycleActionResult()const
@@ -88,7 +88,7 @@ std::string CompleteLifecycleActionRequest::getLifecycleActionResult()const
 void CompleteLifecycleActionRequest::setLifecycleActionResult(const std::string& lifecycleActionResult)
 {
 	lifecycleActionResult_ = lifecycleActionResult;
-	setParameter("LifecycleActionResult", lifecycleActionResult);
+	setCoreParameter("LifecycleActionResult", lifecycleActionResult);
 }
 
 std::string CompleteLifecycleActionRequest::getAccessKeyId()const
@@ -99,6 +99,6 @@ std::string CompleteLifecycleActionRequest::getAccessKeyId()const
 void CompleteLifecycleActionRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/CreateAlarmRequest.cc

@@ -33,7 +33,7 @@ std::string CreateAlarmRequest::getMetricType()const
 void CreateAlarmRequest::setMetricType(const std::string& metricType)
 {
 	metricType_ = metricType;
-	setParameter("MetricType", metricType);
+	setCoreParameter("MetricType", metricType);
 }
 
 int CreateAlarmRequest::getPeriod()const
@@ -44,7 +44,7 @@ int CreateAlarmRequest::getPeriod()const
 void CreateAlarmRequest::setPeriod(int period)
 {
 	period_ = period;
-	setParameter("Period", std::to_string(period));
+	setCoreParameter("Period", std::to_string(period));
 }
 
 std::string CreateAlarmRequest::getResourceOwnerAccount()const
@@ -55,7 +55,7 @@ std::string CreateAlarmRequest::getResourceOwnerAccount()const
 void CreateAlarmRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string CreateAlarmRequest::getScalingGroupId()const
@@ -66,7 +66,7 @@ std::string CreateAlarmRequest::getScalingGroupId()const
 void CreateAlarmRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 int CreateAlarmRequest::getGroupId()const
@@ -77,7 +77,7 @@ int CreateAlarmRequest::getGroupId()const
 void CreateAlarmRequest::setGroupId(int groupId)
 {
 	groupId_ = groupId;
-	setParameter("GroupId", std::to_string(groupId));
+	setCoreParameter("GroupId", std::to_string(groupId));
 }
 
 std::string CreateAlarmRequest::getDescription()const
@@ -88,7 +88,7 @@ std::string CreateAlarmRequest::getDescription()const
 void CreateAlarmRequest::setDescription(const std::string& description)
 {
 	description_ = description;
-	setParameter("Description", description);
+	setCoreParameter("Description", description);
 }
 
 std::vector<std::string> CreateAlarmRequest::getAlarmAction()const
@@ -100,7 +100,7 @@ void CreateAlarmRequest::setAlarmAction(const std::vector<std::string>& alarmAct
 {
 	alarmAction_ = alarmAction;
 	for(int i = 0; i!= alarmAction.size(); i++)
-		setParameter("AlarmAction."+ std::to_string(i), alarmAction.at(i));
+		setCoreParameter("AlarmAction."+ std::to_string(i), alarmAction.at(i));
 }
 
 float CreateAlarmRequest::getThreshold()const
@@ -111,7 +111,7 @@ float CreateAlarmRequest::getThreshold()const
 void CreateAlarmRequest::setThreshold(float threshold)
 {
 	threshold_ = threshold;
-	setParameter("Threshold", std::to_string(threshold));
+	setCoreParameter("Threshold", std::to_string(threshold));
 }
 
 long CreateAlarmRequest::getOwnerId()const
@@ -122,7 +122,7 @@ long CreateAlarmRequest::getOwnerId()const
 void CreateAlarmRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string CreateAlarmRequest::getAccessKeyId()const
@@ -133,7 +133,7 @@ std::string CreateAlarmRequest::getAccessKeyId()const
 void CreateAlarmRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CreateAlarmRequest::getRegionId()const
@@ -144,7 +144,7 @@ std::string CreateAlarmRequest::getRegionId()const
 void CreateAlarmRequest::setRegionId(const std::string& regionId)
 {
 	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+	setCoreParameter("RegionId", regionId);
 }
 
 std::string CreateAlarmRequest::getName()const
@@ -155,7 +155,7 @@ std::string CreateAlarmRequest::getName()const
 void CreateAlarmRequest::setName(const std::string& name)
 {
 	name_ = name;
-	setParameter("Name", name);
+	setCoreParameter("Name", name);
 }
 
 int CreateAlarmRequest::getEvaluationCount()const
@@ -166,7 +166,7 @@ int CreateAlarmRequest::getEvaluationCount()const
 void CreateAlarmRequest::setEvaluationCount(int evaluationCount)
 {
 	evaluationCount_ = evaluationCount;
-	setParameter("EvaluationCount", std::to_string(evaluationCount));
+	setCoreParameter("EvaluationCount", std::to_string(evaluationCount));
 }
 
 std::string CreateAlarmRequest::getMetricName()const
@@ -177,7 +177,7 @@ std::string CreateAlarmRequest::getMetricName()const
 void CreateAlarmRequest::setMetricName(const std::string& metricName)
 {
 	metricName_ = metricName;
-	setParameter("MetricName", metricName);
+	setCoreParameter("MetricName", metricName);
 }
 
 std::string CreateAlarmRequest::getComparisonOperator()const
@@ -188,7 +188,7 @@ std::string CreateAlarmRequest::getComparisonOperator()const
 void CreateAlarmRequest::setComparisonOperator(const std::string& comparisonOperator)
 {
 	comparisonOperator_ = comparisonOperator;
-	setParameter("ComparisonOperator", comparisonOperator);
+	setCoreParameter("ComparisonOperator", comparisonOperator);
 }
 
 std::vector<CreateAlarmRequest::Dimension> CreateAlarmRequest::getDimension()const
@@ -203,8 +203,8 @@ void CreateAlarmRequest::setDimension(const std::vector<Dimension>& dimension)
 	for(int i = 0; i!= dimension.size(); i++)	{
 		auto obj = dimension.at(i);
 		std::string str ="Dimension."+ std::to_string(i);
-		setParameter(str + ".DimensionValue", obj.dimensionValue);
-		setParameter(str + ".DimensionKey", obj.dimensionKey);
+		setCoreParameter(str + ".DimensionValue", obj.dimensionValue);
+		setCoreParameter(str + ".DimensionKey", obj.dimensionKey);
 	}
 }
 
@@ -216,6 +216,6 @@ std::string CreateAlarmRequest::getStatistics()const
 void CreateAlarmRequest::setStatistics(const std::string& statistics)
 {
 	statistics_ = statistics;
-	setParameter("Statistics", statistics);
+	setCoreParameter("Statistics", statistics);
 }
 

ess/src/model/CreateLifecycleHookRequest.cc

@@ -33,7 +33,7 @@ std::string CreateLifecycleHookRequest::getDefaultResult()const
 void CreateLifecycleHookRequest::setDefaultResult(const std::string& defaultResult)
 {
 	defaultResult_ = defaultResult;
-	setParameter("DefaultResult", defaultResult);
+	setCoreParameter("DefaultResult", defaultResult);
 }
 
 std::string CreateLifecycleHookRequest::getResourceOwnerAccount()const
@@ -44,7 +44,7 @@ std::string CreateLifecycleHookRequest::getResourceOwnerAccount()const
 void CreateLifecycleHookRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 int CreateLifecycleHookRequest::getHeartbeatTimeout()const
@@ -55,7 +55,7 @@ int CreateLifecycleHookRequest::getHeartbeatTimeout()const
 void CreateLifecycleHookRequest::setHeartbeatTimeout(int heartbeatTimeout)
 {
 	heartbeatTimeout_ = heartbeatTimeout;
-	setParameter("HeartbeatTimeout", std::to_string(heartbeatTimeout));
+	setCoreParameter("HeartbeatTimeout", std::to_string(heartbeatTimeout));
 }
 
 std::string CreateLifecycleHookRequest::getScalingGroupId()const
@@ -66,7 +66,7 @@ std::string CreateLifecycleHookRequest::getScalingGroupId()const
 void CreateLifecycleHookRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 std::string CreateLifecycleHookRequest::getOwnerAccount()const
@@ -77,7 +77,7 @@ std::string CreateLifecycleHookRequest::getOwnerAccount()const
 void CreateLifecycleHookRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 std::string CreateLifecycleHookRequest::getNotificationMetadata()const
@@ -88,7 +88,7 @@ std::string CreateLifecycleHookRequest::getNotificationMetadata()const
 void CreateLifecycleHookRequest::setNotificationMetadata(const std::string& notificationMetadata)
 {
 	notificationMetadata_ = notificationMetadata;
-	setParameter("NotificationMetadata", notificationMetadata);
+	setCoreParameter("NotificationMetadata", notificationMetadata);
 }
 
 long CreateLifecycleHookRequest::getOwnerId()const
@@ -99,7 +99,7 @@ long CreateLifecycleHookRequest::getOwnerId()const
 void CreateLifecycleHookRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string CreateLifecycleHookRequest::getLifecycleTransition()const
@@ -110,7 +110,7 @@ std::string CreateLifecycleHookRequest::getLifecycleTransition()const
 void CreateLifecycleHookRequest::setLifecycleTransition(const std::string& lifecycleTransition)
 {
 	lifecycleTransition_ = lifecycleTransition;
-	setParameter("LifecycleTransition", lifecycleTransition);
+	setCoreParameter("LifecycleTransition", lifecycleTransition);
 }
 
 std::string CreateLifecycleHookRequest::getAccessKeyId()const
@@ -121,7 +121,7 @@ std::string CreateLifecycleHookRequest::getAccessKeyId()const
 void CreateLifecycleHookRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CreateLifecycleHookRequest::getLifecycleHookName()const
@@ -132,7 +132,7 @@ std::string CreateLifecycleHookRequest::getLifecycleHookName()const
 void CreateLifecycleHookRequest::setLifecycleHookName(const std::string& lifecycleHookName)
 {
 	lifecycleHookName_ = lifecycleHookName;
-	setParameter("LifecycleHookName", lifecycleHookName);
+	setCoreParameter("LifecycleHookName", lifecycleHookName);
 }
 
 std::string CreateLifecycleHookRequest::getNotificationArn()const
@@ -143,7 +143,7 @@ std::string CreateLifecycleHookRequest::getNotificationArn()const
 void CreateLifecycleHookRequest::setNotificationArn(const std::string& notificationArn)
 {
 	notificationArn_ = notificationArn;
-	setParameter("NotificationArn", notificationArn);
+	setCoreParameter("NotificationArn", notificationArn);
 }
 
 std::vector<CreateLifecycleHookRequest::LifecycleHook> CreateLifecycleHookRequest::getLifecycleHook()const
@@ -158,12 +158,12 @@ void CreateLifecycleHookRequest::setLifecycleHook(const std::vector<LifecycleHoo
 	for(int i = 0; i!= lifecycleHook.size(); i++)	{
 		auto obj = lifecycleHook.at(i);
 		std::string str ="LifecycleHook."+ std::to_string(i);
-		setParameter(str + ".DefaultResult", obj.defaultResult);
-		setParameter(str + ".LifecycleHookName", obj.lifecycleHookName);
-		setParameter(str + ".HeartbeatTimeout", std::to_string(obj.heartbeatTimeout));
-		setParameter(str + ".NotificationArn", obj.notificationArn);
-		setParameter(str + ".NotificationMetadata", obj.notificationMetadata);
-		setParameter(str + ".LifecycleTransition", obj.lifecycleTransition);
+		setCoreParameter(str + ".DefaultResult", obj.defaultResult);
+		setCoreParameter(str + ".LifecycleHookName", obj.lifecycleHookName);
+		setCoreParameter(str + ".HeartbeatTimeout", std::to_string(obj.heartbeatTimeout));
+		setCoreParameter(str + ".NotificationArn", obj.notificationArn);
+		setCoreParameter(str + ".NotificationMetadata", obj.notificationMetadata);
+		setCoreParameter(str + ".LifecycleTransition", obj.lifecycleTransition);
 	}
 }
 

ess/src/model/CreateNotificationConfigurationRequest.cc

@@ -33,7 +33,7 @@ std::string CreateNotificationConfigurationRequest::getResourceOwnerAccount()con
 void CreateNotificationConfigurationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string CreateNotificationConfigurationRequest::getScalingGroupId()const
@@ -44,7 +44,7 @@ std::string CreateNotificationConfigurationRequest::getScalingGroupId()const
 void CreateNotificationConfigurationRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 std::string CreateNotificationConfigurationRequest::getNotificationArn()const
@@ -55,7 +55,7 @@ std::string CreateNotificationConfigurationRequest::getNotificationArn()const
 void CreateNotificationConfigurationRequest::setNotificationArn(const std::string& notificationArn)
 {
 	notificationArn_ = notificationArn;
-	setParameter("NotificationArn", notificationArn);
+	setCoreParameter("NotificationArn", notificationArn);
 }
 
 std::vector<std::string> CreateNotificationConfigurationRequest::getNotificationType()const
@@ -67,7 +67,7 @@ void CreateNotificationConfigurationRequest::setNotificationType(const std::vect
 {
 	notificationType_ = notificationType;
 	for(int i = 0; i!= notificationType.size(); i++)
-		setParameter("NotificationType."+ std::to_string(i), notificationType.at(i));
+		setCoreParameter("NotificationType."+ std::to_string(i), notificationType.at(i));
 }
 
 long CreateNotificationConfigurationRequest::getOwnerId()const
@@ -78,7 +78,7 @@ long CreateNotificationConfigurationRequest::getOwnerId()const
 void CreateNotificationConfigurationRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string CreateNotificationConfigurationRequest::getAccessKeyId()const
@@ -89,6 +89,6 @@ std::string CreateNotificationConfigurationRequest::getAccessKeyId()const
 void CreateNotificationConfigurationRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/CreateScalingConfigurationRequest.cc

@@ -33,7 +33,7 @@ std::string CreateScalingConfigurationRequest::getImageId()const
 void CreateScalingConfigurationRequest::setImageId(const std::string& imageId)
 {
 	imageId_ = imageId;
-	setParameter("ImageId", imageId);
+	setCoreParameter("ImageId", imageId);
 }
 
 int CreateScalingConfigurationRequest::getMemory()const
@@ -44,7 +44,7 @@ int CreateScalingConfigurationRequest::getMemory()const
 void CreateScalingConfigurationRequest::setMemory(int memory)
 {
 	memory_ = memory;
-	setParameter("Memory", std::to_string(memory));
+	setCoreParameter("Memory", std::to_string(memory));
 }
 
 std::string CreateScalingConfigurationRequest::getScalingGroupId()const
@@ -55,7 +55,7 @@ std::string CreateScalingConfigurationRequest::getScalingGroupId()const
 void CreateScalingConfigurationRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 std::vector<std::string> CreateScalingConfigurationRequest::getInstanceTypes()const
@@ -67,7 +67,7 @@ void CreateScalingConfigurationRequest::setInstanceTypes(const std::vector<std::
 {
 	instanceTypes_ = instanceTypes;
 	for(int i = 0; i!= instanceTypes.size(); i++)
-		setParameter("InstanceTypes."+ std::to_string(i), instanceTypes.at(i));
+		setCoreParameter("InstanceTypes."+ std::to_string(i), instanceTypes.at(i));
 }
 
 std::string CreateScalingConfigurationRequest::getIoOptimized()const
@@ -78,7 +78,7 @@ std::string CreateScalingConfigurationRequest::getIoOptimized()const
 void CreateScalingConfigurationRequest::setIoOptimized(const std::string& ioOptimized)
 {
 	ioOptimized_ = ioOptimized;
-	setParameter("IoOptimized", ioOptimized);
+	setCoreParameter("IoOptimized", ioOptimized);
 }
 
 std::string CreateScalingConfigurationRequest::getSecurityGroupId()const
@@ -89,7 +89,7 @@ std::string CreateScalingConfigurationRequest::getSecurityGroupId()const
 void CreateScalingConfigurationRequest::setSecurityGroupId(const std::string& securityGroupId)
 {
 	securityGroupId_ = securityGroupId;
-	setParameter("SecurityGroupId", securityGroupId);
+	setCoreParameter("SecurityGroupId", securityGroupId);
 }
 
 int CreateScalingConfigurationRequest::getInternetMaxBandwidthOut()const
@@ -100,7 +100,7 @@ int CreateScalingConfigurationRequest::getInternetMaxBandwidthOut()const
 void CreateScalingConfigurationRequest::setInternetMaxBandwidthOut(int internetMaxBandwidthOut)
 {
 	internetMaxBandwidthOut_ = internetMaxBandwidthOut;
-	setParameter("InternetMaxBandwidthOut", std::to_string(internetMaxBandwidthOut));
+	setCoreParameter("InternetMaxBandwidthOut", std::to_string(internetMaxBandwidthOut));
 }
 
 std::string CreateScalingConfigurationRequest::getSecurityEnhancementStrategy()const
@@ -111,7 +111,7 @@ std::string CreateScalingConfigurationRequest::getSecurityEnhancementStrategy()c
 void CreateScalingConfigurationRequest::setSecurityEnhancementStrategy(const std::string& securityEnhancementStrategy)
 {
 	securityEnhancementStrategy_ = securityEnhancementStrategy;
-	setParameter("SecurityEnhancementStrategy", securityEnhancementStrategy);
+	setCoreParameter("SecurityEnhancementStrategy", securityEnhancementStrategy);
 }
 
 std::string CreateScalingConfigurationRequest::getKeyPairName()const
@@ -122,7 +122,7 @@ std::string CreateScalingConfigurationRequest::getKeyPairName()const
 void CreateScalingConfigurationRequest::setKeyPairName(const std::string& keyPairName)
 {
 	keyPairName_ = keyPairName;
-	setParameter("KeyPairName", keyPairName);
+	setCoreParameter("KeyPairName", keyPairName);
 }
 
 std::vector<CreateScalingConfigurationRequest::SpotPriceLimit> CreateScalingConfigurationRequest::getSpotPriceLimit()const
@@ -137,8 +137,8 @@ void CreateScalingConfigurationRequest::setSpotPriceLimit(const std::vector<Spot
 	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));
+		setCoreParameter(str + ".InstanceType", obj.instanceType);
+		setCoreParameter(str + ".PriceLimit", std::to_string(obj.priceLimit));
 	}
 }
 
@@ -150,7 +150,7 @@ std::string CreateScalingConfigurationRequest::getSystemDiskCategory()const
 void CreateScalingConfigurationRequest::setSystemDiskCategory(const std::string& systemDiskCategory)
 {
 	systemDiskCategory_ = systemDiskCategory;
-	setParameter("SystemDiskCategory", systemDiskCategory);
+	setCoreParameter("SystemDiskCategory", systemDiskCategory);
 }
 
 std::string CreateScalingConfigurationRequest::getAccessKeyId()const
@@ -161,7 +161,7 @@ std::string CreateScalingConfigurationRequest::getAccessKeyId()const
 void CreateScalingConfigurationRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CreateScalingConfigurationRequest::getUserData()const
@@ -172,7 +172,18 @@ std::string CreateScalingConfigurationRequest::getUserData()const
 void CreateScalingConfigurationRequest::setUserData(const std::string& userData)
 {
 	userData_ = userData;
-	setParameter("UserData", userData);
+	setCoreParameter("UserData", userData);
+}
+
+std::string CreateScalingConfigurationRequest::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+void CreateScalingConfigurationRequest::setResourceGroupId(const std::string& resourceGroupId)
+{
+	resourceGroupId_ = resourceGroupId;
+	setCoreParameter("ResourceGroupId", resourceGroupId);
 }
 
 std::string CreateScalingConfigurationRequest::getHostName()const
@@ -183,7 +194,7 @@ std::string CreateScalingConfigurationRequest::getHostName()const
 void CreateScalingConfigurationRequest::setHostName(const std::string& hostName)
 {
 	hostName_ = hostName;
-	setParameter("HostName", hostName);
+	setCoreParameter("HostName", hostName);
 }
 
 std::string CreateScalingConfigurationRequest::getPassword()const
@@ -194,7 +205,7 @@ std::string CreateScalingConfigurationRequest::getPassword()const
 void CreateScalingConfigurationRequest::setPassword(const std::string& password)
 {
 	password_ = password;
-	setParameter("Password", password);
+	setCoreParameter("Password", password);
 }
 
 bool CreateScalingConfigurationRequest::getPasswordInherit()const
@@ -205,7 +216,7 @@ bool CreateScalingConfigurationRequest::getPasswordInherit()const
 void CreateScalingConfigurationRequest::setPasswordInherit(bool passwordInherit)
 {
 	passwordInherit_ = passwordInherit;
-	setParameter("PasswordInherit", std::to_string(passwordInherit));
+	setCoreParameter("PasswordInherit", passwordInherit ? "true" : "false");
 }
 
 std::string CreateScalingConfigurationRequest::getImageName()const
@@ -216,7 +227,7 @@ std::string CreateScalingConfigurationRequest::getImageName()const
 void CreateScalingConfigurationRequest::setImageName(const std::string& imageName)
 {
 	imageName_ = imageName;
-	setParameter("ImageName", imageName);
+	setCoreParameter("ImageName", imageName);
 }
 
 std::string CreateScalingConfigurationRequest::getInstanceType()const
@@ -227,7 +238,7 @@ std::string CreateScalingConfigurationRequest::getInstanceType()const
 void CreateScalingConfigurationRequest::setInstanceType(const std::string& instanceType)
 {
 	instanceType_ = instanceType;
-	setParameter("InstanceType", instanceType);
+	setCoreParameter("InstanceType", instanceType);
 }
 
 std::string CreateScalingConfigurationRequest::getDeploymentSetId()const
@@ -238,7 +249,7 @@ std::string CreateScalingConfigurationRequest::getDeploymentSetId()const
 void CreateScalingConfigurationRequest::setDeploymentSetId(const std::string& deploymentSetId)
 {
 	deploymentSetId_ = deploymentSetId;
-	setParameter("DeploymentSetId", deploymentSetId);
+	setCoreParameter("DeploymentSetId", deploymentSetId);
 }
 
 std::string CreateScalingConfigurationRequest::getResourceOwnerAccount()const
@@ -249,7 +260,7 @@ std::string CreateScalingConfigurationRequest::getResourceOwnerAccount()const
 void CreateScalingConfigurationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string CreateScalingConfigurationRequest::getOwnerAccount()const
@@ -260,7 +271,7 @@ std::string CreateScalingConfigurationRequest::getOwnerAccount()const
 void CreateScalingConfigurationRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 int CreateScalingConfigurationRequest::getCpu()const
@@ -271,7 +282,18 @@ int CreateScalingConfigurationRequest::getCpu()const
 void CreateScalingConfigurationRequest::setCpu(int cpu)
 {
 	cpu_ = cpu;
-	setParameter("Cpu", std::to_string(cpu));
+	setCoreParameter("Cpu", std::to_string(cpu));
+}
+
+std::string CreateScalingConfigurationRequest::getSystemDiskDiskName()const
+{
+	return systemDiskDiskName_;
+}
+
+void CreateScalingConfigurationRequest::setSystemDiskDiskName(const std::string& systemDiskDiskName)
+{
+	systemDiskDiskName_ = systemDiskDiskName;
+	setCoreParameter("SystemDiskDiskName", systemDiskDiskName);
 }
 
 std::string CreateScalingConfigurationRequest::getRamRoleName()const
@@ -282,7 +304,7 @@ std::string CreateScalingConfigurationRequest::getRamRoleName()const
 void CreateScalingConfigurationRequest::setRamRoleName(const std::string& ramRoleName)
 {
 	ramRoleName_ = ramRoleName;
-	setParameter("RamRoleName", ramRoleName);
+	setCoreParameter("RamRoleName", ramRoleName);
 }
 
 long CreateScalingConfigurationRequest::getOwnerId()const
@@ -293,7 +315,7 @@ long CreateScalingConfigurationRequest::getOwnerId()const
 void CreateScalingConfigurationRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::vector<CreateScalingConfigurationRequest::DataDisk> CreateScalingConfigurationRequest::getDataDisk()const
@@ -308,11 +330,15 @@ void CreateScalingConfigurationRequest::setDataDisk(const std::vector<DataDisk>&
 	for(int i = 0; i!= dataDisk.size(); i++)	{
 		auto obj = dataDisk.at(i);
 		std::string str ="DataDisk."+ std::to_string(i);
-		setParameter(str + ".SnapshotId", obj.snapshotId);
-		setParameter(str + ".Size", std::to_string(obj.size));
-		setParameter(str + ".Category", obj.category);
-		setParameter(str + ".Device", obj.device);
-		setParameter(str + ".DeleteWithInstance", std::to_string(obj.deleteWithInstance));
+		setCoreParameter(str + ".DiskName", obj.diskName);
+		setCoreParameter(str + ".SnapshotId", obj.snapshotId);
+		setCoreParameter(str + ".Size", std::to_string(obj.size));
+		setCoreParameter(str + ".Encrypted", obj.encrypted);
+		setCoreParameter(str + ".Description", obj.description);
+		setCoreParameter(str + ".Category", obj.category);
+		setCoreParameter(str + ".KMSKeyId", obj.kMSKeyId);
+		setCoreParameter(str + ".Device", obj.device);
+		setCoreParameter(str + ".DeleteWithInstance", obj.deleteWithInstance ? "true" : "false");
 	}
 }
 
@@ -324,7 +350,7 @@ std::string CreateScalingConfigurationRequest::getScalingConfigurationName()cons
 void CreateScalingConfigurationRequest::setScalingConfigurationName(const std::string& scalingConfigurationName)
 {
 	scalingConfigurationName_ = scalingConfigurationName;
-	setParameter("ScalingConfigurationName", scalingConfigurationName);
+	setCoreParameter("ScalingConfigurationName", scalingConfigurationName);
 }
 
 std::string CreateScalingConfigurationRequest::getTags()const
@@ -335,7 +361,7 @@ std::string CreateScalingConfigurationRequest::getTags()const
 void CreateScalingConfigurationRequest::setTags(const std::string& tags)
 {
 	tags_ = tags;
-	setParameter("Tags", tags);
+	setCoreParameter("Tags", tags);
 }
 
 std::string CreateScalingConfigurationRequest::getSpotStrategy()const
@@ -346,7 +372,7 @@ std::string CreateScalingConfigurationRequest::getSpotStrategy()const
 void CreateScalingConfigurationRequest::setSpotStrategy(const std::string& spotStrategy)
 {
 	spotStrategy_ = spotStrategy;
-	setParameter("SpotStrategy", spotStrategy);
+	setCoreParameter("SpotStrategy", spotStrategy);
 }
 
 int CreateScalingConfigurationRequest::getLoadBalancerWeight()const
@@ -357,7 +383,7 @@ int CreateScalingConfigurationRequest::getLoadBalancerWeight()const
 void CreateScalingConfigurationRequest::setLoadBalancerWeight(int loadBalancerWeight)
 {
 	loadBalancerWeight_ = loadBalancerWeight;
-	setParameter("LoadBalancerWeight", std::to_string(loadBalancerWeight));
+	setCoreParameter("LoadBalancerWeight", std::to_string(loadBalancerWeight));
 }
 
 std::string CreateScalingConfigurationRequest::getInstanceName()const
@@ -368,7 +394,7 @@ std::string CreateScalingConfigurationRequest::getInstanceName()const
 void CreateScalingConfigurationRequest::setInstanceName(const std::string& instanceName)
 {
 	instanceName_ = instanceName;
-	setParameter("InstanceName", instanceName);
+	setCoreParameter("InstanceName", instanceName);
 }
 
 int CreateScalingConfigurationRequest::getSystemDiskSize()const
@@ -379,7 +405,7 @@ int CreateScalingConfigurationRequest::getSystemDiskSize()const
 void CreateScalingConfigurationRequest::setSystemDiskSize(int systemDiskSize)
 {
 	systemDiskSize_ = systemDiskSize;
-	setParameter("SystemDiskSize", std::to_string(systemDiskSize));
+	setCoreParameter("SystemDiskSize", std::to_string(systemDiskSize));
 }
 
 std::string CreateScalingConfigurationRequest::getInternetChargeType()const
@@ -390,7 +416,7 @@ std::string CreateScalingConfigurationRequest::getInternetChargeType()const
 void CreateScalingConfigurationRequest::setInternetChargeType(const std::string& internetChargeType)
 {
 	internetChargeType_ = internetChargeType;
-	setParameter("InternetChargeType", internetChargeType);
+	setCoreParameter("InternetChargeType", internetChargeType);
 }
 
 int CreateScalingConfigurationRequest::getInternetMaxBandwidthIn()const
@@ -401,6 +427,17 @@ int CreateScalingConfigurationRequest::getInternetMaxBandwidthIn()const
 void CreateScalingConfigurationRequest::setInternetMaxBandwidthIn(int internetMaxBandwidthIn)
 {
 	internetMaxBandwidthIn_ = internetMaxBandwidthIn;
-	setParameter("InternetMaxBandwidthIn", std::to_string(internetMaxBandwidthIn));
+	setCoreParameter("InternetMaxBandwidthIn", std::to_string(internetMaxBandwidthIn));
+}
+
+std::string CreateScalingConfigurationRequest::getSystemDiskDescription()const
+{
+	return systemDiskDescription_;
+}
+
+void CreateScalingConfigurationRequest::setSystemDiskDescription(const std::string& systemDiskDescription)
+{
+	systemDiskDescription_ = systemDiskDescription;
+	setCoreParameter("SystemDiskDescription", systemDiskDescription);
 }
 

ess/src/model/CreateScalingGroupRequest.cc

@@ -33,7 +33,7 @@ std::string CreateScalingGroupRequest::getMultiAZPolicy()const
 void CreateScalingGroupRequest::setMultiAZPolicy(const std::string& multiAZPolicy)
 {
 	multiAZPolicy_ = multiAZPolicy;
-	setParameter("MultiAZPolicy", multiAZPolicy);
+	setCoreParameter("MultiAZPolicy", multiAZPolicy);
 }
 
 std::string CreateScalingGroupRequest::getDBInstanceIds()const
@@ -44,7 +44,7 @@ std::string CreateScalingGroupRequest::getDBInstanceIds()const
 void CreateScalingGroupRequest::setDBInstanceIds(const std::string& dBInstanceIds)
 {
 	dBInstanceIds_ = dBInstanceIds;
-	setParameter("DBInstanceIds", dBInstanceIds);
+	setCoreParameter("DBInstanceIds", dBInstanceIds);
 }
 
 std::string CreateScalingGroupRequest::getLaunchTemplateId()const
@@ -55,7 +55,7 @@ std::string CreateScalingGroupRequest::getLaunchTemplateId()const
 void CreateScalingGroupRequest::setLaunchTemplateId(const std::string& launchTemplateId)
 {
 	launchTemplateId_ = launchTemplateId;
-	setParameter("LaunchTemplateId", launchTemplateId);
+	setCoreParameter("LaunchTemplateId", launchTemplateId);
 }
 
 std::string CreateScalingGroupRequest::getLoadBalancerIds()const
@@ -66,7 +66,7 @@ std::string CreateScalingGroupRequest::getLoadBalancerIds()const
 void CreateScalingGroupRequest::setLoadBalancerIds(const std::string& loadBalancerIds)
 {
 	loadBalancerIds_ = loadBalancerIds;
-	setParameter("LoadBalancerIds", loadBalancerIds);
+	setCoreParameter("LoadBalancerIds", loadBalancerIds);
 }
 
 std::string CreateScalingGroupRequest::getHealthCheckType()const
@@ -77,7 +77,7 @@ std::string CreateScalingGroupRequest::getHealthCheckType()const
 void CreateScalingGroupRequest::setHealthCheckType(const std::string& healthCheckType)
 {
 	healthCheckType_ = healthCheckType;
-	setParameter("HealthCheckType", healthCheckType);
+	setCoreParameter("HealthCheckType", healthCheckType);
 }
 
 std::string CreateScalingGroupRequest::getResourceOwnerAccount()const
@@ -88,7 +88,7 @@ std::string CreateScalingGroupRequest::getResourceOwnerAccount()const
 void CreateScalingGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string CreateScalingGroupRequest::getScalingGroupName()const
@@ -99,7 +99,18 @@ std::string CreateScalingGroupRequest::getScalingGroupName()const
 void CreateScalingGroupRequest::setScalingGroupName(const std::string& scalingGroupName)
 {
 	scalingGroupName_ = scalingGroupName;
-	setParameter("ScalingGroupName", scalingGroupName);
+	setCoreParameter("ScalingGroupName", scalingGroupName);
+}
+
+std::string CreateScalingGroupRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateScalingGroupRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setCoreParameter("ClientToken", clientToken);
 }
 
 std::vector<std::string> CreateScalingGroupRequest::getVSwitchIds()const
@@ -111,7 +122,7 @@ void CreateScalingGroupRequest::setVSwitchIds(const std::vector<std::string>& vS
 {
 	vSwitchIds_ = vSwitchIds;
 	for(int i = 0; i!= vSwitchIds.size(); i++)
-		setParameter("VSwitchIds."+ std::to_string(i), vSwitchIds.at(i));
+		setCoreParameter("VSwitchIds."+ std::to_string(i), vSwitchIds.at(i));
 }
 
 std::string CreateScalingGroupRequest::getOwnerAccount()const
@@ -122,7 +133,7 @@ std::string CreateScalingGroupRequest::getOwnerAccount()const
 void CreateScalingGroupRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 int CreateScalingGroupRequest::getMinSize()const
@@ -133,7 +144,7 @@ int CreateScalingGroupRequest::getMinSize()const
 void CreateScalingGroupRequest::setMinSize(int minSize)
 {
 	minSize_ = minSize;
-	setParameter("MinSize", std::to_string(minSize));
+	setCoreParameter("MinSize", std::to_string(minSize));
 }
 
 long CreateScalingGroupRequest::getOwnerId()const
@@ -144,7 +155,7 @@ long CreateScalingGroupRequest::getOwnerId()const
 void CreateScalingGroupRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string CreateScalingGroupRequest::getLaunchTemplateVersion()const
@@ -155,7 +166,7 @@ std::string CreateScalingGroupRequest::getLaunchTemplateVersion()const
 void CreateScalingGroupRequest::setLaunchTemplateVersion(const std::string& launchTemplateVersion)
 {
 	launchTemplateVersion_ = launchTemplateVersion;
-	setParameter("LaunchTemplateVersion", launchTemplateVersion);
+	setCoreParameter("LaunchTemplateVersion", launchTemplateVersion);
 }
 
 std::string CreateScalingGroupRequest::getScalingPolicy()const
@@ -166,7 +177,7 @@ std::string CreateScalingGroupRequest::getScalingPolicy()const
 void CreateScalingGroupRequest::setScalingPolicy(const std::string& scalingPolicy)
 {
 	scalingPolicy_ = scalingPolicy;
-	setParameter("ScalingPolicy", scalingPolicy);
+	setCoreParameter("ScalingPolicy", scalingPolicy);
 }
 
 std::string CreateScalingGroupRequest::getAccessKeyId()const
@@ -177,7 +188,7 @@ std::string CreateScalingGroupRequest::getAccessKeyId()const
 void CreateScalingGroupRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CreateScalingGroupRequest::getVSwitchId()const
@@ -188,7 +199,7 @@ std::string CreateScalingGroupRequest::getVSwitchId()const
 void CreateScalingGroupRequest::setVSwitchId(const std::string& vSwitchId)
 {
 	vSwitchId_ = vSwitchId;
-	setParameter("VSwitchId", vSwitchId);
+	setCoreParameter("VSwitchId", vSwitchId);
 }
 
 std::string CreateScalingGroupRequest::getRegionId()const
@@ -199,7 +210,7 @@ std::string CreateScalingGroupRequest::getRegionId()const
 void CreateScalingGroupRequest::setRegionId(const std::string& regionId)
 {
 	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+	setCoreParameter("RegionId", regionId);
 }
 
 int CreateScalingGroupRequest::getMaxSize()const
@@ -210,7 +221,7 @@ int CreateScalingGroupRequest::getMaxSize()const
 void CreateScalingGroupRequest::setMaxSize(int maxSize)
 {
 	maxSize_ = maxSize;
-	setParameter("MaxSize", std::to_string(maxSize));
+	setCoreParameter("MaxSize", std::to_string(maxSize));
 }
 
 std::vector<CreateScalingGroupRequest::LifecycleHook> CreateScalingGroupRequest::getLifecycleHook()const
@@ -225,12 +236,12 @@ void CreateScalingGroupRequest::setLifecycleHook(const std::vector<LifecycleHook
 	for(int i = 0; i!= lifecycleHook.size(); i++)	{
 		auto obj = lifecycleHook.at(i);
 		std::string str ="LifecycleHook."+ std::to_string(i);
-		setParameter(str + ".DefaultResult", obj.defaultResult);
-		setParameter(str + ".LifecycleHookName", obj.lifecycleHookName);
-		setParameter(str + ".HeartbeatTimeout", std::to_string(obj.heartbeatTimeout));
-		setParameter(str + ".NotificationArn", obj.notificationArn);
-		setParameter(str + ".NotificationMetadata", obj.notificationMetadata);
-		setParameter(str + ".LifecycleTransition", obj.lifecycleTransition);
+		setCoreParameter(str + ".DefaultResult", obj.defaultResult);
+		setCoreParameter(str + ".LifecycleHookName", obj.lifecycleHookName);
+		setCoreParameter(str + ".HeartbeatTimeout", std::to_string(obj.heartbeatTimeout));
+		setCoreParameter(str + ".NotificationArn", obj.notificationArn);
+		setCoreParameter(str + ".NotificationMetadata", obj.notificationMetadata);
+		setCoreParameter(str + ".LifecycleTransition", obj.lifecycleTransition);
 	}
 }
 
@@ -242,7 +253,7 @@ int CreateScalingGroupRequest::getDefaultCooldown()const
 void CreateScalingGroupRequest::setDefaultCooldown(int defaultCooldown)
 {
 	defaultCooldown_ = defaultCooldown;
-	setParameter("DefaultCooldown", std::to_string(defaultCooldown));
+	setCoreParameter("DefaultCooldown", std::to_string(defaultCooldown));
 }
 
 std::string CreateScalingGroupRequest::getRemovalPolicy1()const
@@ -253,7 +264,24 @@ std::string CreateScalingGroupRequest::getRemovalPolicy1()const
 void CreateScalingGroupRequest::setRemovalPolicy1(const std::string& removalPolicy1)
 {
 	removalPolicy1_ = removalPolicy1;
-	setParameter("RemovalPolicy1", removalPolicy1);
+	setCoreParameter("RemovalPolicy1", removalPolicy1);
+}
+
+std::vector<CreateScalingGroupRequest::VServerGroup> CreateScalingGroupRequest::getVServerGroup()const
+{
+	return vServerGroup_;
+}
+
+void CreateScalingGroupRequest::setVServerGroup(const std::vector<VServerGroup>& vServerGroup)
+{
+	vServerGroup_ = vServerGroup;
+	int i = 0;
+	for(int i = 0; i!= vServerGroup.size(); i++)	{
+		auto obj = vServerGroup.at(i);
+		std::string str ="VServerGroup."+ std::to_string(i);
+		setCoreParameter(str + ".LoadBalancerId", obj.loadBalancerId);
+		setCoreParameter(str + ".VServerGroupAttribute", std::to_string(obj.vServerGroupAttribute));
+	}
 }
 
 std::string CreateScalingGroupRequest::getRemovalPolicy2()const
@@ -264,6 +292,6 @@ std::string CreateScalingGroupRequest::getRemovalPolicy2()const
 void CreateScalingGroupRequest::setRemovalPolicy2(const std::string& removalPolicy2)
 {
 	removalPolicy2_ = removalPolicy2;
-	setParameter("RemovalPolicy2", removalPolicy2);
+	setCoreParameter("RemovalPolicy2", removalPolicy2);
 }
 

ess/src/model/CreateScalingRuleRequest.cc

@@ -25,17 +25,6 @@ CreateScalingRuleRequest::CreateScalingRuleRequest() :
 CreateScalingRuleRequest::~CreateScalingRuleRequest()
 {}
 
-std::string CreateScalingRuleRequest::getScalingRuleName()const
-{
-	return scalingRuleName_;
-}
-
-void CreateScalingRuleRequest::setScalingRuleName(const std::string& scalingRuleName)
-{
-	scalingRuleName_ = scalingRuleName;
-	setParameter("ScalingRuleName", scalingRuleName);
-}
-
 std::string CreateScalingRuleRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -44,7 +33,7 @@ std::string CreateScalingRuleRequest::getResourceOwnerAccount()const
 void CreateScalingRuleRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 int CreateScalingRuleRequest::getAdjustmentValue()const
@@ -55,7 +44,25 @@ int CreateScalingRuleRequest::getAdjustmentValue()const
 void CreateScalingRuleRequest::setAdjustmentValue(int adjustmentValue)
 {
 	adjustmentValue_ = adjustmentValue;
-	setParameter("AdjustmentValue", std::to_string(adjustmentValue));
+	setCoreParameter("AdjustmentValue", std::to_string(adjustmentValue));
+}
+
+std::vector<CreateScalingRuleRequest::StepAdjustment> CreateScalingRuleRequest::getStepAdjustment()const
+{
+	return stepAdjustment_;
+}
+
+void CreateScalingRuleRequest::setStepAdjustment(const std::vector<StepAdjustment>& stepAdjustment)
+{
+	stepAdjustment_ = stepAdjustment;
+	int i = 0;
+	for(int i = 0; i!= stepAdjustment.size(); i++)	{
+		auto obj = stepAdjustment.at(i);
+		std::string str ="StepAdjustment."+ std::to_string(i);
+		setCoreParameter(str + ".MetricIntervalLowerBound", std::to_string(obj.metricIntervalLowerBound));
+		setCoreParameter(str + ".MetricIntervalUpperBound", std::to_string(obj.metricIntervalUpperBound));
+		setCoreParameter(str + ".ScalingAdjustment", std::to_string(obj.scalingAdjustment));
+	}
 }
 
 std::string CreateScalingRuleRequest::getScalingGroupId()const
@@ -66,29 +73,29 @@ std::string CreateScalingRuleRequest::getScalingGroupId()const
 void CreateScalingRuleRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
-std::string CreateScalingRuleRequest::getOwnerAccount()const
+int CreateScalingRuleRequest::getEstimatedInstanceWarmup()const
 {
-	return ownerAccount_;
+	return estimatedInstanceWarmup_;
 }
 
-void CreateScalingRuleRequest::setOwnerAccount(const std::string& ownerAccount)
+void CreateScalingRuleRequest::setEstimatedInstanceWarmup(int estimatedInstanceWarmup)
 {
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	estimatedInstanceWarmup_ = estimatedInstanceWarmup;
+	setCoreParameter("EstimatedInstanceWarmup", std::to_string(estimatedInstanceWarmup));
 }
 
-int CreateScalingRuleRequest::getCooldown()const
+std::string CreateScalingRuleRequest::getOwnerAccount()const
 {
-	return cooldown_;
+	return ownerAccount_;
 }
 
-void CreateScalingRuleRequest::setCooldown(int cooldown)
+void CreateScalingRuleRequest::setOwnerAccount(const std::string& ownerAccount)
 {
-	cooldown_ = cooldown;
-	setParameter("Cooldown", std::to_string(cooldown));
+	ownerAccount_ = ownerAccount;
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 std::string CreateScalingRuleRequest::getAdjustmentType()const
@@ -99,7 +106,18 @@ std::string CreateScalingRuleRequest::getAdjustmentType()const
 void CreateScalingRuleRequest::setAdjustmentType(const std::string& adjustmentType)
 {
 	adjustmentType_ = adjustmentType;
-	setParameter("AdjustmentType", adjustmentType);
+	setCoreParameter("AdjustmentType", adjustmentType);
+}
+
+bool CreateScalingRuleRequest::getDisableScaleIn()const
+{
+	return disableScaleIn_;
+}
+
+void CreateScalingRuleRequest::setDisableScaleIn(bool disableScaleIn)
+{
+	disableScaleIn_ = disableScaleIn;
+	setCoreParameter("DisableScaleIn", disableScaleIn ? "true" : "false");
 }
 
 long CreateScalingRuleRequest::getOwnerId()const
@@ -110,7 +128,7 @@ long CreateScalingRuleRequest::getOwnerId()const
 void CreateScalingRuleRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string CreateScalingRuleRequest::getAccessKeyId()const
@@ -121,6 +139,72 @@ std::string CreateScalingRuleRequest::getAccessKeyId()const
 void CreateScalingRuleRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
+}
+
+std::string CreateScalingRuleRequest::getScalingRuleName()const
+{
+	return scalingRuleName_;
+}
+
+void CreateScalingRuleRequest::setScalingRuleName(const std::string& scalingRuleName)
+{
+	scalingRuleName_ = scalingRuleName;
+	setCoreParameter("ScalingRuleName", scalingRuleName);
+}
+
+int CreateScalingRuleRequest::getCooldown()const
+{
+	return cooldown_;
+}
+
+void CreateScalingRuleRequest::setCooldown(int cooldown)
+{
+	cooldown_ = cooldown;
+	setCoreParameter("Cooldown", std::to_string(cooldown));
+}
+
+int CreateScalingRuleRequest::getMinAdjustmentMagnitude()const
+{
+	return minAdjustmentMagnitude_;
+}
+
+void CreateScalingRuleRequest::setMinAdjustmentMagnitude(int minAdjustmentMagnitude)
+{
+	minAdjustmentMagnitude_ = minAdjustmentMagnitude;
+	setCoreParameter("MinAdjustmentMagnitude", std::to_string(minAdjustmentMagnitude));
+}
+
+float CreateScalingRuleRequest::getTargetValue()const
+{
+	return targetValue_;
+}
+
+void CreateScalingRuleRequest::setTargetValue(float targetValue)
+{
+	targetValue_ = targetValue;
+	setCoreParameter("TargetValue", std::to_string(targetValue));
+}
+
+std::string CreateScalingRuleRequest::getScalingRuleType()const
+{
+	return scalingRuleType_;
+}
+
+void CreateScalingRuleRequest::setScalingRuleType(const std::string& scalingRuleType)
+{
+	scalingRuleType_ = scalingRuleType;
+	setCoreParameter("ScalingRuleType", scalingRuleType);
+}
+
+std::string CreateScalingRuleRequest::getMetricName()const
+{
+	return metricName_;
+}
+
+void CreateScalingRuleRequest::setMetricName(const std::string& metricName)
+{
+	metricName_ = metricName;
+	setCoreParameter("MetricName", metricName);
 }
 

ess/src/model/CreateScheduledTaskRequest.cc

@@ -33,7 +33,7 @@ std::string CreateScheduledTaskRequest::getLaunchTime()const
 void CreateScheduledTaskRequest::setLaunchTime(const std::string& launchTime)
 {
 	launchTime_ = launchTime;
-	setParameter("LaunchTime", launchTime);
+	setCoreParameter("LaunchTime", launchTime);
 }
 
 std::string CreateScheduledTaskRequest::getScheduledAction()const
@@ -44,7 +44,7 @@ std::string CreateScheduledTaskRequest::getScheduledAction()const
 void CreateScheduledTaskRequest::setScheduledAction(const std::string& scheduledAction)
 {
 	scheduledAction_ = scheduledAction;
-	setParameter("ScheduledAction", scheduledAction);
+	setCoreParameter("ScheduledAction", scheduledAction);
 }
 
 std::string CreateScheduledTaskRequest::getResourceOwnerAccount()const
@@ -55,7 +55,7 @@ std::string CreateScheduledTaskRequest::getResourceOwnerAccount()const
 void CreateScheduledTaskRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string CreateScheduledTaskRequest::getOwnerAccount()const
@@ -66,7 +66,7 @@ std::string CreateScheduledTaskRequest::getOwnerAccount()const
 void CreateScheduledTaskRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 std::string CreateScheduledTaskRequest::getDescription()const
@@ -77,7 +77,7 @@ std::string CreateScheduledTaskRequest::getDescription()const
 void CreateScheduledTaskRequest::setDescription(const std::string& description)
 {
 	description_ = description;
-	setParameter("Description", description);
+	setCoreParameter("Description", description);
 }
 
 long CreateScheduledTaskRequest::getOwnerId()const
@@ -88,7 +88,7 @@ long CreateScheduledTaskRequest::getOwnerId()const
 void CreateScheduledTaskRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string CreateScheduledTaskRequest::getRecurrenceValue()const
@@ -99,7 +99,7 @@ std::string CreateScheduledTaskRequest::getRecurrenceValue()const
 void CreateScheduledTaskRequest::setRecurrenceValue(const std::string& recurrenceValue)
 {
 	recurrenceValue_ = recurrenceValue;
-	setParameter("RecurrenceValue", recurrenceValue);
+	setCoreParameter("RecurrenceValue", recurrenceValue);
 }
 
 int CreateScheduledTaskRequest::getLaunchExpirationTime()const
@@ -110,7 +110,7 @@ int CreateScheduledTaskRequest::getLaunchExpirationTime()const
 void CreateScheduledTaskRequest::setLaunchExpirationTime(int launchExpirationTime)
 {
 	launchExpirationTime_ = launchExpirationTime;
-	setParameter("LaunchExpirationTime", std::to_string(launchExpirationTime));
+	setCoreParameter("LaunchExpirationTime", std::to_string(launchExpirationTime));
 }
 
 std::string CreateScheduledTaskRequest::getRecurrenceEndTime()const
@@ -121,7 +121,7 @@ std::string CreateScheduledTaskRequest::getRecurrenceEndTime()const
 void CreateScheduledTaskRequest::setRecurrenceEndTime(const std::string& recurrenceEndTime)
 {
 	recurrenceEndTime_ = recurrenceEndTime;
-	setParameter("RecurrenceEndTime", recurrenceEndTime);
+	setCoreParameter("RecurrenceEndTime", recurrenceEndTime);
 }
 
 std::string CreateScheduledTaskRequest::getAccessKeyId()const
@@ -132,7 +132,7 @@ std::string CreateScheduledTaskRequest::getAccessKeyId()const
 void CreateScheduledTaskRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string CreateScheduledTaskRequest::getRegionId()const
@@ -143,7 +143,7 @@ std::string CreateScheduledTaskRequest::getRegionId()const
 void CreateScheduledTaskRequest::setRegionId(const std::string& regionId)
 {
 	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+	setCoreParameter("RegionId", regionId);
 }
 
 std::string CreateScheduledTaskRequest::getScheduledTaskName()const
@@ -154,7 +154,7 @@ std::string CreateScheduledTaskRequest::getScheduledTaskName()const
 void CreateScheduledTaskRequest::setScheduledTaskName(const std::string& scheduledTaskName)
 {
 	scheduledTaskName_ = scheduledTaskName;
-	setParameter("ScheduledTaskName", scheduledTaskName);
+	setCoreParameter("ScheduledTaskName", scheduledTaskName);
 }
 
 bool CreateScheduledTaskRequest::getTaskEnabled()const
@@ -165,7 +165,7 @@ bool CreateScheduledTaskRequest::getTaskEnabled()const
 void CreateScheduledTaskRequest::setTaskEnabled(bool taskEnabled)
 {
 	taskEnabled_ = taskEnabled;
-	setParameter("TaskEnabled", std::to_string(taskEnabled));
+	setCoreParameter("TaskEnabled", taskEnabled ? "true" : "false");
 }
 
 std::string CreateScheduledTaskRequest::getRecurrenceType()const
@@ -176,6 +176,6 @@ std::string CreateScheduledTaskRequest::getRecurrenceType()const
 void CreateScheduledTaskRequest::setRecurrenceType(const std::string& recurrenceType)
 {
 	recurrenceType_ = recurrenceType;
-	setParameter("RecurrenceType", recurrenceType);
+	setCoreParameter("RecurrenceType", recurrenceType);
 }
 

ess/src/model/DeactivateScalingConfigurationRequest.cc

@@ -33,7 +33,7 @@ std::string DeactivateScalingConfigurationRequest::getScalingConfigurationId()co
 void DeactivateScalingConfigurationRequest::setScalingConfigurationId(const std::string& scalingConfigurationId)
 {
 	scalingConfigurationId_ = scalingConfigurationId;
-	setParameter("ScalingConfigurationId", scalingConfigurationId);
+	setCoreParameter("ScalingConfigurationId", scalingConfigurationId);
 }
 
 std::string DeactivateScalingConfigurationRequest::getResourceOwnerAccount()const
@@ -44,7 +44,7 @@ std::string DeactivateScalingConfigurationRequest::getResourceOwnerAccount()cons
 void DeactivateScalingConfigurationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DeactivateScalingConfigurationRequest::getOwnerAccount()const
@@ -55,7 +55,7 @@ std::string DeactivateScalingConfigurationRequest::getOwnerAccount()const
 void DeactivateScalingConfigurationRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 long DeactivateScalingConfigurationRequest::getOwnerId()const
@@ -66,7 +66,7 @@ long DeactivateScalingConfigurationRequest::getOwnerId()const
 void DeactivateScalingConfigurationRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DeactivateScalingConfigurationRequest::getAccessKeyId()const
@@ -77,6 +77,6 @@ std::string DeactivateScalingConfigurationRequest::getAccessKeyId()const
 void DeactivateScalingConfigurationRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DeleteAlarmRequest.cc

@@ -33,7 +33,7 @@ std::string DeleteAlarmRequest::getResourceOwnerAccount()const
 void DeleteAlarmRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DeleteAlarmRequest::getRegionId()const
@@ -44,7 +44,7 @@ std::string DeleteAlarmRequest::getRegionId()const
 void DeleteAlarmRequest::setRegionId(const std::string& regionId)
 {
 	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+	setCoreParameter("RegionId", regionId);
 }
 
 long DeleteAlarmRequest::getOwnerId()const
@@ -55,7 +55,7 @@ long DeleteAlarmRequest::getOwnerId()const
 void DeleteAlarmRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DeleteAlarmRequest::getAlarmTaskId()const
@@ -66,7 +66,7 @@ std::string DeleteAlarmRequest::getAlarmTaskId()const
 void DeleteAlarmRequest::setAlarmTaskId(const std::string& alarmTaskId)
 {
 	alarmTaskId_ = alarmTaskId;
-	setParameter("AlarmTaskId", alarmTaskId);
+	setCoreParameter("AlarmTaskId", alarmTaskId);
 }
 
 std::string DeleteAlarmRequest::getAccessKeyId()const
@@ -77,6 +77,6 @@ std::string DeleteAlarmRequest::getAccessKeyId()const
 void DeleteAlarmRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DeleteLifecycleHookRequest.cc

@@ -33,7 +33,7 @@ std::string DeleteLifecycleHookRequest::getLifecycleHookName()const
 void DeleteLifecycleHookRequest::setLifecycleHookName(const std::string& lifecycleHookName)
 {
 	lifecycleHookName_ = lifecycleHookName;
-	setParameter("LifecycleHookName", lifecycleHookName);
+	setCoreParameter("LifecycleHookName", lifecycleHookName);
 }
 
 std::string DeleteLifecycleHookRequest::getResourceOwnerAccount()const
@@ -44,7 +44,7 @@ std::string DeleteLifecycleHookRequest::getResourceOwnerAccount()const
 void DeleteLifecycleHookRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DeleteLifecycleHookRequest::getLifecycleHookId()const
@@ -55,7 +55,7 @@ std::string DeleteLifecycleHookRequest::getLifecycleHookId()const
 void DeleteLifecycleHookRequest::setLifecycleHookId(const std::string& lifecycleHookId)
 {
 	lifecycleHookId_ = lifecycleHookId;
-	setParameter("LifecycleHookId", lifecycleHookId);
+	setCoreParameter("LifecycleHookId", lifecycleHookId);
 }
 
 std::string DeleteLifecycleHookRequest::getScalingGroupId()const
@@ -66,7 +66,7 @@ std::string DeleteLifecycleHookRequest::getScalingGroupId()const
 void DeleteLifecycleHookRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 std::string DeleteLifecycleHookRequest::getOwnerAccount()const
@@ -77,7 +77,7 @@ std::string DeleteLifecycleHookRequest::getOwnerAccount()const
 void DeleteLifecycleHookRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 long DeleteLifecycleHookRequest::getOwnerId()const
@@ -88,7 +88,7 @@ long DeleteLifecycleHookRequest::getOwnerId()const
 void DeleteLifecycleHookRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DeleteLifecycleHookRequest::getAccessKeyId()const
@@ -99,6 +99,6 @@ std::string DeleteLifecycleHookRequest::getAccessKeyId()const
 void DeleteLifecycleHookRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DeleteNotificationConfigurationRequest.cc

@@ -33,7 +33,7 @@ std::string DeleteNotificationConfigurationRequest::getResourceOwnerAccount()con
 void DeleteNotificationConfigurationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DeleteNotificationConfigurationRequest::getScalingGroupId()const
@@ -44,7 +44,7 @@ std::string DeleteNotificationConfigurationRequest::getScalingGroupId()const
 void DeleteNotificationConfigurationRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 std::string DeleteNotificationConfigurationRequest::getNotificationArn()const
@@ -55,7 +55,7 @@ std::string DeleteNotificationConfigurationRequest::getNotificationArn()const
 void DeleteNotificationConfigurationRequest::setNotificationArn(const std::string& notificationArn)
 {
 	notificationArn_ = notificationArn;
-	setParameter("NotificationArn", notificationArn);
+	setCoreParameter("NotificationArn", notificationArn);
 }
 
 long DeleteNotificationConfigurationRequest::getOwnerId()const
@@ -66,7 +66,7 @@ long DeleteNotificationConfigurationRequest::getOwnerId()const
 void DeleteNotificationConfigurationRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DeleteNotificationConfigurationRequest::getAccessKeyId()const
@@ -77,6 +77,6 @@ std::string DeleteNotificationConfigurationRequest::getAccessKeyId()const
 void DeleteNotificationConfigurationRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DeleteScalingConfigurationRequest.cc

@@ -33,7 +33,7 @@ std::string DeleteScalingConfigurationRequest::getScalingConfigurationId()const
 void DeleteScalingConfigurationRequest::setScalingConfigurationId(const std::string& scalingConfigurationId)
 {
 	scalingConfigurationId_ = scalingConfigurationId;
-	setParameter("ScalingConfigurationId", scalingConfigurationId);
+	setCoreParameter("ScalingConfigurationId", scalingConfigurationId);
 }
 
 std::string DeleteScalingConfigurationRequest::getResourceOwnerAccount()const
@@ -44,7 +44,7 @@ std::string DeleteScalingConfigurationRequest::getResourceOwnerAccount()const
 void DeleteScalingConfigurationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DeleteScalingConfigurationRequest::getOwnerAccount()const
@@ -55,7 +55,7 @@ std::string DeleteScalingConfigurationRequest::getOwnerAccount()const
 void DeleteScalingConfigurationRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 long DeleteScalingConfigurationRequest::getOwnerId()const
@@ -66,7 +66,7 @@ long DeleteScalingConfigurationRequest::getOwnerId()const
 void DeleteScalingConfigurationRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DeleteScalingConfigurationRequest::getAccessKeyId()const
@@ -77,6 +77,6 @@ std::string DeleteScalingConfigurationRequest::getAccessKeyId()const
 void DeleteScalingConfigurationRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DeleteScalingGroupRequest.cc

@@ -33,7 +33,7 @@ std::string DeleteScalingGroupRequest::getResourceOwnerAccount()const
 void DeleteScalingGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DeleteScalingGroupRequest::getScalingGroupId()const
@@ -44,7 +44,7 @@ std::string DeleteScalingGroupRequest::getScalingGroupId()const
 void DeleteScalingGroupRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 bool DeleteScalingGroupRequest::getForceDelete()const
@@ -55,7 +55,7 @@ bool DeleteScalingGroupRequest::getForceDelete()const
 void DeleteScalingGroupRequest::setForceDelete(bool forceDelete)
 {
 	forceDelete_ = forceDelete;
-	setParameter("ForceDelete", std::to_string(forceDelete));
+	setCoreParameter("ForceDelete", forceDelete ? "true" : "false");
 }
 
 std::string DeleteScalingGroupRequest::getOwnerAccount()const
@@ -66,7 +66,7 @@ std::string DeleteScalingGroupRequest::getOwnerAccount()const
 void DeleteScalingGroupRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 long DeleteScalingGroupRequest::getOwnerId()const
@@ -77,7 +77,7 @@ long DeleteScalingGroupRequest::getOwnerId()const
 void DeleteScalingGroupRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DeleteScalingGroupRequest::getAccessKeyId()const
@@ -88,6 +88,6 @@ std::string DeleteScalingGroupRequest::getAccessKeyId()const
 void DeleteScalingGroupRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DeleteScalingRuleRequest.cc

@@ -33,7 +33,7 @@ std::string DeleteScalingRuleRequest::getResourceOwnerAccount()const
 void DeleteScalingRuleRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DeleteScalingRuleRequest::getOwnerAccount()const
@@ -44,7 +44,7 @@ std::string DeleteScalingRuleRequest::getOwnerAccount()const
 void DeleteScalingRuleRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 long DeleteScalingRuleRequest::getOwnerId()const
@@ -55,7 +55,7 @@ long DeleteScalingRuleRequest::getOwnerId()const
 void DeleteScalingRuleRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DeleteScalingRuleRequest::getScalingRuleId()const
@@ -66,7 +66,7 @@ std::string DeleteScalingRuleRequest::getScalingRuleId()const
 void DeleteScalingRuleRequest::setScalingRuleId(const std::string& scalingRuleId)
 {
 	scalingRuleId_ = scalingRuleId;
-	setParameter("ScalingRuleId", scalingRuleId);
+	setCoreParameter("ScalingRuleId", scalingRuleId);
 }
 
 std::string DeleteScalingRuleRequest::getAccessKeyId()const
@@ -77,6 +77,6 @@ std::string DeleteScalingRuleRequest::getAccessKeyId()const
 void DeleteScalingRuleRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DeleteScheduledTaskRequest.cc

@@ -33,7 +33,7 @@ std::string DeleteScheduledTaskRequest::getResourceOwnerAccount()const
 void DeleteScheduledTaskRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DeleteScheduledTaskRequest::getOwnerAccount()const
@@ -44,7 +44,7 @@ std::string DeleteScheduledTaskRequest::getOwnerAccount()const
 void DeleteScheduledTaskRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 long DeleteScheduledTaskRequest::getOwnerId()const
@@ -55,7 +55,7 @@ long DeleteScheduledTaskRequest::getOwnerId()const
 void DeleteScheduledTaskRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DeleteScheduledTaskRequest::getScheduledTaskId()const
@@ -66,7 +66,7 @@ std::string DeleteScheduledTaskRequest::getScheduledTaskId()const
 void DeleteScheduledTaskRequest::setScheduledTaskId(const std::string& scheduledTaskId)
 {
 	scheduledTaskId_ = scheduledTaskId;
-	setParameter("ScheduledTaskId", scheduledTaskId);
+	setCoreParameter("ScheduledTaskId", scheduledTaskId);
 }
 
 std::string DeleteScheduledTaskRequest::getAccessKeyId()const
@@ -77,6 +77,6 @@ std::string DeleteScheduledTaskRequest::getAccessKeyId()const
 void DeleteScheduledTaskRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DescribeAccountAttributesRequest.cc

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

ess/src/model/DescribeAccountAttributesResult.cc

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

ess/src/model/DescribeAlarmsRequest.cc

@@ -33,7 +33,7 @@ bool DescribeAlarmsRequest::getIsEnable()const
 void DescribeAlarmsRequest::setIsEnable(bool isEnable)
 {
 	isEnable_ = isEnable;
-	setParameter("IsEnable", std::to_string(isEnable));
+	setCoreParameter("IsEnable", isEnable ? "true" : "false");
 }
 
 std::string DescribeAlarmsRequest::getMetricType()const
@@ -44,7 +44,7 @@ std::string DescribeAlarmsRequest::getMetricType()const
 void DescribeAlarmsRequest::setMetricType(const std::string& metricType)
 {
 	metricType_ = metricType;
-	setParameter("MetricType", metricType);
+	setCoreParameter("MetricType", metricType);
 }
 
 std::string DescribeAlarmsRequest::getResourceOwnerAccount()const
@@ -55,7 +55,7 @@ std::string DescribeAlarmsRequest::getResourceOwnerAccount()const
 void DescribeAlarmsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeAlarmsRequest::getRegionId()const
@@ -66,7 +66,7 @@ std::string DescribeAlarmsRequest::getRegionId()const
 void DescribeAlarmsRequest::setRegionId(const std::string& regionId)
 {
 	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+	setCoreParameter("RegionId", regionId);
 }
 
 std::string DescribeAlarmsRequest::getScalingGroupId()const
@@ -77,7 +77,7 @@ std::string DescribeAlarmsRequest::getScalingGroupId()const
 void DescribeAlarmsRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 int DescribeAlarmsRequest::getPageSize()const
@@ -88,7 +88,7 @@ int DescribeAlarmsRequest::getPageSize()const
 void DescribeAlarmsRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+	setCoreParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string DescribeAlarmsRequest::getState()const
@@ -99,7 +99,7 @@ std::string DescribeAlarmsRequest::getState()const
 void DescribeAlarmsRequest::setState(const std::string& state)
 {
 	state_ = state;
-	setParameter("State", state);
+	setCoreParameter("State", state);
 }
 
 long DescribeAlarmsRequest::getOwnerId()const
@@ -110,7 +110,7 @@ long DescribeAlarmsRequest::getOwnerId()const
 void DescribeAlarmsRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeAlarmsRequest::getAlarmTaskId()const
@@ -121,7 +121,7 @@ std::string DescribeAlarmsRequest::getAlarmTaskId()const
 void DescribeAlarmsRequest::setAlarmTaskId(const std::string& alarmTaskId)
 {
 	alarmTaskId_ = alarmTaskId;
-	setParameter("AlarmTaskId", alarmTaskId);
+	setCoreParameter("AlarmTaskId", alarmTaskId);
 }
 
 int DescribeAlarmsRequest::getPageNumber()const
@@ -132,7 +132,7 @@ int DescribeAlarmsRequest::getPageNumber()const
 void DescribeAlarmsRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
+	setCoreParameter("PageNumber", std::to_string(pageNumber));
 }
 
 std::string DescribeAlarmsRequest::getAccessKeyId()const
@@ -143,6 +143,6 @@ std::string DescribeAlarmsRequest::getAccessKeyId()const
 void DescribeAlarmsRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DescribeAlertConfigRequest.cc

@@ -33,7 +33,7 @@ std::string DescribeAlertConfigRequest::getResourceOwnerAccount()const
 void DescribeAlertConfigRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeAlertConfigRequest::getScalingGroupId()const
@@ -44,7 +44,7 @@ std::string DescribeAlertConfigRequest::getScalingGroupId()const
 void DescribeAlertConfigRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 long DescribeAlertConfigRequest::getOwnerId()const
@@ -55,7 +55,7 @@ long DescribeAlertConfigRequest::getOwnerId()const
 void DescribeAlertConfigRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeAlertConfigRequest::getAccessKeyId()const
@@ -66,6 +66,6 @@ std::string DescribeAlertConfigRequest::getAccessKeyId()const
 void DescribeAlertConfigRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DescribeCapacityHistoryRequest.cc

@@ -33,7 +33,7 @@ std::string DescribeCapacityHistoryRequest::getResourceOwnerAccount()const
 void DescribeCapacityHistoryRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeCapacityHistoryRequest::getScalingGroupId()const
@@ -44,7 +44,7 @@ std::string DescribeCapacityHistoryRequest::getScalingGroupId()const
 void DescribeCapacityHistoryRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 int DescribeCapacityHistoryRequest::getPageSize()const
@@ -55,7 +55,7 @@ int DescribeCapacityHistoryRequest::getPageSize()const
 void DescribeCapacityHistoryRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+	setCoreParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string DescribeCapacityHistoryRequest::getEndTime()const
@@ -66,7 +66,7 @@ std::string DescribeCapacityHistoryRequest::getEndTime()const
 void DescribeCapacityHistoryRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setParameter("EndTime", endTime);
+	setCoreParameter("EndTime", endTime);
 }
 
 std::string DescribeCapacityHistoryRequest::getStartTime()const
@@ -77,7 +77,7 @@ std::string DescribeCapacityHistoryRequest::getStartTime()const
 void DescribeCapacityHistoryRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setParameter("StartTime", startTime);
+	setCoreParameter("StartTime", startTime);
 }
 
 long DescribeCapacityHistoryRequest::getOwnerId()const
@@ -88,7 +88,7 @@ long DescribeCapacityHistoryRequest::getOwnerId()const
 void DescribeCapacityHistoryRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 int DescribeCapacityHistoryRequest::getPageNumber()const
@@ -99,7 +99,7 @@ int DescribeCapacityHistoryRequest::getPageNumber()const
 void DescribeCapacityHistoryRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
+	setCoreParameter("PageNumber", std::to_string(pageNumber));
 }
 
 std::string DescribeCapacityHistoryRequest::getAccessKeyId()const
@@ -110,6 +110,6 @@ std::string DescribeCapacityHistoryRequest::getAccessKeyId()const
 void DescribeCapacityHistoryRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DescribeLifecycleHooksRequest.cc

@@ -33,7 +33,7 @@ std::string DescribeLifecycleHooksRequest::getLifecycleHookName()const
 void DescribeLifecycleHooksRequest::setLifecycleHookName(const std::string& lifecycleHookName)
 {
 	lifecycleHookName_ = lifecycleHookName;
-	setParameter("LifecycleHookName", lifecycleHookName);
+	setCoreParameter("LifecycleHookName", lifecycleHookName);
 }
 
 std::string DescribeLifecycleHooksRequest::getResourceOwnerAccount()const
@@ -44,7 +44,7 @@ std::string DescribeLifecycleHooksRequest::getResourceOwnerAccount()const
 void DescribeLifecycleHooksRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeLifecycleHooksRequest::getScalingGroupId()const
@@ -55,7 +55,7 @@ std::string DescribeLifecycleHooksRequest::getScalingGroupId()const
 void DescribeLifecycleHooksRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 std::vector<std::string> DescribeLifecycleHooksRequest::getLifecycleHookId()const
@@ -67,7 +67,7 @@ void DescribeLifecycleHooksRequest::setLifecycleHookId(const std::vector<std::st
 {
 	lifecycleHookId_ = lifecycleHookId;
 	for(int i = 0; i!= lifecycleHookId.size(); i++)
-		setParameter("LifecycleHookId."+ std::to_string(i), lifecycleHookId.at(i));
+		setCoreParameter("LifecycleHookId."+ std::to_string(i), lifecycleHookId.at(i));
 }
 
 std::string DescribeLifecycleHooksRequest::getOwnerAccount()const
@@ -78,7 +78,7 @@ std::string DescribeLifecycleHooksRequest::getOwnerAccount()const
 void DescribeLifecycleHooksRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 int DescribeLifecycleHooksRequest::getPageSize()const
@@ -89,7 +89,7 @@ int DescribeLifecycleHooksRequest::getPageSize()const
 void DescribeLifecycleHooksRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+	setCoreParameter("PageSize", std::to_string(pageSize));
 }
 
 long DescribeLifecycleHooksRequest::getOwnerId()const
@@ -100,7 +100,7 @@ long DescribeLifecycleHooksRequest::getOwnerId()const
 void DescribeLifecycleHooksRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 int DescribeLifecycleHooksRequest::getPageNumber()const
@@ -111,7 +111,7 @@ int DescribeLifecycleHooksRequest::getPageNumber()const
 void DescribeLifecycleHooksRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
+	setCoreParameter("PageNumber", std::to_string(pageNumber));
 }
 
 std::string DescribeLifecycleHooksRequest::getAccessKeyId()const
@@ -122,6 +122,6 @@ std::string DescribeLifecycleHooksRequest::getAccessKeyId()const
 void DescribeLifecycleHooksRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DescribeLimitationRequest.cc

@@ -33,7 +33,7 @@ std::string DescribeLimitationRequest::getResourceOwnerAccount()const
 void DescribeLimitationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 long DescribeLimitationRequest::getOwnerId()const
@@ -44,7 +44,7 @@ long DescribeLimitationRequest::getOwnerId()const
 void DescribeLimitationRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeLimitationRequest::getAccessKeyId()const
@@ -55,6 +55,6 @@ std::string DescribeLimitationRequest::getAccessKeyId()const
 void DescribeLimitationRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DescribeLimitationResult.cc

@@ -58,9 +58,20 @@ void DescribeLimitationResult::parse(const std::string &payload)
 		maxNumberOfMinSize_ = std::stoi(value["MaxNumberOfMinSize"].asString());
 	if(!value["MaxNumberOfMaxSize"].isNull())
 		maxNumberOfMaxSize_ = std::stoi(value["MaxNumberOfMaxSize"].asString());
+	if(!value["MaxNumberOfVServerGroups"].isNull())
+		maxNumberOfVServerGroups_ = std::stoi(value["MaxNumberOfVServerGroups"].asString());
+	if(!value["MaxNumberOfLifecycleHooks"].isNull())
+		maxNumberOfLifecycleHooks_ = std::stoi(value["MaxNumberOfLifecycleHooks"].asString());
+	if(!value["MaxNumberOfNotificationConfigurations"].isNull())
+		maxNumberOfNotificationConfigurations_ = std::stoi(value["MaxNumberOfNotificationConfigurations"].asString());
 
 }
 
+int DescribeLimitationResult::getMaxNumberOfLifecycleHooks()const
+{
+	return maxNumberOfLifecycleHooks_;
+}
+
 int DescribeLimitationResult::getMaxNumberOfScalingRules()const
 {
 	return maxNumberOfScalingRules_;
@@ -76,6 +87,11 @@ int DescribeLimitationResult::getMaxNumberOfScheduledTasks()const
 	return maxNumberOfScheduledTasks_;
 }
 
+int DescribeLimitationResult::getMaxNumberOfVServerGroups()const
+{
+	return maxNumberOfVServerGroups_;
+}
+
 int DescribeLimitationResult::getMaxNumberOfLoadBalancers()const
 {
 	return maxNumberOfLoadBalancers_;
@@ -91,6 +107,11 @@ int DescribeLimitationResult::getMaxNumberOfScalingGroups()const
 	return maxNumberOfScalingGroups_;
 }
 
+int DescribeLimitationResult::getMaxNumberOfNotificationConfigurations()const
+{
+	return maxNumberOfNotificationConfigurations_;
+}
+
 int DescribeLimitationResult::getMaxNumberOfScalingConfigurations()const
 {
 	return maxNumberOfScalingConfigurations_;

ess/src/model/DescribeNotificationConfigurationsRequest.cc

@@ -33,7 +33,7 @@ std::string DescribeNotificationConfigurationsRequest::getResourceOwnerAccount()
 void DescribeNotificationConfigurationsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeNotificationConfigurationsRequest::getScalingGroupId()const
@@ -44,7 +44,7 @@ std::string DescribeNotificationConfigurationsRequest::getScalingGroupId()const
 void DescribeNotificationConfigurationsRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 long DescribeNotificationConfigurationsRequest::getOwnerId()const
@@ -55,7 +55,7 @@ long DescribeNotificationConfigurationsRequest::getOwnerId()const
 void DescribeNotificationConfigurationsRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeNotificationConfigurationsRequest::getAccessKeyId()const
@@ -66,6 +66,6 @@ std::string DescribeNotificationConfigurationsRequest::getAccessKeyId()const
 void DescribeNotificationConfigurationsRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DescribeNotificationTypesRequest.cc

@@ -33,7 +33,7 @@ std::string DescribeNotificationTypesRequest::getResourceOwnerAccount()const
 void DescribeNotificationTypesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 long DescribeNotificationTypesRequest::getOwnerId()const
@@ -44,7 +44,7 @@ long DescribeNotificationTypesRequest::getOwnerId()const
 void DescribeNotificationTypesRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeNotificationTypesRequest::getAccessKeyId()const
@@ -55,6 +55,6 @@ std::string DescribeNotificationTypesRequest::getAccessKeyId()const
 void DescribeNotificationTypesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DescribeRegionsRequest.cc

@@ -33,7 +33,7 @@ long DescribeRegionsRequest::getResourceOwnerId()const
 void DescribeRegionsRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeRegionsRequest::getResourceOwnerAccount()const
@@ -44,7 +44,7 @@ std::string DescribeRegionsRequest::getResourceOwnerAccount()const
 void DescribeRegionsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 long DescribeRegionsRequest::getOwnerId()const
@@ -55,7 +55,7 @@ long DescribeRegionsRequest::getOwnerId()const
 void DescribeRegionsRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeRegionsRequest::getAccessKeyId()const
@@ -66,6 +66,6 @@ std::string DescribeRegionsRequest::getAccessKeyId()const
 void DescribeRegionsRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DescribeScalingActivitiesRequest.cc

@@ -33,7 +33,7 @@ std::string DescribeScalingActivitiesRequest::getScalingActivityId9()const
 void DescribeScalingActivitiesRequest::setScalingActivityId9(const std::string& scalingActivityId9)
 {
 	scalingActivityId9_ = scalingActivityId9;
-	setParameter("ScalingActivityId9", scalingActivityId9);
+	setCoreParameter("ScalingActivityId9", scalingActivityId9);
 }
 
 long DescribeScalingActivitiesRequest::getResourceOwnerId()const
@@ -44,7 +44,7 @@ long DescribeScalingActivitiesRequest::getResourceOwnerId()const
 void DescribeScalingActivitiesRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeScalingActivitiesRequest::getScalingActivityId5()const
@@ -55,7 +55,7 @@ std::string DescribeScalingActivitiesRequest::getScalingActivityId5()const
 void DescribeScalingActivitiesRequest::setScalingActivityId5(const std::string& scalingActivityId5)
 {
 	scalingActivityId5_ = scalingActivityId5;
-	setParameter("ScalingActivityId5", scalingActivityId5);
+	setCoreParameter("ScalingActivityId5", scalingActivityId5);
 }
 
 std::string DescribeScalingActivitiesRequest::getScalingActivityId6()const
@@ -66,7 +66,7 @@ std::string DescribeScalingActivitiesRequest::getScalingActivityId6()const
 void DescribeScalingActivitiesRequest::setScalingActivityId6(const std::string& scalingActivityId6)
 {
 	scalingActivityId6_ = scalingActivityId6;
-	setParameter("ScalingActivityId6", scalingActivityId6);
+	setCoreParameter("ScalingActivityId6", scalingActivityId6);
 }
 
 std::string DescribeScalingActivitiesRequest::getScalingGroupId()const
@@ -77,7 +77,7 @@ std::string DescribeScalingActivitiesRequest::getScalingGroupId()const
 void DescribeScalingActivitiesRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 std::string DescribeScalingActivitiesRequest::getScalingActivityId7()const
@@ -88,7 +88,7 @@ std::string DescribeScalingActivitiesRequest::getScalingActivityId7()const
 void DescribeScalingActivitiesRequest::setScalingActivityId7(const std::string& scalingActivityId7)
 {
 	scalingActivityId7_ = scalingActivityId7;
-	setParameter("ScalingActivityId7", scalingActivityId7);
+	setCoreParameter("ScalingActivityId7", scalingActivityId7);
 }
 
 std::string DescribeScalingActivitiesRequest::getScalingActivityId8()const
@@ -99,7 +99,7 @@ std::string DescribeScalingActivitiesRequest::getScalingActivityId8()const
 void DescribeScalingActivitiesRequest::setScalingActivityId8(const std::string& scalingActivityId8)
 {
 	scalingActivityId8_ = scalingActivityId8;
-	setParameter("ScalingActivityId8", scalingActivityId8);
+	setCoreParameter("ScalingActivityId8", scalingActivityId8);
 }
 
 std::string DescribeScalingActivitiesRequest::getScalingActivityId1()const
@@ -110,7 +110,7 @@ std::string DescribeScalingActivitiesRequest::getScalingActivityId1()const
 void DescribeScalingActivitiesRequest::setScalingActivityId1(const std::string& scalingActivityId1)
 {
 	scalingActivityId1_ = scalingActivityId1;
-	setParameter("ScalingActivityId1", scalingActivityId1);
+	setCoreParameter("ScalingActivityId1", scalingActivityId1);
 }
 
 std::string DescribeScalingActivitiesRequest::getScalingActivityId2()const
@@ -121,7 +121,7 @@ std::string DescribeScalingActivitiesRequest::getScalingActivityId2()const
 void DescribeScalingActivitiesRequest::setScalingActivityId2(const std::string& scalingActivityId2)
 {
 	scalingActivityId2_ = scalingActivityId2;
-	setParameter("ScalingActivityId2", scalingActivityId2);
+	setCoreParameter("ScalingActivityId2", scalingActivityId2);
 }
 
 std::string DescribeScalingActivitiesRequest::getScalingActivityId3()const
@@ -132,7 +132,7 @@ std::string DescribeScalingActivitiesRequest::getScalingActivityId3()const
 void DescribeScalingActivitiesRequest::setScalingActivityId3(const std::string& scalingActivityId3)
 {
 	scalingActivityId3_ = scalingActivityId3;
-	setParameter("ScalingActivityId3", scalingActivityId3);
+	setCoreParameter("ScalingActivityId3", scalingActivityId3);
 }
 
 std::string DescribeScalingActivitiesRequest::getScalingActivityId4()const
@@ -143,7 +143,7 @@ std::string DescribeScalingActivitiesRequest::getScalingActivityId4()const
 void DescribeScalingActivitiesRequest::setScalingActivityId4(const std::string& scalingActivityId4)
 {
 	scalingActivityId4_ = scalingActivityId4;
-	setParameter("ScalingActivityId4", scalingActivityId4);
+	setCoreParameter("ScalingActivityId4", scalingActivityId4);
 }
 
 int DescribeScalingActivitiesRequest::getPageNumber()const
@@ -154,7 +154,7 @@ int DescribeScalingActivitiesRequest::getPageNumber()const
 void DescribeScalingActivitiesRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
+	setCoreParameter("PageNumber", std::to_string(pageNumber));
 }
 
 std::string DescribeScalingActivitiesRequest::getAccessKeyId()const
@@ -165,7 +165,7 @@ std::string DescribeScalingActivitiesRequest::getAccessKeyId()const
 void DescribeScalingActivitiesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeScalingActivitiesRequest::getStatusCode()const
@@ -176,7 +176,7 @@ std::string DescribeScalingActivitiesRequest::getStatusCode()const
 void DescribeScalingActivitiesRequest::setStatusCode(const std::string& statusCode)
 {
 	statusCode_ = statusCode;
-	setParameter("StatusCode", statusCode);
+	setCoreParameter("StatusCode", statusCode);
 }
 
 std::string DescribeScalingActivitiesRequest::getRegionId()const
@@ -187,7 +187,7 @@ std::string DescribeScalingActivitiesRequest::getRegionId()const
 void DescribeScalingActivitiesRequest::setRegionId(const std::string& regionId)
 {
 	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+	setCoreParameter("RegionId", regionId);
 }
 
 int DescribeScalingActivitiesRequest::getPageSize()const
@@ -198,7 +198,7 @@ int DescribeScalingActivitiesRequest::getPageSize()const
 void DescribeScalingActivitiesRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+	setCoreParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string DescribeScalingActivitiesRequest::getScalingActivityId11()const
@@ -209,7 +209,7 @@ std::string DescribeScalingActivitiesRequest::getScalingActivityId11()const
 void DescribeScalingActivitiesRequest::setScalingActivityId11(const std::string& scalingActivityId11)
 {
 	scalingActivityId11_ = scalingActivityId11;
-	setParameter("ScalingActivityId11", scalingActivityId11);
+	setCoreParameter("ScalingActivityId11", scalingActivityId11);
 }
 
 std::string DescribeScalingActivitiesRequest::getScalingActivityId10()const
@@ -220,7 +220,7 @@ std::string DescribeScalingActivitiesRequest::getScalingActivityId10()const
 void DescribeScalingActivitiesRequest::setScalingActivityId10(const std::string& scalingActivityId10)
 {
 	scalingActivityId10_ = scalingActivityId10;
-	setParameter("ScalingActivityId10", scalingActivityId10);
+	setCoreParameter("ScalingActivityId10", scalingActivityId10);
 }
 
 std::string DescribeScalingActivitiesRequest::getScalingActivityId13()const
@@ -231,7 +231,7 @@ std::string DescribeScalingActivitiesRequest::getScalingActivityId13()const
 void DescribeScalingActivitiesRequest::setScalingActivityId13(const std::string& scalingActivityId13)
 {
 	scalingActivityId13_ = scalingActivityId13;
-	setParameter("ScalingActivityId13", scalingActivityId13);
+	setCoreParameter("ScalingActivityId13", scalingActivityId13);
 }
 
 std::string DescribeScalingActivitiesRequest::getScalingActivityId12()const
@@ -242,7 +242,7 @@ std::string DescribeScalingActivitiesRequest::getScalingActivityId12()const
 void DescribeScalingActivitiesRequest::setScalingActivityId12(const std::string& scalingActivityId12)
 {
 	scalingActivityId12_ = scalingActivityId12;
-	setParameter("ScalingActivityId12", scalingActivityId12);
+	setCoreParameter("ScalingActivityId12", scalingActivityId12);
 }
 
 std::string DescribeScalingActivitiesRequest::getScalingActivityId15()const
@@ -253,7 +253,7 @@ std::string DescribeScalingActivitiesRequest::getScalingActivityId15()const
 void DescribeScalingActivitiesRequest::setScalingActivityId15(const std::string& scalingActivityId15)
 {
 	scalingActivityId15_ = scalingActivityId15;
-	setParameter("ScalingActivityId15", scalingActivityId15);
+	setCoreParameter("ScalingActivityId15", scalingActivityId15);
 }
 
 std::string DescribeScalingActivitiesRequest::getScalingActivityId14()const
@@ -264,7 +264,7 @@ std::string DescribeScalingActivitiesRequest::getScalingActivityId14()const
 void DescribeScalingActivitiesRequest::setScalingActivityId14(const std::string& scalingActivityId14)
 {
 	scalingActivityId14_ = scalingActivityId14;
-	setParameter("ScalingActivityId14", scalingActivityId14);
+	setCoreParameter("ScalingActivityId14", scalingActivityId14);
 }
 
 std::string DescribeScalingActivitiesRequest::getScalingActivityId17()const
@@ -275,7 +275,7 @@ std::string DescribeScalingActivitiesRequest::getScalingActivityId17()const
 void DescribeScalingActivitiesRequest::setScalingActivityId17(const std::string& scalingActivityId17)
 {
 	scalingActivityId17_ = scalingActivityId17;
-	setParameter("ScalingActivityId17", scalingActivityId17);
+	setCoreParameter("ScalingActivityId17", scalingActivityId17);
 }
 
 std::string DescribeScalingActivitiesRequest::getScalingActivityId16()const
@@ -286,7 +286,7 @@ std::string DescribeScalingActivitiesRequest::getScalingActivityId16()const
 void DescribeScalingActivitiesRequest::setScalingActivityId16(const std::string& scalingActivityId16)
 {
 	scalingActivityId16_ = scalingActivityId16;
-	setParameter("ScalingActivityId16", scalingActivityId16);
+	setCoreParameter("ScalingActivityId16", scalingActivityId16);
 }
 
 std::string DescribeScalingActivitiesRequest::getScalingActivityId19()const
@@ -297,7 +297,7 @@ std::string DescribeScalingActivitiesRequest::getScalingActivityId19()const
 void DescribeScalingActivitiesRequest::setScalingActivityId19(const std::string& scalingActivityId19)
 {
 	scalingActivityId19_ = scalingActivityId19;
-	setParameter("ScalingActivityId19", scalingActivityId19);
+	setCoreParameter("ScalingActivityId19", scalingActivityId19);
 }
 
 std::string DescribeScalingActivitiesRequest::getResourceOwnerAccount()const
@@ -308,7 +308,7 @@ std::string DescribeScalingActivitiesRequest::getResourceOwnerAccount()const
 void DescribeScalingActivitiesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeScalingActivitiesRequest::getScalingActivityId18()const
@@ -319,7 +319,7 @@ std::string DescribeScalingActivitiesRequest::getScalingActivityId18()const
 void DescribeScalingActivitiesRequest::setScalingActivityId18(const std::string& scalingActivityId18)
 {
 	scalingActivityId18_ = scalingActivityId18;
-	setParameter("ScalingActivityId18", scalingActivityId18);
+	setCoreParameter("ScalingActivityId18", scalingActivityId18);
 }
 
 std::string DescribeScalingActivitiesRequest::getOwnerAccount()const
@@ -330,7 +330,7 @@ std::string DescribeScalingActivitiesRequest::getOwnerAccount()const
 void DescribeScalingActivitiesRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 long DescribeScalingActivitiesRequest::getOwnerId()const
@@ -341,7 +341,7 @@ long DescribeScalingActivitiesRequest::getOwnerId()const
 void DescribeScalingActivitiesRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScalingActivitiesRequest::getScalingActivityId20()const
@@ -352,6 +352,6 @@ std::string DescribeScalingActivitiesRequest::getScalingActivityId20()const
 void DescribeScalingActivitiesRequest::setScalingActivityId20(const std::string& scalingActivityId20)
 {
 	scalingActivityId20_ = scalingActivityId20;
-	setParameter("ScalingActivityId20", scalingActivityId20);
+	setCoreParameter("ScalingActivityId20", scalingActivityId20);
 }
 

ess/src/model/DescribeScalingActivitiesResult.cc

@@ -68,6 +68,8 @@ void DescribeScalingActivitiesResult::parse(const std::string &payload)
 			scalingActivitiesObject.attachedCapacity = value["AttachedCapacity"].asString();
 		if(!value["AutoCreatedCapacity"].isNull())
 			scalingActivitiesObject.autoCreatedCapacity = value["AutoCreatedCapacity"].asString();
+		if(!value["ScalingInstanceNumber"].isNull())
+			scalingActivitiesObject.scalingInstanceNumber = std::stoi(value["ScalingInstanceNumber"].asString());
 		scalingActivities_.push_back(scalingActivitiesObject);
 	}
 	if(!value["TotalCount"].isNull())

ess/src/model/DescribeScalingActivityDetailRequest.cc

@@ -33,7 +33,7 @@ long DescribeScalingActivityDetailRequest::getResourceOwnerId()const
 void DescribeScalingActivityDetailRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeScalingActivityDetailRequest::getResourceOwnerAccount()const
@@ -44,7 +44,7 @@ std::string DescribeScalingActivityDetailRequest::getResourceOwnerAccount()const
 void DescribeScalingActivityDetailRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 long DescribeScalingActivityDetailRequest::getOwnerId()const
@@ -55,7 +55,7 @@ long DescribeScalingActivityDetailRequest::getOwnerId()const
 void DescribeScalingActivityDetailRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScalingActivityDetailRequest::getScalingActivityId()const
@@ -66,7 +66,7 @@ std::string DescribeScalingActivityDetailRequest::getScalingActivityId()const
 void DescribeScalingActivityDetailRequest::setScalingActivityId(const std::string& scalingActivityId)
 {
 	scalingActivityId_ = scalingActivityId;
-	setParameter("ScalingActivityId", scalingActivityId);
+	setCoreParameter("ScalingActivityId", scalingActivityId);
 }
 
 std::string DescribeScalingActivityDetailRequest::getAccessKeyId()const
@@ -77,6 +77,6 @@ std::string DescribeScalingActivityDetailRequest::getAccessKeyId()const
 void DescribeScalingActivityDetailRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DescribeScalingConfigurationsRequest.cc

@@ -33,7 +33,7 @@ std::string DescribeScalingConfigurationsRequest::getScalingConfigurationId6()co
 void DescribeScalingConfigurationsRequest::setScalingConfigurationId6(const std::string& scalingConfigurationId6)
 {
 	scalingConfigurationId6_ = scalingConfigurationId6;
-	setParameter("ScalingConfigurationId6", scalingConfigurationId6);
+	setCoreParameter("ScalingConfigurationId6", scalingConfigurationId6);
 }
 
 std::string DescribeScalingConfigurationsRequest::getScalingConfigurationId7()const
@@ -44,7 +44,7 @@ std::string DescribeScalingConfigurationsRequest::getScalingConfigurationId7()co
 void DescribeScalingConfigurationsRequest::setScalingConfigurationId7(const std::string& scalingConfigurationId7)
 {
 	scalingConfigurationId7_ = scalingConfigurationId7;
-	setParameter("ScalingConfigurationId7", scalingConfigurationId7);
+	setCoreParameter("ScalingConfigurationId7", scalingConfigurationId7);
 }
 
 long DescribeScalingConfigurationsRequest::getResourceOwnerId()const
@@ -55,7 +55,7 @@ long DescribeScalingConfigurationsRequest::getResourceOwnerId()const
 void DescribeScalingConfigurationsRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeScalingConfigurationsRequest::getScalingConfigurationId4()const
@@ -66,7 +66,7 @@ std::string DescribeScalingConfigurationsRequest::getScalingConfigurationId4()co
 void DescribeScalingConfigurationsRequest::setScalingConfigurationId4(const std::string& scalingConfigurationId4)
 {
 	scalingConfigurationId4_ = scalingConfigurationId4;
-	setParameter("ScalingConfigurationId4", scalingConfigurationId4);
+	setCoreParameter("ScalingConfigurationId4", scalingConfigurationId4);
 }
 
 std::string DescribeScalingConfigurationsRequest::getScalingConfigurationId5()const
@@ -77,7 +77,7 @@ std::string DescribeScalingConfigurationsRequest::getScalingConfigurationId5()co
 void DescribeScalingConfigurationsRequest::setScalingConfigurationId5(const std::string& scalingConfigurationId5)
 {
 	scalingConfigurationId5_ = scalingConfigurationId5;
-	setParameter("ScalingConfigurationId5", scalingConfigurationId5);
+	setCoreParameter("ScalingConfigurationId5", scalingConfigurationId5);
 }
 
 std::string DescribeScalingConfigurationsRequest::getScalingGroupId()const
@@ -88,7 +88,7 @@ std::string DescribeScalingConfigurationsRequest::getScalingGroupId()const
 void DescribeScalingConfigurationsRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 std::string DescribeScalingConfigurationsRequest::getScalingConfigurationId8()const
@@ -99,7 +99,7 @@ std::string DescribeScalingConfigurationsRequest::getScalingConfigurationId8()co
 void DescribeScalingConfigurationsRequest::setScalingConfigurationId8(const std::string& scalingConfigurationId8)
 {
 	scalingConfigurationId8_ = scalingConfigurationId8;
-	setParameter("ScalingConfigurationId8", scalingConfigurationId8);
+	setCoreParameter("ScalingConfigurationId8", scalingConfigurationId8);
 }
 
 std::string DescribeScalingConfigurationsRequest::getScalingConfigurationId9()const
@@ -110,7 +110,7 @@ std::string DescribeScalingConfigurationsRequest::getScalingConfigurationId9()co
 void DescribeScalingConfigurationsRequest::setScalingConfigurationId9(const std::string& scalingConfigurationId9)
 {
 	scalingConfigurationId9_ = scalingConfigurationId9;
-	setParameter("ScalingConfigurationId9", scalingConfigurationId9);
+	setCoreParameter("ScalingConfigurationId9", scalingConfigurationId9);
 }
 
 std::string DescribeScalingConfigurationsRequest::getScalingConfigurationId10()const
@@ -121,7 +121,7 @@ std::string DescribeScalingConfigurationsRequest::getScalingConfigurationId10()c
 void DescribeScalingConfigurationsRequest::setScalingConfigurationId10(const std::string& scalingConfigurationId10)
 {
 	scalingConfigurationId10_ = scalingConfigurationId10;
-	setParameter("ScalingConfigurationId10", scalingConfigurationId10);
+	setCoreParameter("ScalingConfigurationId10", scalingConfigurationId10);
 }
 
 int DescribeScalingConfigurationsRequest::getPageNumber()const
@@ -132,7 +132,7 @@ int DescribeScalingConfigurationsRequest::getPageNumber()const
 void DescribeScalingConfigurationsRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
+	setCoreParameter("PageNumber", std::to_string(pageNumber));
 }
 
 std::string DescribeScalingConfigurationsRequest::getAccessKeyId()const
@@ -143,7 +143,7 @@ std::string DescribeScalingConfigurationsRequest::getAccessKeyId()const
 void DescribeScalingConfigurationsRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeScalingConfigurationsRequest::getScalingConfigurationName2()const
@@ -154,7 +154,7 @@ std::string DescribeScalingConfigurationsRequest::getScalingConfigurationName2()
 void DescribeScalingConfigurationsRequest::setScalingConfigurationName2(const std::string& scalingConfigurationName2)
 {
 	scalingConfigurationName2_ = scalingConfigurationName2;
-	setParameter("ScalingConfigurationName2", scalingConfigurationName2);
+	setCoreParameter("ScalingConfigurationName2", scalingConfigurationName2);
 }
 
 std::string DescribeScalingConfigurationsRequest::getRegionId()const
@@ -165,7 +165,7 @@ std::string DescribeScalingConfigurationsRequest::getRegionId()const
 void DescribeScalingConfigurationsRequest::setRegionId(const std::string& regionId)
 {
 	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+	setCoreParameter("RegionId", regionId);
 }
 
 std::string DescribeScalingConfigurationsRequest::getScalingConfigurationName3()const
@@ -176,7 +176,7 @@ std::string DescribeScalingConfigurationsRequest::getScalingConfigurationName3()
 void DescribeScalingConfigurationsRequest::setScalingConfigurationName3(const std::string& scalingConfigurationName3)
 {
 	scalingConfigurationName3_ = scalingConfigurationName3;
-	setParameter("ScalingConfigurationName3", scalingConfigurationName3);
+	setCoreParameter("ScalingConfigurationName3", scalingConfigurationName3);
 }
 
 std::string DescribeScalingConfigurationsRequest::getScalingConfigurationName1()const
@@ -187,7 +187,7 @@ std::string DescribeScalingConfigurationsRequest::getScalingConfigurationName1()
 void DescribeScalingConfigurationsRequest::setScalingConfigurationName1(const std::string& scalingConfigurationName1)
 {
 	scalingConfigurationName1_ = scalingConfigurationName1;
-	setParameter("ScalingConfigurationName1", scalingConfigurationName1);
+	setCoreParameter("ScalingConfigurationName1", scalingConfigurationName1);
 }
 
 int DescribeScalingConfigurationsRequest::getPageSize()const
@@ -198,7 +198,7 @@ int DescribeScalingConfigurationsRequest::getPageSize()const
 void DescribeScalingConfigurationsRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+	setCoreParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string DescribeScalingConfigurationsRequest::getScalingConfigurationId2()const
@@ -209,7 +209,7 @@ std::string DescribeScalingConfigurationsRequest::getScalingConfigurationId2()co
 void DescribeScalingConfigurationsRequest::setScalingConfigurationId2(const std::string& scalingConfigurationId2)
 {
 	scalingConfigurationId2_ = scalingConfigurationId2;
-	setParameter("ScalingConfigurationId2", scalingConfigurationId2);
+	setCoreParameter("ScalingConfigurationId2", scalingConfigurationId2);
 }
 
 std::string DescribeScalingConfigurationsRequest::getScalingConfigurationId3()const
@@ -220,7 +220,7 @@ std::string DescribeScalingConfigurationsRequest::getScalingConfigurationId3()co
 void DescribeScalingConfigurationsRequest::setScalingConfigurationId3(const std::string& scalingConfigurationId3)
 {
 	scalingConfigurationId3_ = scalingConfigurationId3;
-	setParameter("ScalingConfigurationId3", scalingConfigurationId3);
+	setCoreParameter("ScalingConfigurationId3", scalingConfigurationId3);
 }
 
 std::string DescribeScalingConfigurationsRequest::getScalingConfigurationId1()const
@@ -231,7 +231,7 @@ std::string DescribeScalingConfigurationsRequest::getScalingConfigurationId1()co
 void DescribeScalingConfigurationsRequest::setScalingConfigurationId1(const std::string& scalingConfigurationId1)
 {
 	scalingConfigurationId1_ = scalingConfigurationId1;
-	setParameter("ScalingConfigurationId1", scalingConfigurationId1);
+	setCoreParameter("ScalingConfigurationId1", scalingConfigurationId1);
 }
 
 std::string DescribeScalingConfigurationsRequest::getResourceOwnerAccount()const
@@ -242,7 +242,7 @@ std::string DescribeScalingConfigurationsRequest::getResourceOwnerAccount()const
 void DescribeScalingConfigurationsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeScalingConfigurationsRequest::getOwnerAccount()const
@@ -253,7 +253,7 @@ std::string DescribeScalingConfigurationsRequest::getOwnerAccount()const
 void DescribeScalingConfigurationsRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 std::string DescribeScalingConfigurationsRequest::getScalingConfigurationName6()const
@@ -264,7 +264,7 @@ std::string DescribeScalingConfigurationsRequest::getScalingConfigurationName6()
 void DescribeScalingConfigurationsRequest::setScalingConfigurationName6(const std::string& scalingConfigurationName6)
 {
 	scalingConfigurationName6_ = scalingConfigurationName6;
-	setParameter("ScalingConfigurationName6", scalingConfigurationName6);
+	setCoreParameter("ScalingConfigurationName6", scalingConfigurationName6);
 }
 
 std::string DescribeScalingConfigurationsRequest::getScalingConfigurationName7()const
@@ -275,7 +275,7 @@ std::string DescribeScalingConfigurationsRequest::getScalingConfigurationName7()
 void DescribeScalingConfigurationsRequest::setScalingConfigurationName7(const std::string& scalingConfigurationName7)
 {
 	scalingConfigurationName7_ = scalingConfigurationName7;
-	setParameter("ScalingConfigurationName7", scalingConfigurationName7);
+	setCoreParameter("ScalingConfigurationName7", scalingConfigurationName7);
 }
 
 std::string DescribeScalingConfigurationsRequest::getScalingConfigurationName4()const
@@ -286,7 +286,7 @@ std::string DescribeScalingConfigurationsRequest::getScalingConfigurationName4()
 void DescribeScalingConfigurationsRequest::setScalingConfigurationName4(const std::string& scalingConfigurationName4)
 {
 	scalingConfigurationName4_ = scalingConfigurationName4;
-	setParameter("ScalingConfigurationName4", scalingConfigurationName4);
+	setCoreParameter("ScalingConfigurationName4", scalingConfigurationName4);
 }
 
 std::string DescribeScalingConfigurationsRequest::getScalingConfigurationName5()const
@@ -297,7 +297,7 @@ std::string DescribeScalingConfigurationsRequest::getScalingConfigurationName5()
 void DescribeScalingConfigurationsRequest::setScalingConfigurationName5(const std::string& scalingConfigurationName5)
 {
 	scalingConfigurationName5_ = scalingConfigurationName5;
-	setParameter("ScalingConfigurationName5", scalingConfigurationName5);
+	setCoreParameter("ScalingConfigurationName5", scalingConfigurationName5);
 }
 
 long DescribeScalingConfigurationsRequest::getOwnerId()const
@@ -308,7 +308,7 @@ long DescribeScalingConfigurationsRequest::getOwnerId()const
 void DescribeScalingConfigurationsRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScalingConfigurationsRequest::getScalingConfigurationName8()const
@@ -319,7 +319,7 @@ std::string DescribeScalingConfigurationsRequest::getScalingConfigurationName8()
 void DescribeScalingConfigurationsRequest::setScalingConfigurationName8(const std::string& scalingConfigurationName8)
 {
 	scalingConfigurationName8_ = scalingConfigurationName8;
-	setParameter("ScalingConfigurationName8", scalingConfigurationName8);
+	setCoreParameter("ScalingConfigurationName8", scalingConfigurationName8);
 }
 
 std::string DescribeScalingConfigurationsRequest::getScalingConfigurationName9()const
@@ -330,7 +330,7 @@ std::string DescribeScalingConfigurationsRequest::getScalingConfigurationName9()
 void DescribeScalingConfigurationsRequest::setScalingConfigurationName9(const std::string& scalingConfigurationName9)
 {
 	scalingConfigurationName9_ = scalingConfigurationName9;
-	setParameter("ScalingConfigurationName9", scalingConfigurationName9);
+	setCoreParameter("ScalingConfigurationName9", scalingConfigurationName9);
 }
 
 std::string DescribeScalingConfigurationsRequest::getScalingConfigurationName10()const
@@ -341,6 +341,6 @@ std::string DescribeScalingConfigurationsRequest::getScalingConfigurationName10(
 void DescribeScalingConfigurationsRequest::setScalingConfigurationName10(const std::string& scalingConfigurationName10)
 {
 	scalingConfigurationName10_ = scalingConfigurationName10;
-	setParameter("ScalingConfigurationName10", scalingConfigurationName10);
+	setCoreParameter("ScalingConfigurationName10", scalingConfigurationName10);
 }
 

ess/src/model/DescribeScalingConfigurationsResult.cc

@@ -80,6 +80,10 @@ void DescribeScalingConfigurationsResult::parse(const std::string &payload)
 			scalingConfigurationsObject.systemDiskCategory = value["SystemDiskCategory"].asString();
 		if(!value["SystemDiskSize"].isNull())
 			scalingConfigurationsObject.systemDiskSize = std::stoi(value["SystemDiskSize"].asString());
+		if(!value["SystemDiskName"].isNull())
+			scalingConfigurationsObject.systemDiskName = value["SystemDiskName"].asString();
+		if(!value["SystemDiskDescription"].isNull())
+			scalingConfigurationsObject.systemDiskDescription = value["SystemDiskDescription"].asString();
 		if(!value["LifecycleState"].isNull())
 			scalingConfigurationsObject.lifecycleState = value["LifecycleState"].asString();
 		if(!value["CreationTime"].isNull())
@@ -100,6 +104,8 @@ void DescribeScalingConfigurationsResult::parse(const std::string &payload)
 			scalingConfigurationsObject.spotStrategy = value["SpotStrategy"].asString();
 		if(!value["PasswordInherit"].isNull())
 			scalingConfigurationsObject.passwordInherit = value["PasswordInherit"].asString() == "true";
+		if(!value["ResourceGroupId"].isNull())
+			scalingConfigurationsObject.resourceGroupId = value["ResourceGroupId"].asString();
 		auto allDataDisks = value["DataDisks"]["DataDisk"];
 		for (auto value : allDataDisks)
 		{
@@ -114,6 +120,14 @@ void DescribeScalingConfigurationsResult::parse(const std::string &payload)
 				dataDisksObject.device = value["Device"].asString();
 			if(!value["DeleteWithInstance"].isNull())
 				dataDisksObject.deleteWithInstance = value["DeleteWithInstance"].asString() == "true";
+			if(!value["Encrypted"].isNull())
+				dataDisksObject.encrypted = value["Encrypted"].asString();
+			if(!value["KMSKeyId"].isNull())
+				dataDisksObject.kMSKeyId = value["KMSKeyId"].asString();
+			if(!value["DiskName"].isNull())
+				dataDisksObject.diskName = value["DiskName"].asString();
+			if(!value["Description"].isNull())
+				dataDisksObject.description = value["Description"].asString();
 			scalingConfigurationsObject.dataDisks.push_back(dataDisksObject);
 		}
 		auto allTags = value["Tags"]["Tag"];

ess/src/model/DescribeScalingGroupsRequest.cc

@@ -33,7 +33,7 @@ long DescribeScalingGroupsRequest::getResourceOwnerId()const
 void DescribeScalingGroupsRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupId10()const
@@ -44,7 +44,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupId10()const
 void DescribeScalingGroupsRequest::setScalingGroupId10(const std::string& scalingGroupId10)
 {
 	scalingGroupId10_ = scalingGroupId10;
-	setParameter("ScalingGroupId10", scalingGroupId10);
+	setCoreParameter("ScalingGroupId10", scalingGroupId10);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupId12()const
@@ -55,7 +55,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupId12()const
 void DescribeScalingGroupsRequest::setScalingGroupId12(const std::string& scalingGroupId12)
 {
 	scalingGroupId12_ = scalingGroupId12;
-	setParameter("ScalingGroupId12", scalingGroupId12);
+	setCoreParameter("ScalingGroupId12", scalingGroupId12);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupId13()const
@@ -66,7 +66,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupId13()const
 void DescribeScalingGroupsRequest::setScalingGroupId13(const std::string& scalingGroupId13)
 {
 	scalingGroupId13_ = scalingGroupId13;
-	setParameter("ScalingGroupId13", scalingGroupId13);
+	setCoreParameter("ScalingGroupId13", scalingGroupId13);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupId14()const
@@ -77,7 +77,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupId14()const
 void DescribeScalingGroupsRequest::setScalingGroupId14(const std::string& scalingGroupId14)
 {
 	scalingGroupId14_ = scalingGroupId14;
-	setParameter("ScalingGroupId14", scalingGroupId14);
+	setCoreParameter("ScalingGroupId14", scalingGroupId14);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupId15()const
@@ -88,7 +88,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupId15()const
 void DescribeScalingGroupsRequest::setScalingGroupId15(const std::string& scalingGroupId15)
 {
 	scalingGroupId15_ = scalingGroupId15;
-	setParameter("ScalingGroupId15", scalingGroupId15);
+	setCoreParameter("ScalingGroupId15", scalingGroupId15);
 }
 
 long DescribeScalingGroupsRequest::getOwnerId()const
@@ -99,7 +99,7 @@ long DescribeScalingGroupsRequest::getOwnerId()const
 void DescribeScalingGroupsRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 int DescribeScalingGroupsRequest::getPageNumber()const
@@ -110,7 +110,7 @@ int DescribeScalingGroupsRequest::getPageNumber()const
 void DescribeScalingGroupsRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
+	setCoreParameter("PageNumber", std::to_string(pageNumber));
 }
 
 std::string DescribeScalingGroupsRequest::getAccessKeyId()const
@@ -121,7 +121,7 @@ std::string DescribeScalingGroupsRequest::getAccessKeyId()const
 void DescribeScalingGroupsRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeScalingGroupsRequest::getRegionId()const
@@ -132,7 +132,7 @@ std::string DescribeScalingGroupsRequest::getRegionId()const
 void DescribeScalingGroupsRequest::setRegionId(const std::string& regionId)
 {
 	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+	setCoreParameter("RegionId", regionId);
 }
 
 int DescribeScalingGroupsRequest::getPageSize()const
@@ -143,7 +143,7 @@ int DescribeScalingGroupsRequest::getPageSize()const
 void DescribeScalingGroupsRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+	setCoreParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName20()const
@@ -154,7 +154,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName20()const
 void DescribeScalingGroupsRequest::setScalingGroupName20(const std::string& scalingGroupName20)
 {
 	scalingGroupName20_ = scalingGroupName20;
-	setParameter("ScalingGroupName20", scalingGroupName20);
+	setCoreParameter("ScalingGroupName20", scalingGroupName20);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName19()const
@@ -165,7 +165,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName19()const
 void DescribeScalingGroupsRequest::setScalingGroupName19(const std::string& scalingGroupName19)
 {
 	scalingGroupName19_ = scalingGroupName19;
-	setParameter("ScalingGroupName19", scalingGroupName19);
+	setCoreParameter("ScalingGroupName19", scalingGroupName19);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupId20()const
@@ -176,7 +176,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupId20()const
 void DescribeScalingGroupsRequest::setScalingGroupId20(const std::string& scalingGroupId20)
 {
 	scalingGroupId20_ = scalingGroupId20;
-	setParameter("ScalingGroupId20", scalingGroupId20);
+	setCoreParameter("ScalingGroupId20", scalingGroupId20);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName18()const
@@ -187,7 +187,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName18()const
 void DescribeScalingGroupsRequest::setScalingGroupName18(const std::string& scalingGroupName18)
 {
 	scalingGroupName18_ = scalingGroupName18;
-	setParameter("ScalingGroupName18", scalingGroupName18);
+	setCoreParameter("ScalingGroupName18", scalingGroupName18);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName17()const
@@ -198,7 +198,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName17()const
 void DescribeScalingGroupsRequest::setScalingGroupName17(const std::string& scalingGroupName17)
 {
 	scalingGroupName17_ = scalingGroupName17;
-	setParameter("ScalingGroupName17", scalingGroupName17);
+	setCoreParameter("ScalingGroupName17", scalingGroupName17);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName16()const
@@ -209,7 +209,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName16()const
 void DescribeScalingGroupsRequest::setScalingGroupName16(const std::string& scalingGroupName16)
 {
 	scalingGroupName16_ = scalingGroupName16;
-	setParameter("ScalingGroupName16", scalingGroupName16);
+	setCoreParameter("ScalingGroupName16", scalingGroupName16);
 }
 
 std::string DescribeScalingGroupsRequest::getResourceOwnerAccount()const
@@ -220,7 +220,7 @@ std::string DescribeScalingGroupsRequest::getResourceOwnerAccount()const
 void DescribeScalingGroupsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName()const
@@ -231,7 +231,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName()const
 void DescribeScalingGroupsRequest::setScalingGroupName(const std::string& scalingGroupName)
 {
 	scalingGroupName_ = scalingGroupName;
-	setParameter("ScalingGroupName", scalingGroupName);
+	setCoreParameter("ScalingGroupName", scalingGroupName);
 }
 
 std::string DescribeScalingGroupsRequest::getOwnerAccount()const
@@ -242,7 +242,7 @@ std::string DescribeScalingGroupsRequest::getOwnerAccount()const
 void DescribeScalingGroupsRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName1()const
@@ -253,7 +253,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName1()const
 void DescribeScalingGroupsRequest::setScalingGroupName1(const std::string& scalingGroupName1)
 {
 	scalingGroupName1_ = scalingGroupName1;
-	setParameter("ScalingGroupName1", scalingGroupName1);
+	setCoreParameter("ScalingGroupName1", scalingGroupName1);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName2()const
@@ -264,7 +264,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName2()const
 void DescribeScalingGroupsRequest::setScalingGroupName2(const std::string& scalingGroupName2)
 {
 	scalingGroupName2_ = scalingGroupName2;
-	setParameter("ScalingGroupName2", scalingGroupName2);
+	setCoreParameter("ScalingGroupName2", scalingGroupName2);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupId2()const
@@ -275,7 +275,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupId2()const
 void DescribeScalingGroupsRequest::setScalingGroupId2(const std::string& scalingGroupId2)
 {
 	scalingGroupId2_ = scalingGroupId2;
-	setParameter("ScalingGroupId2", scalingGroupId2);
+	setCoreParameter("ScalingGroupId2", scalingGroupId2);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupId1()const
@@ -286,7 +286,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupId1()const
 void DescribeScalingGroupsRequest::setScalingGroupId1(const std::string& scalingGroupId1)
 {
 	scalingGroupId1_ = scalingGroupId1;
-	setParameter("ScalingGroupId1", scalingGroupId1);
+	setCoreParameter("ScalingGroupId1", scalingGroupId1);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupId6()const
@@ -297,7 +297,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupId6()const
 void DescribeScalingGroupsRequest::setScalingGroupId6(const std::string& scalingGroupId6)
 {
 	scalingGroupId6_ = scalingGroupId6;
-	setParameter("ScalingGroupId6", scalingGroupId6);
+	setCoreParameter("ScalingGroupId6", scalingGroupId6);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupId16()const
@@ -308,7 +308,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupId16()const
 void DescribeScalingGroupsRequest::setScalingGroupId16(const std::string& scalingGroupId16)
 {
 	scalingGroupId16_ = scalingGroupId16;
-	setParameter("ScalingGroupId16", scalingGroupId16);
+	setCoreParameter("ScalingGroupId16", scalingGroupId16);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName7()const
@@ -319,7 +319,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName7()const
 void DescribeScalingGroupsRequest::setScalingGroupName7(const std::string& scalingGroupName7)
 {
 	scalingGroupName7_ = scalingGroupName7;
-	setParameter("ScalingGroupName7", scalingGroupName7);
+	setCoreParameter("ScalingGroupName7", scalingGroupName7);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName11()const
@@ -330,7 +330,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName11()const
 void DescribeScalingGroupsRequest::setScalingGroupName11(const std::string& scalingGroupName11)
 {
 	scalingGroupName11_ = scalingGroupName11;
-	setParameter("ScalingGroupName11", scalingGroupName11);
+	setCoreParameter("ScalingGroupName11", scalingGroupName11);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupId5()const
@@ -341,7 +341,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupId5()const
 void DescribeScalingGroupsRequest::setScalingGroupId5(const std::string& scalingGroupId5)
 {
 	scalingGroupId5_ = scalingGroupId5;
-	setParameter("ScalingGroupId5", scalingGroupId5);
+	setCoreParameter("ScalingGroupId5", scalingGroupId5);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupId17()const
@@ -352,7 +352,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupId17()const
 void DescribeScalingGroupsRequest::setScalingGroupId17(const std::string& scalingGroupId17)
 {
 	scalingGroupId17_ = scalingGroupId17;
-	setParameter("ScalingGroupId17", scalingGroupId17);
+	setCoreParameter("ScalingGroupId17", scalingGroupId17);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName8()const
@@ -363,7 +363,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName8()const
 void DescribeScalingGroupsRequest::setScalingGroupName8(const std::string& scalingGroupName8)
 {
 	scalingGroupName8_ = scalingGroupName8;
-	setParameter("ScalingGroupName8", scalingGroupName8);
+	setCoreParameter("ScalingGroupName8", scalingGroupName8);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName10()const
@@ -374,7 +374,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName10()const
 void DescribeScalingGroupsRequest::setScalingGroupName10(const std::string& scalingGroupName10)
 {
 	scalingGroupName10_ = scalingGroupName10;
-	setParameter("ScalingGroupName10", scalingGroupName10);
+	setCoreParameter("ScalingGroupName10", scalingGroupName10);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupId4()const
@@ -385,7 +385,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupId4()const
 void DescribeScalingGroupsRequest::setScalingGroupId4(const std::string& scalingGroupId4)
 {
 	scalingGroupId4_ = scalingGroupId4;
-	setParameter("ScalingGroupId4", scalingGroupId4);
+	setCoreParameter("ScalingGroupId4", scalingGroupId4);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupId18()const
@@ -396,7 +396,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupId18()const
 void DescribeScalingGroupsRequest::setScalingGroupId18(const std::string& scalingGroupId18)
 {
 	scalingGroupId18_ = scalingGroupId18;
-	setParameter("ScalingGroupId18", scalingGroupId18);
+	setCoreParameter("ScalingGroupId18", scalingGroupId18);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName9()const
@@ -407,7 +407,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName9()const
 void DescribeScalingGroupsRequest::setScalingGroupName9(const std::string& scalingGroupName9)
 {
 	scalingGroupName9_ = scalingGroupName9;
-	setParameter("ScalingGroupName9", scalingGroupName9);
+	setCoreParameter("ScalingGroupName9", scalingGroupName9);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupId3()const
@@ -418,7 +418,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupId3()const
 void DescribeScalingGroupsRequest::setScalingGroupId3(const std::string& scalingGroupId3)
 {
 	scalingGroupId3_ = scalingGroupId3;
-	setParameter("ScalingGroupId3", scalingGroupId3);
+	setCoreParameter("ScalingGroupId3", scalingGroupId3);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupId19()const
@@ -429,7 +429,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupId19()const
 void DescribeScalingGroupsRequest::setScalingGroupId19(const std::string& scalingGroupId19)
 {
 	scalingGroupId19_ = scalingGroupId19;
-	setParameter("ScalingGroupId19", scalingGroupId19);
+	setCoreParameter("ScalingGroupId19", scalingGroupId19);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName3()const
@@ -440,7 +440,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName3()const
 void DescribeScalingGroupsRequest::setScalingGroupName3(const std::string& scalingGroupName3)
 {
 	scalingGroupName3_ = scalingGroupName3;
-	setParameter("ScalingGroupName3", scalingGroupName3);
+	setCoreParameter("ScalingGroupName3", scalingGroupName3);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName15()const
@@ -451,7 +451,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName15()const
 void DescribeScalingGroupsRequest::setScalingGroupName15(const std::string& scalingGroupName15)
 {
 	scalingGroupName15_ = scalingGroupName15;
-	setParameter("ScalingGroupName15", scalingGroupName15);
+	setCoreParameter("ScalingGroupName15", scalingGroupName15);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupId9()const
@@ -462,7 +462,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupId9()const
 void DescribeScalingGroupsRequest::setScalingGroupId9(const std::string& scalingGroupId9)
 {
 	scalingGroupId9_ = scalingGroupId9;
-	setParameter("ScalingGroupId9", scalingGroupId9);
+	setCoreParameter("ScalingGroupId9", scalingGroupId9);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName4()const
@@ -473,7 +473,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName4()const
 void DescribeScalingGroupsRequest::setScalingGroupName4(const std::string& scalingGroupName4)
 {
 	scalingGroupName4_ = scalingGroupName4;
-	setParameter("ScalingGroupName4", scalingGroupName4);
+	setCoreParameter("ScalingGroupName4", scalingGroupName4);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName14()const
@@ -484,7 +484,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName14()const
 void DescribeScalingGroupsRequest::setScalingGroupName14(const std::string& scalingGroupName14)
 {
 	scalingGroupName14_ = scalingGroupName14;
-	setParameter("ScalingGroupName14", scalingGroupName14);
+	setCoreParameter("ScalingGroupName14", scalingGroupName14);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupId8()const
@@ -495,7 +495,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupId8()const
 void DescribeScalingGroupsRequest::setScalingGroupId8(const std::string& scalingGroupId8)
 {
 	scalingGroupId8_ = scalingGroupId8;
-	setParameter("ScalingGroupId8", scalingGroupId8);
+	setCoreParameter("ScalingGroupId8", scalingGroupId8);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName5()const
@@ -506,7 +506,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName5()const
 void DescribeScalingGroupsRequest::setScalingGroupName5(const std::string& scalingGroupName5)
 {
 	scalingGroupName5_ = scalingGroupName5;
-	setParameter("ScalingGroupName5", scalingGroupName5);
+	setCoreParameter("ScalingGroupName5", scalingGroupName5);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName13()const
@@ -517,7 +517,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName13()const
 void DescribeScalingGroupsRequest::setScalingGroupName13(const std::string& scalingGroupName13)
 {
 	scalingGroupName13_ = scalingGroupName13;
-	setParameter("ScalingGroupName13", scalingGroupName13);
+	setCoreParameter("ScalingGroupName13", scalingGroupName13);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupId7()const
@@ -528,7 +528,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupId7()const
 void DescribeScalingGroupsRequest::setScalingGroupId7(const std::string& scalingGroupId7)
 {
 	scalingGroupId7_ = scalingGroupId7;
-	setParameter("ScalingGroupId7", scalingGroupId7);
+	setCoreParameter("ScalingGroupId7", scalingGroupId7);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName6()const
@@ -539,7 +539,7 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName6()const
 void DescribeScalingGroupsRequest::setScalingGroupName6(const std::string& scalingGroupName6)
 {
 	scalingGroupName6_ = scalingGroupName6;
-	setParameter("ScalingGroupName6", scalingGroupName6);
+	setCoreParameter("ScalingGroupName6", scalingGroupName6);
 }
 
 std::string DescribeScalingGroupsRequest::getScalingGroupName12()const
@@ -550,6 +550,6 @@ std::string DescribeScalingGroupsRequest::getScalingGroupName12()const
 void DescribeScalingGroupsRequest::setScalingGroupName12(const std::string& scalingGroupName12)
 {
 	scalingGroupName12_ = scalingGroupName12;
-	setParameter("ScalingGroupName12", scalingGroupName12);
+	setCoreParameter("ScalingGroupName12", scalingGroupName12);
 }
 

ess/src/model/DescribeScalingGroupsResult.cc

@@ -96,6 +96,26 @@ void DescribeScalingGroupsResult::parse(const std::string &payload)
 			scalingGroupsObject.scalingPolicy = value["ScalingPolicy"].asString();
 		if(!value["StoppedCapacity"].isNull())
 			scalingGroupsObject.stoppedCapacity = std::stoi(value["StoppedCapacity"].asString());
+		auto allVServerGroups = value["VServerGroups"]["VServerGroup"];
+		for (auto value : allVServerGroups)
+		{
+			ScalingGroup::VServerGroup vServerGroupsObject;
+			if(!value["LoadBalancerId"].isNull())
+				vServerGroupsObject.loadBalancerId = value["LoadBalancerId"].asString();
+			auto allVServerGroupAttributes = value["VServerGroupAttributes"]["VServerGroupAttribute"];
+			for (auto value : allVServerGroupAttributes)
+			{
+				ScalingGroup::VServerGroup::VServerGroupAttribute vServerGroupAttributesObject;
+				if(!value["VServerGroupId"].isNull())
+					vServerGroupAttributesObject.vServerGroupId = value["VServerGroupId"].asString();
+				if(!value["Port"].isNull())
+					vServerGroupAttributesObject.port = std::stoi(value["Port"].asString());
+				if(!value["Weight"].isNull())
+					vServerGroupAttributesObject.weight = std::stoi(value["Weight"].asString());
+				vServerGroupsObject.vServerGroupAttributes.push_back(vServerGroupAttributesObject);
+			}
+			scalingGroupsObject.vServerGroups.push_back(vServerGroupsObject);
+		}
 		auto allVSwitchIds = value["VSwitchIds"]["VSwitchId"];
 		for (auto value : allVSwitchIds)
 			scalingGroupsObject.vSwitchIds.push_back(value.asString());

ess/src/model/DescribeScalingInstancesRequest.cc

@@ -33,7 +33,7 @@ std::string DescribeScalingInstancesRequest::getInstanceId10()const
 void DescribeScalingInstancesRequest::setInstanceId10(const std::string& instanceId10)
 {
 	instanceId10_ = instanceId10;
-	setParameter("InstanceId10", instanceId10);
+	setCoreParameter("InstanceId10", instanceId10);
 }
 
 long DescribeScalingInstancesRequest::getResourceOwnerId()const
@@ -44,7 +44,7 @@ long DescribeScalingInstancesRequest::getResourceOwnerId()const
 void DescribeScalingInstancesRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeScalingInstancesRequest::getInstanceId12()const
@@ -55,7 +55,7 @@ std::string DescribeScalingInstancesRequest::getInstanceId12()const
 void DescribeScalingInstancesRequest::setInstanceId12(const std::string& instanceId12)
 {
 	instanceId12_ = instanceId12;
-	setParameter("InstanceId12", instanceId12);
+	setCoreParameter("InstanceId12", instanceId12);
 }
 
 std::string DescribeScalingInstancesRequest::getInstanceId11()const
@@ -66,7 +66,7 @@ std::string DescribeScalingInstancesRequest::getInstanceId11()const
 void DescribeScalingInstancesRequest::setInstanceId11(const std::string& instanceId11)
 {
 	instanceId11_ = instanceId11;
-	setParameter("InstanceId11", instanceId11);
+	setCoreParameter("InstanceId11", instanceId11);
 }
 
 std::string DescribeScalingInstancesRequest::getScalingGroupId()const
@@ -77,7 +77,7 @@ std::string DescribeScalingInstancesRequest::getScalingGroupId()const
 void DescribeScalingInstancesRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 std::string DescribeScalingInstancesRequest::getLifecycleState()const
@@ -88,7 +88,7 @@ std::string DescribeScalingInstancesRequest::getLifecycleState()const
 void DescribeScalingInstancesRequest::setLifecycleState(const std::string& lifecycleState)
 {
 	lifecycleState_ = lifecycleState;
-	setParameter("LifecycleState", lifecycleState);
+	setCoreParameter("LifecycleState", lifecycleState);
 }
 
 std::string DescribeScalingInstancesRequest::getCreationType()const
@@ -99,7 +99,7 @@ std::string DescribeScalingInstancesRequest::getCreationType()const
 void DescribeScalingInstancesRequest::setCreationType(const std::string& creationType)
 {
 	creationType_ = creationType;
-	setParameter("CreationType", creationType);
+	setCoreParameter("CreationType", creationType);
 }
 
 int DescribeScalingInstancesRequest::getPageNumber()const
@@ -110,7 +110,7 @@ int DescribeScalingInstancesRequest::getPageNumber()const
 void DescribeScalingInstancesRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
+	setCoreParameter("PageNumber", std::to_string(pageNumber));
 }
 
 std::string DescribeScalingInstancesRequest::getAccessKeyId()const
@@ -121,7 +121,7 @@ std::string DescribeScalingInstancesRequest::getAccessKeyId()const
 void DescribeScalingInstancesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeScalingInstancesRequest::getRegionId()const
@@ -132,7 +132,7 @@ std::string DescribeScalingInstancesRequest::getRegionId()const
 void DescribeScalingInstancesRequest::setRegionId(const std::string& regionId)
 {
 	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+	setCoreParameter("RegionId", regionId);
 }
 
 int DescribeScalingInstancesRequest::getPageSize()const
@@ -143,7 +143,7 @@ int DescribeScalingInstancesRequest::getPageSize()const
 void DescribeScalingInstancesRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+	setCoreParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string DescribeScalingInstancesRequest::getInstanceId20()const
@@ -154,7 +154,7 @@ std::string DescribeScalingInstancesRequest::getInstanceId20()const
 void DescribeScalingInstancesRequest::setInstanceId20(const std::string& instanceId20)
 {
 	instanceId20_ = instanceId20;
-	setParameter("InstanceId20", instanceId20);
+	setCoreParameter("InstanceId20", instanceId20);
 }
 
 std::string DescribeScalingInstancesRequest::getInstanceId1()const
@@ -165,7 +165,7 @@ std::string DescribeScalingInstancesRequest::getInstanceId1()const
 void DescribeScalingInstancesRequest::setInstanceId1(const std::string& instanceId1)
 {
 	instanceId1_ = instanceId1;
-	setParameter("InstanceId1", instanceId1);
+	setCoreParameter("InstanceId1", instanceId1);
 }
 
 std::string DescribeScalingInstancesRequest::getInstanceId3()const
@@ -176,7 +176,7 @@ std::string DescribeScalingInstancesRequest::getInstanceId3()const
 void DescribeScalingInstancesRequest::setInstanceId3(const std::string& instanceId3)
 {
 	instanceId3_ = instanceId3;
-	setParameter("InstanceId3", instanceId3);
+	setCoreParameter("InstanceId3", instanceId3);
 }
 
 std::string DescribeScalingInstancesRequest::getResourceOwnerAccount()const
@@ -187,7 +187,7 @@ std::string DescribeScalingInstancesRequest::getResourceOwnerAccount()const
 void DescribeScalingInstancesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeScalingInstancesRequest::getInstanceId2()const
@@ -198,7 +198,7 @@ std::string DescribeScalingInstancesRequest::getInstanceId2()const
 void DescribeScalingInstancesRequest::setInstanceId2(const std::string& instanceId2)
 {
 	instanceId2_ = instanceId2;
-	setParameter("InstanceId2", instanceId2);
+	setCoreParameter("InstanceId2", instanceId2);
 }
 
 std::string DescribeScalingInstancesRequest::getInstanceId5()const
@@ -209,7 +209,7 @@ std::string DescribeScalingInstancesRequest::getInstanceId5()const
 void DescribeScalingInstancesRequest::setInstanceId5(const std::string& instanceId5)
 {
 	instanceId5_ = instanceId5;
-	setParameter("InstanceId5", instanceId5);
+	setCoreParameter("InstanceId5", instanceId5);
 }
 
 std::string DescribeScalingInstancesRequest::getInstanceId4()const
@@ -220,7 +220,7 @@ std::string DescribeScalingInstancesRequest::getInstanceId4()const
 void DescribeScalingInstancesRequest::setInstanceId4(const std::string& instanceId4)
 {
 	instanceId4_ = instanceId4;
-	setParameter("InstanceId4", instanceId4);
+	setCoreParameter("InstanceId4", instanceId4);
 }
 
 std::string DescribeScalingInstancesRequest::getOwnerAccount()const
@@ -231,7 +231,7 @@ std::string DescribeScalingInstancesRequest::getOwnerAccount()const
 void DescribeScalingInstancesRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 std::string DescribeScalingInstancesRequest::getInstanceId7()const
@@ -242,7 +242,7 @@ std::string DescribeScalingInstancesRequest::getInstanceId7()const
 void DescribeScalingInstancesRequest::setInstanceId7(const std::string& instanceId7)
 {
 	instanceId7_ = instanceId7;
-	setParameter("InstanceId7", instanceId7);
+	setCoreParameter("InstanceId7", instanceId7);
 }
 
 std::string DescribeScalingInstancesRequest::getInstanceId6()const
@@ -253,7 +253,7 @@ std::string DescribeScalingInstancesRequest::getInstanceId6()const
 void DescribeScalingInstancesRequest::setInstanceId6(const std::string& instanceId6)
 {
 	instanceId6_ = instanceId6;
-	setParameter("InstanceId6", instanceId6);
+	setCoreParameter("InstanceId6", instanceId6);
 }
 
 std::string DescribeScalingInstancesRequest::getInstanceId9()const
@@ -264,7 +264,7 @@ std::string DescribeScalingInstancesRequest::getInstanceId9()const
 void DescribeScalingInstancesRequest::setInstanceId9(const std::string& instanceId9)
 {
 	instanceId9_ = instanceId9;
-	setParameter("InstanceId9", instanceId9);
+	setCoreParameter("InstanceId9", instanceId9);
 }
 
 std::string DescribeScalingInstancesRequest::getInstanceId8()const
@@ -275,7 +275,7 @@ std::string DescribeScalingInstancesRequest::getInstanceId8()const
 void DescribeScalingInstancesRequest::setInstanceId8(const std::string& instanceId8)
 {
 	instanceId8_ = instanceId8;
-	setParameter("InstanceId8", instanceId8);
+	setCoreParameter("InstanceId8", instanceId8);
 }
 
 long DescribeScalingInstancesRequest::getOwnerId()const
@@ -286,7 +286,7 @@ long DescribeScalingInstancesRequest::getOwnerId()const
 void DescribeScalingInstancesRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScalingInstancesRequest::getScalingConfigurationId()const
@@ -297,7 +297,7 @@ std::string DescribeScalingInstancesRequest::getScalingConfigurationId()const
 void DescribeScalingInstancesRequest::setScalingConfigurationId(const std::string& scalingConfigurationId)
 {
 	scalingConfigurationId_ = scalingConfigurationId;
-	setParameter("ScalingConfigurationId", scalingConfigurationId);
+	setCoreParameter("ScalingConfigurationId", scalingConfigurationId);
 }
 
 std::string DescribeScalingInstancesRequest::getHealthStatus()const
@@ -308,7 +308,7 @@ std::string DescribeScalingInstancesRequest::getHealthStatus()const
 void DescribeScalingInstancesRequest::setHealthStatus(const std::string& healthStatus)
 {
 	healthStatus_ = healthStatus;
-	setParameter("HealthStatus", healthStatus);
+	setCoreParameter("HealthStatus", healthStatus);
 }
 
 std::string DescribeScalingInstancesRequest::getInstanceId18()const
@@ -319,7 +319,7 @@ std::string DescribeScalingInstancesRequest::getInstanceId18()const
 void DescribeScalingInstancesRequest::setInstanceId18(const std::string& instanceId18)
 {
 	instanceId18_ = instanceId18;
-	setParameter("InstanceId18", instanceId18);
+	setCoreParameter("InstanceId18", instanceId18);
 }
 
 std::string DescribeScalingInstancesRequest::getInstanceId17()const
@@ -330,7 +330,7 @@ std::string DescribeScalingInstancesRequest::getInstanceId17()const
 void DescribeScalingInstancesRequest::setInstanceId17(const std::string& instanceId17)
 {
 	instanceId17_ = instanceId17;
-	setParameter("InstanceId17", instanceId17);
+	setCoreParameter("InstanceId17", instanceId17);
 }
 
 std::string DescribeScalingInstancesRequest::getInstanceId19()const
@@ -341,7 +341,7 @@ std::string DescribeScalingInstancesRequest::getInstanceId19()const
 void DescribeScalingInstancesRequest::setInstanceId19(const std::string& instanceId19)
 {
 	instanceId19_ = instanceId19;
-	setParameter("InstanceId19", instanceId19);
+	setCoreParameter("InstanceId19", instanceId19);
 }
 
 std::string DescribeScalingInstancesRequest::getInstanceId14()const
@@ -352,7 +352,7 @@ std::string DescribeScalingInstancesRequest::getInstanceId14()const
 void DescribeScalingInstancesRequest::setInstanceId14(const std::string& instanceId14)
 {
 	instanceId14_ = instanceId14;
-	setParameter("InstanceId14", instanceId14);
+	setCoreParameter("InstanceId14", instanceId14);
 }
 
 std::string DescribeScalingInstancesRequest::getInstanceId13()const
@@ -363,7 +363,7 @@ std::string DescribeScalingInstancesRequest::getInstanceId13()const
 void DescribeScalingInstancesRequest::setInstanceId13(const std::string& instanceId13)
 {
 	instanceId13_ = instanceId13;
-	setParameter("InstanceId13", instanceId13);
+	setCoreParameter("InstanceId13", instanceId13);
 }
 
 std::string DescribeScalingInstancesRequest::getInstanceId16()const
@@ -374,7 +374,7 @@ std::string DescribeScalingInstancesRequest::getInstanceId16()const
 void DescribeScalingInstancesRequest::setInstanceId16(const std::string& instanceId16)
 {
 	instanceId16_ = instanceId16;
-	setParameter("InstanceId16", instanceId16);
+	setCoreParameter("InstanceId16", instanceId16);
 }
 
 std::string DescribeScalingInstancesRequest::getInstanceId15()const
@@ -385,6 +385,6 @@ std::string DescribeScalingInstancesRequest::getInstanceId15()const
 void DescribeScalingInstancesRequest::setInstanceId15(const std::string& instanceId15)
 {
 	instanceId15_ = instanceId15;
-	setParameter("InstanceId15", instanceId15);
+	setCoreParameter("InstanceId15", instanceId15);
 }
 

ess/src/model/DescribeScalingInstancesResult.cc

@@ -64,6 +64,8 @@ void DescribeScalingInstancesResult::parse(const std::string &payload)
 			scalingInstancesObject.launchTemplateId = value["LaunchTemplateId"].asString();
 		if(!value["LaunchTemplateVersion"].isNull())
 			scalingInstancesObject.launchTemplateVersion = value["LaunchTemplateVersion"].asString();
+		if(!value["WarmupState"].isNull())
+			scalingInstancesObject.warmupState = value["WarmupState"].asString();
 		scalingInstances_.push_back(scalingInstancesObject);
 	}
 	if(!value["TotalCount"].isNull())

ess/src/model/DescribeScalingRulesRequest.cc

@@ -33,7 +33,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleName1()const
 void DescribeScalingRulesRequest::setScalingRuleName1(const std::string& scalingRuleName1)
 {
 	scalingRuleName1_ = scalingRuleName1;
-	setParameter("ScalingRuleName1", scalingRuleName1);
+	setCoreParameter("ScalingRuleName1", scalingRuleName1);
 }
 
 long DescribeScalingRulesRequest::getResourceOwnerId()const
@@ -44,7 +44,7 @@ long DescribeScalingRulesRequest::getResourceOwnerId()const
 void DescribeScalingRulesRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleName2()const
@@ -55,7 +55,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleName2()const
 void DescribeScalingRulesRequest::setScalingRuleName2(const std::string& scalingRuleName2)
 {
 	scalingRuleName2_ = scalingRuleName2;
-	setParameter("ScalingRuleName2", scalingRuleName2);
+	setCoreParameter("ScalingRuleName2", scalingRuleName2);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleName3()const
@@ -66,7 +66,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleName3()const
 void DescribeScalingRulesRequest::setScalingRuleName3(const std::string& scalingRuleName3)
 {
 	scalingRuleName3_ = scalingRuleName3;
-	setParameter("ScalingRuleName3", scalingRuleName3);
+	setCoreParameter("ScalingRuleName3", scalingRuleName3);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleName4()const
@@ -77,7 +77,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleName4()const
 void DescribeScalingRulesRequest::setScalingRuleName4(const std::string& scalingRuleName4)
 {
 	scalingRuleName4_ = scalingRuleName4;
-	setParameter("ScalingRuleName4", scalingRuleName4);
+	setCoreParameter("ScalingRuleName4", scalingRuleName4);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleName5()const
@@ -88,7 +88,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleName5()const
 void DescribeScalingRulesRequest::setScalingRuleName5(const std::string& scalingRuleName5)
 {
 	scalingRuleName5_ = scalingRuleName5;
-	setParameter("ScalingRuleName5", scalingRuleName5);
+	setCoreParameter("ScalingRuleName5", scalingRuleName5);
 }
 
 std::string DescribeScalingRulesRequest::getScalingGroupId()const
@@ -99,7 +99,7 @@ std::string DescribeScalingRulesRequest::getScalingGroupId()const
 void DescribeScalingRulesRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleName6()const
@@ -110,7 +110,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleName6()const
 void DescribeScalingRulesRequest::setScalingRuleName6(const std::string& scalingRuleName6)
 {
 	scalingRuleName6_ = scalingRuleName6;
-	setParameter("ScalingRuleName6", scalingRuleName6);
+	setCoreParameter("ScalingRuleName6", scalingRuleName6);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleName7()const
@@ -121,7 +121,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleName7()const
 void DescribeScalingRulesRequest::setScalingRuleName7(const std::string& scalingRuleName7)
 {
 	scalingRuleName7_ = scalingRuleName7;
-	setParameter("ScalingRuleName7", scalingRuleName7);
+	setCoreParameter("ScalingRuleName7", scalingRuleName7);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleName8()const
@@ -132,7 +132,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleName8()const
 void DescribeScalingRulesRequest::setScalingRuleName8(const std::string& scalingRuleName8)
 {
 	scalingRuleName8_ = scalingRuleName8;
-	setParameter("ScalingRuleName8", scalingRuleName8);
+	setCoreParameter("ScalingRuleName8", scalingRuleName8);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleAri9()const
@@ -143,7 +143,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleAri9()const
 void DescribeScalingRulesRequest::setScalingRuleAri9(const std::string& scalingRuleAri9)
 {
 	scalingRuleAri9_ = scalingRuleAri9;
-	setParameter("ScalingRuleAri9", scalingRuleAri9);
+	setCoreParameter("ScalingRuleAri9", scalingRuleAri9);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleName9()const
@@ -154,7 +154,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleName9()const
 void DescribeScalingRulesRequest::setScalingRuleName9(const std::string& scalingRuleName9)
 {
 	scalingRuleName9_ = scalingRuleName9;
-	setParameter("ScalingRuleName9", scalingRuleName9);
+	setCoreParameter("ScalingRuleName9", scalingRuleName9);
 }
 
 int DescribeScalingRulesRequest::getPageNumber()const
@@ -165,7 +165,7 @@ int DescribeScalingRulesRequest::getPageNumber()const
 void DescribeScalingRulesRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
+	setCoreParameter("PageNumber", std::to_string(pageNumber));
 }
 
 std::string DescribeScalingRulesRequest::getAccessKeyId()const
@@ -176,7 +176,7 @@ std::string DescribeScalingRulesRequest::getAccessKeyId()const
 void DescribeScalingRulesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeScalingRulesRequest::getRegionId()const
@@ -187,7 +187,7 @@ std::string DescribeScalingRulesRequest::getRegionId()const
 void DescribeScalingRulesRequest::setRegionId(const std::string& regionId)
 {
 	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+	setCoreParameter("RegionId", regionId);
 }
 
 int DescribeScalingRulesRequest::getPageSize()const
@@ -198,7 +198,18 @@ int DescribeScalingRulesRequest::getPageSize()const
 void DescribeScalingRulesRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+	setCoreParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string DescribeScalingRulesRequest::getScalingRuleType()const
+{
+	return scalingRuleType_;
+}
+
+void DescribeScalingRulesRequest::setScalingRuleType(const std::string& scalingRuleType)
+{
+	scalingRuleType_ = scalingRuleType;
+	setCoreParameter("ScalingRuleType", scalingRuleType);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleId10()const
@@ -209,7 +220,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleId10()const
 void DescribeScalingRulesRequest::setScalingRuleId10(const std::string& scalingRuleId10)
 {
 	scalingRuleId10_ = scalingRuleId10;
-	setParameter("ScalingRuleId10", scalingRuleId10);
+	setCoreParameter("ScalingRuleId10", scalingRuleId10);
 }
 
 std::string DescribeScalingRulesRequest::getResourceOwnerAccount()const
@@ -220,7 +231,7 @@ std::string DescribeScalingRulesRequest::getResourceOwnerAccount()const
 void DescribeScalingRulesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeScalingRulesRequest::getOwnerAccount()const
@@ -231,7 +242,7 @@ std::string DescribeScalingRulesRequest::getOwnerAccount()const
 void DescribeScalingRulesRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 long DescribeScalingRulesRequest::getOwnerId()const
@@ -242,7 +253,7 @@ long DescribeScalingRulesRequest::getOwnerId()const
 void DescribeScalingRulesRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleAri1()const
@@ -253,7 +264,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleAri1()const
 void DescribeScalingRulesRequest::setScalingRuleAri1(const std::string& scalingRuleAri1)
 {
 	scalingRuleAri1_ = scalingRuleAri1;
-	setParameter("ScalingRuleAri1", scalingRuleAri1);
+	setCoreParameter("ScalingRuleAri1", scalingRuleAri1);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleAri2()const
@@ -264,7 +275,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleAri2()const
 void DescribeScalingRulesRequest::setScalingRuleAri2(const std::string& scalingRuleAri2)
 {
 	scalingRuleAri2_ = scalingRuleAri2;
-	setParameter("ScalingRuleAri2", scalingRuleAri2);
+	setCoreParameter("ScalingRuleAri2", scalingRuleAri2);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleName10()const
@@ -275,7 +286,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleName10()const
 void DescribeScalingRulesRequest::setScalingRuleName10(const std::string& scalingRuleName10)
 {
 	scalingRuleName10_ = scalingRuleName10;
-	setParameter("ScalingRuleName10", scalingRuleName10);
+	setCoreParameter("ScalingRuleName10", scalingRuleName10);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleAri3()const
@@ -286,7 +297,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleAri3()const
 void DescribeScalingRulesRequest::setScalingRuleAri3(const std::string& scalingRuleAri3)
 {
 	scalingRuleAri3_ = scalingRuleAri3;
-	setParameter("ScalingRuleAri3", scalingRuleAri3);
+	setCoreParameter("ScalingRuleAri3", scalingRuleAri3);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleAri4()const
@@ -297,7 +308,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleAri4()const
 void DescribeScalingRulesRequest::setScalingRuleAri4(const std::string& scalingRuleAri4)
 {
 	scalingRuleAri4_ = scalingRuleAri4;
-	setParameter("ScalingRuleAri4", scalingRuleAri4);
+	setCoreParameter("ScalingRuleAri4", scalingRuleAri4);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleId8()const
@@ -308,7 +319,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleId8()const
 void DescribeScalingRulesRequest::setScalingRuleId8(const std::string& scalingRuleId8)
 {
 	scalingRuleId8_ = scalingRuleId8;
-	setParameter("ScalingRuleId8", scalingRuleId8);
+	setCoreParameter("ScalingRuleId8", scalingRuleId8);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleAri5()const
@@ -319,7 +330,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleAri5()const
 void DescribeScalingRulesRequest::setScalingRuleAri5(const std::string& scalingRuleAri5)
 {
 	scalingRuleAri5_ = scalingRuleAri5;
-	setParameter("ScalingRuleAri5", scalingRuleAri5);
+	setCoreParameter("ScalingRuleAri5", scalingRuleAri5);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleId9()const
@@ -330,7 +341,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleId9()const
 void DescribeScalingRulesRequest::setScalingRuleId9(const std::string& scalingRuleId9)
 {
 	scalingRuleId9_ = scalingRuleId9;
-	setParameter("ScalingRuleId9", scalingRuleId9);
+	setCoreParameter("ScalingRuleId9", scalingRuleId9);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleAri6()const
@@ -341,7 +352,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleAri6()const
 void DescribeScalingRulesRequest::setScalingRuleAri6(const std::string& scalingRuleAri6)
 {
 	scalingRuleAri6_ = scalingRuleAri6;
-	setParameter("ScalingRuleAri6", scalingRuleAri6);
+	setCoreParameter("ScalingRuleAri6", scalingRuleAri6);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleAri7()const
@@ -352,7 +363,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleAri7()const
 void DescribeScalingRulesRequest::setScalingRuleAri7(const std::string& scalingRuleAri7)
 {
 	scalingRuleAri7_ = scalingRuleAri7;
-	setParameter("ScalingRuleAri7", scalingRuleAri7);
+	setCoreParameter("ScalingRuleAri7", scalingRuleAri7);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleAri10()const
@@ -363,7 +374,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleAri10()const
 void DescribeScalingRulesRequest::setScalingRuleAri10(const std::string& scalingRuleAri10)
 {
 	scalingRuleAri10_ = scalingRuleAri10;
-	setParameter("ScalingRuleAri10", scalingRuleAri10);
+	setCoreParameter("ScalingRuleAri10", scalingRuleAri10);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleAri8()const
@@ -374,7 +385,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleAri8()const
 void DescribeScalingRulesRequest::setScalingRuleAri8(const std::string& scalingRuleAri8)
 {
 	scalingRuleAri8_ = scalingRuleAri8;
-	setParameter("ScalingRuleAri8", scalingRuleAri8);
+	setCoreParameter("ScalingRuleAri8", scalingRuleAri8);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleId4()const
@@ -385,7 +396,18 @@ std::string DescribeScalingRulesRequest::getScalingRuleId4()const
 void DescribeScalingRulesRequest::setScalingRuleId4(const std::string& scalingRuleId4)
 {
 	scalingRuleId4_ = scalingRuleId4;
-	setParameter("ScalingRuleId4", scalingRuleId4);
+	setCoreParameter("ScalingRuleId4", scalingRuleId4);
+}
+
+bool DescribeScalingRulesRequest::getShowAlarmRules()const
+{
+	return showAlarmRules_;
+}
+
+void DescribeScalingRulesRequest::setShowAlarmRules(bool showAlarmRules)
+{
+	showAlarmRules_ = showAlarmRules;
+	setCoreParameter("ShowAlarmRules", showAlarmRules ? "true" : "false");
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleId5()const
@@ -396,7 +418,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleId5()const
 void DescribeScalingRulesRequest::setScalingRuleId5(const std::string& scalingRuleId5)
 {
 	scalingRuleId5_ = scalingRuleId5;
-	setParameter("ScalingRuleId5", scalingRuleId5);
+	setCoreParameter("ScalingRuleId5", scalingRuleId5);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleId6()const
@@ -407,7 +429,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleId6()const
 void DescribeScalingRulesRequest::setScalingRuleId6(const std::string& scalingRuleId6)
 {
 	scalingRuleId6_ = scalingRuleId6;
-	setParameter("ScalingRuleId6", scalingRuleId6);
+	setCoreParameter("ScalingRuleId6", scalingRuleId6);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleId7()const
@@ -418,7 +440,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleId7()const
 void DescribeScalingRulesRequest::setScalingRuleId7(const std::string& scalingRuleId7)
 {
 	scalingRuleId7_ = scalingRuleId7;
-	setParameter("ScalingRuleId7", scalingRuleId7);
+	setCoreParameter("ScalingRuleId7", scalingRuleId7);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleId1()const
@@ -429,7 +451,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleId1()const
 void DescribeScalingRulesRequest::setScalingRuleId1(const std::string& scalingRuleId1)
 {
 	scalingRuleId1_ = scalingRuleId1;
-	setParameter("ScalingRuleId1", scalingRuleId1);
+	setCoreParameter("ScalingRuleId1", scalingRuleId1);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleId2()const
@@ -440,7 +462,7 @@ std::string DescribeScalingRulesRequest::getScalingRuleId2()const
 void DescribeScalingRulesRequest::setScalingRuleId2(const std::string& scalingRuleId2)
 {
 	scalingRuleId2_ = scalingRuleId2;
-	setParameter("ScalingRuleId2", scalingRuleId2);
+	setCoreParameter("ScalingRuleId2", scalingRuleId2);
 }
 
 std::string DescribeScalingRulesRequest::getScalingRuleId3()const
@@ -451,6 +473,6 @@ std::string DescribeScalingRulesRequest::getScalingRuleId3()const
 void DescribeScalingRulesRequest::setScalingRuleId3(const std::string& scalingRuleId3)
 {
 	scalingRuleId3_ = scalingRuleId3;
-	setParameter("ScalingRuleId3", scalingRuleId3);
+	setCoreParameter("ScalingRuleId3", scalingRuleId3);
 }
 

ess/src/model/DescribeScalingRulesResult.cc

@@ -52,6 +52,8 @@ void DescribeScalingRulesResult::parse(const std::string &payload)
 			scalingRulesObject.scalingRuleName = value["ScalingRuleName"].asString();
 		if(!value["Cooldown"].isNull())
 			scalingRulesObject.cooldown = std::stoi(value["Cooldown"].asString());
+		if(!value["MinAdjustmentMagnitude"].isNull())
+			scalingRulesObject.minAdjustmentMagnitude = std::stoi(value["MinAdjustmentMagnitude"].asString());
 		if(!value["AdjustmentType"].isNull())
 			scalingRulesObject.adjustmentType = value["AdjustmentType"].asString();
 		if(!value["AdjustmentValue"].isNull())
@@ -62,6 +64,38 @@ void DescribeScalingRulesResult::parse(const std::string &payload)
 			scalingRulesObject.maxSize = std::stoi(value["MaxSize"].asString());
 		if(!value["ScalingRuleAri"].isNull())
 			scalingRulesObject.scalingRuleAri = value["ScalingRuleAri"].asString();
+		if(!value["ScalingRuleType"].isNull())
+			scalingRulesObject.scalingRuleType = value["ScalingRuleType"].asString();
+		if(!value["EstimatedInstanceWarmup"].isNull())
+			scalingRulesObject.estimatedInstanceWarmup = std::stoi(value["EstimatedInstanceWarmup"].asString());
+		if(!value["MetricName"].isNull())
+			scalingRulesObject.metricName = value["MetricName"].asString();
+		if(!value["TargetValue"].isNull())
+			scalingRulesObject.targetValue = std::stof(value["TargetValue"].asString());
+		if(!value["DisableScaleIn"].isNull())
+			scalingRulesObject.disableScaleIn = value["DisableScaleIn"].asString() == "true";
+		auto allAlarms = value["Alarms"]["Alarm"];
+		for (auto value : allAlarms)
+		{
+			ScalingRule::Alarm alarmsObject;
+			if(!value["AlarmTaskName"].isNull())
+				alarmsObject.alarmTaskName = value["AlarmTaskName"].asString();
+			if(!value["AlarmTaskId"].isNull())
+				alarmsObject.alarmTaskId = value["AlarmTaskId"].asString();
+			scalingRulesObject.alarms.push_back(alarmsObject);
+		}
+		auto allStepAdjustments = value["StepAdjustments"]["StepAdjustment"];
+		for (auto value : allStepAdjustments)
+		{
+			ScalingRule::StepAdjustment stepAdjustmentsObject;
+			if(!value["MetricIntervalLowerBound"].isNull())
+				stepAdjustmentsObject.metricIntervalLowerBound = std::stof(value["MetricIntervalLowerBound"].asString());
+			if(!value["MetricIntervalUpperBound"].isNull())
+				stepAdjustmentsObject.metricIntervalUpperBound = std::stof(value["MetricIntervalUpperBound"].asString());
+			if(!value["ScalingAdjustment"].isNull())
+				stepAdjustmentsObject.scalingAdjustment = std::stoi(value["ScalingAdjustment"].asString());
+			scalingRulesObject.stepAdjustments.push_back(stepAdjustmentsObject);
+		}
 		scalingRules_.push_back(scalingRulesObject);
 	}
 	if(!value["TotalCount"].isNull())

ess/src/model/DescribeScheduledTasksRequest.cc

@@ -33,7 +33,7 @@ long DescribeScheduledTasksRequest::getResourceOwnerId()const
 void DescribeScheduledTasksRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledAction2()const
@@ -44,7 +44,7 @@ std::string DescribeScheduledTasksRequest::getScheduledAction2()const
 void DescribeScheduledTasksRequest::setScheduledAction2(const std::string& scheduledAction2)
 {
 	scheduledAction2_ = scheduledAction2;
-	setParameter("ScheduledAction2", scheduledAction2);
+	setCoreParameter("ScheduledAction2", scheduledAction2);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledAction1()const
@@ -55,7 +55,7 @@ std::string DescribeScheduledTasksRequest::getScheduledAction1()const
 void DescribeScheduledTasksRequest::setScheduledAction1(const std::string& scheduledAction1)
 {
 	scheduledAction1_ = scheduledAction1;
-	setParameter("ScheduledAction1", scheduledAction1);
+	setCoreParameter("ScheduledAction1", scheduledAction1);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledAction6()const
@@ -66,7 +66,7 @@ std::string DescribeScheduledTasksRequest::getScheduledAction6()const
 void DescribeScheduledTasksRequest::setScheduledAction6(const std::string& scheduledAction6)
 {
 	scheduledAction6_ = scheduledAction6;
-	setParameter("ScheduledAction6", scheduledAction6);
+	setCoreParameter("ScheduledAction6", scheduledAction6);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledAction5()const
@@ -77,7 +77,7 @@ std::string DescribeScheduledTasksRequest::getScheduledAction5()const
 void DescribeScheduledTasksRequest::setScheduledAction5(const std::string& scheduledAction5)
 {
 	scheduledAction5_ = scheduledAction5;
-	setParameter("ScheduledAction5", scheduledAction5);
+	setCoreParameter("ScheduledAction5", scheduledAction5);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledAction4()const
@@ -88,7 +88,7 @@ std::string DescribeScheduledTasksRequest::getScheduledAction4()const
 void DescribeScheduledTasksRequest::setScheduledAction4(const std::string& scheduledAction4)
 {
 	scheduledAction4_ = scheduledAction4;
-	setParameter("ScheduledAction4", scheduledAction4);
+	setCoreParameter("ScheduledAction4", scheduledAction4);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledAction3()const
@@ -99,7 +99,7 @@ std::string DescribeScheduledTasksRequest::getScheduledAction3()const
 void DescribeScheduledTasksRequest::setScheduledAction3(const std::string& scheduledAction3)
 {
 	scheduledAction3_ = scheduledAction3;
-	setParameter("ScheduledAction3", scheduledAction3);
+	setCoreParameter("ScheduledAction3", scheduledAction3);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledAction9()const
@@ -110,7 +110,7 @@ std::string DescribeScheduledTasksRequest::getScheduledAction9()const
 void DescribeScheduledTasksRequest::setScheduledAction9(const std::string& scheduledAction9)
 {
 	scheduledAction9_ = scheduledAction9;
-	setParameter("ScheduledAction9", scheduledAction9);
+	setCoreParameter("ScheduledAction9", scheduledAction9);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledAction8()const
@@ -121,7 +121,7 @@ std::string DescribeScheduledTasksRequest::getScheduledAction8()const
 void DescribeScheduledTasksRequest::setScheduledAction8(const std::string& scheduledAction8)
 {
 	scheduledAction8_ = scheduledAction8;
-	setParameter("ScheduledAction8", scheduledAction8);
+	setCoreParameter("ScheduledAction8", scheduledAction8);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledAction7()const
@@ -132,7 +132,7 @@ std::string DescribeScheduledTasksRequest::getScheduledAction7()const
 void DescribeScheduledTasksRequest::setScheduledAction7(const std::string& scheduledAction7)
 {
 	scheduledAction7_ = scheduledAction7;
-	setParameter("ScheduledAction7", scheduledAction7);
+	setCoreParameter("ScheduledAction7", scheduledAction7);
 }
 
 long DescribeScheduledTasksRequest::getOwnerId()const
@@ -143,7 +143,7 @@ long DescribeScheduledTasksRequest::getOwnerId()const
 void DescribeScheduledTasksRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskName20()const
@@ -154,7 +154,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskName20()const
 void DescribeScheduledTasksRequest::setScheduledTaskName20(const std::string& scheduledTaskName20)
 {
 	scheduledTaskName20_ = scheduledTaskName20;
-	setParameter("ScheduledTaskName20", scheduledTaskName20);
+	setCoreParameter("ScheduledTaskName20", scheduledTaskName20);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskName19()const
@@ -165,7 +165,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskName19()const
 void DescribeScheduledTasksRequest::setScheduledTaskName19(const std::string& scheduledTaskName19)
 {
 	scheduledTaskName19_ = scheduledTaskName19;
-	setParameter("ScheduledTaskName19", scheduledTaskName19);
+	setCoreParameter("ScheduledTaskName19", scheduledTaskName19);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskName18()const
@@ -176,7 +176,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskName18()const
 void DescribeScheduledTasksRequest::setScheduledTaskName18(const std::string& scheduledTaskName18)
 {
 	scheduledTaskName18_ = scheduledTaskName18;
-	setParameter("ScheduledTaskName18", scheduledTaskName18);
+	setCoreParameter("ScheduledTaskName18", scheduledTaskName18);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskId20()const
@@ -187,7 +187,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskId20()const
 void DescribeScheduledTasksRequest::setScheduledTaskId20(const std::string& scheduledTaskId20)
 {
 	scheduledTaskId20_ = scheduledTaskId20;
-	setParameter("ScheduledTaskId20", scheduledTaskId20);
+	setCoreParameter("ScheduledTaskId20", scheduledTaskId20);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskName13()const
@@ -198,7 +198,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskName13()const
 void DescribeScheduledTasksRequest::setScheduledTaskName13(const std::string& scheduledTaskName13)
 {
 	scheduledTaskName13_ = scheduledTaskName13;
-	setParameter("ScheduledTaskName13", scheduledTaskName13);
+	setCoreParameter("ScheduledTaskName13", scheduledTaskName13);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskName12()const
@@ -209,7 +209,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskName12()const
 void DescribeScheduledTasksRequest::setScheduledTaskName12(const std::string& scheduledTaskName12)
 {
 	scheduledTaskName12_ = scheduledTaskName12;
-	setParameter("ScheduledTaskName12", scheduledTaskName12);
+	setCoreParameter("ScheduledTaskName12", scheduledTaskName12);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskName11()const
@@ -220,7 +220,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskName11()const
 void DescribeScheduledTasksRequest::setScheduledTaskName11(const std::string& scheduledTaskName11)
 {
 	scheduledTaskName11_ = scheduledTaskName11;
-	setParameter("ScheduledTaskName11", scheduledTaskName11);
+	setCoreParameter("ScheduledTaskName11", scheduledTaskName11);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskName10()const
@@ -231,7 +231,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskName10()const
 void DescribeScheduledTasksRequest::setScheduledTaskName10(const std::string& scheduledTaskName10)
 {
 	scheduledTaskName10_ = scheduledTaskName10;
-	setParameter("ScheduledTaskName10", scheduledTaskName10);
+	setCoreParameter("ScheduledTaskName10", scheduledTaskName10);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskName17()const
@@ -242,7 +242,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskName17()const
 void DescribeScheduledTasksRequest::setScheduledTaskName17(const std::string& scheduledTaskName17)
 {
 	scheduledTaskName17_ = scheduledTaskName17;
-	setParameter("ScheduledTaskName17", scheduledTaskName17);
+	setCoreParameter("ScheduledTaskName17", scheduledTaskName17);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskName16()const
@@ -253,7 +253,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskName16()const
 void DescribeScheduledTasksRequest::setScheduledTaskName16(const std::string& scheduledTaskName16)
 {
 	scheduledTaskName16_ = scheduledTaskName16;
-	setParameter("ScheduledTaskName16", scheduledTaskName16);
+	setCoreParameter("ScheduledTaskName16", scheduledTaskName16);
 }
 
 int DescribeScheduledTasksRequest::getPageNumber()const
@@ -264,7 +264,7 @@ int DescribeScheduledTasksRequest::getPageNumber()const
 void DescribeScheduledTasksRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
+	setCoreParameter("PageNumber", std::to_string(pageNumber));
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskName15()const
@@ -275,7 +275,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskName15()const
 void DescribeScheduledTasksRequest::setScheduledTaskName15(const std::string& scheduledTaskName15)
 {
 	scheduledTaskName15_ = scheduledTaskName15;
-	setParameter("ScheduledTaskName15", scheduledTaskName15);
+	setCoreParameter("ScheduledTaskName15", scheduledTaskName15);
 }
 
 std::string DescribeScheduledTasksRequest::getAccessKeyId()const
@@ -286,7 +286,7 @@ std::string DescribeScheduledTasksRequest::getAccessKeyId()const
 void DescribeScheduledTasksRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskName14()const
@@ -297,7 +297,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskName14()const
 void DescribeScheduledTasksRequest::setScheduledTaskName14(const std::string& scheduledTaskName14)
 {
 	scheduledTaskName14_ = scheduledTaskName14;
-	setParameter("ScheduledTaskName14", scheduledTaskName14);
+	setCoreParameter("ScheduledTaskName14", scheduledTaskName14);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskId2()const
@@ -308,7 +308,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskId2()const
 void DescribeScheduledTasksRequest::setScheduledTaskId2(const std::string& scheduledTaskId2)
 {
 	scheduledTaskId2_ = scheduledTaskId2;
-	setParameter("ScheduledTaskId2", scheduledTaskId2);
+	setCoreParameter("ScheduledTaskId2", scheduledTaskId2);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskId1()const
@@ -319,7 +319,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskId1()const
 void DescribeScheduledTasksRequest::setScheduledTaskId1(const std::string& scheduledTaskId1)
 {
 	scheduledTaskId1_ = scheduledTaskId1;
-	setParameter("ScheduledTaskId1", scheduledTaskId1);
+	setCoreParameter("ScheduledTaskId1", scheduledTaskId1);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskId4()const
@@ -330,7 +330,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskId4()const
 void DescribeScheduledTasksRequest::setScheduledTaskId4(const std::string& scheduledTaskId4)
 {
 	scheduledTaskId4_ = scheduledTaskId4;
-	setParameter("ScheduledTaskId4", scheduledTaskId4);
+	setCoreParameter("ScheduledTaskId4", scheduledTaskId4);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskId18()const
@@ -341,7 +341,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskId18()const
 void DescribeScheduledTasksRequest::setScheduledTaskId18(const std::string& scheduledTaskId18)
 {
 	scheduledTaskId18_ = scheduledTaskId18;
-	setParameter("ScheduledTaskId18", scheduledTaskId18);
+	setCoreParameter("ScheduledTaskId18", scheduledTaskId18);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskId3()const
@@ -352,7 +352,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskId3()const
 void DescribeScheduledTasksRequest::setScheduledTaskId3(const std::string& scheduledTaskId3)
 {
 	scheduledTaskId3_ = scheduledTaskId3;
-	setParameter("ScheduledTaskId3", scheduledTaskId3);
+	setCoreParameter("ScheduledTaskId3", scheduledTaskId3);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskId19()const
@@ -363,7 +363,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskId19()const
 void DescribeScheduledTasksRequest::setScheduledTaskId19(const std::string& scheduledTaskId19)
 {
 	scheduledTaskId19_ = scheduledTaskId19;
-	setParameter("ScheduledTaskId19", scheduledTaskId19);
+	setCoreParameter("ScheduledTaskId19", scheduledTaskId19);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskId6()const
@@ -374,7 +374,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskId6()const
 void DescribeScheduledTasksRequest::setScheduledTaskId6(const std::string& scheduledTaskId6)
 {
 	scheduledTaskId6_ = scheduledTaskId6;
-	setParameter("ScheduledTaskId6", scheduledTaskId6);
+	setCoreParameter("ScheduledTaskId6", scheduledTaskId6);
 }
 
 std::string DescribeScheduledTasksRequest::getRegionId()const
@@ -385,7 +385,7 @@ std::string DescribeScheduledTasksRequest::getRegionId()const
 void DescribeScheduledTasksRequest::setRegionId(const std::string& regionId)
 {
 	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+	setCoreParameter("RegionId", regionId);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskId5()const
@@ -396,7 +396,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskId5()const
 void DescribeScheduledTasksRequest::setScheduledTaskId5(const std::string& scheduledTaskId5)
 {
 	scheduledTaskId5_ = scheduledTaskId5;
-	setParameter("ScheduledTaskId5", scheduledTaskId5);
+	setCoreParameter("ScheduledTaskId5", scheduledTaskId5);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskId8()const
@@ -407,7 +407,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskId8()const
 void DescribeScheduledTasksRequest::setScheduledTaskId8(const std::string& scheduledTaskId8)
 {
 	scheduledTaskId8_ = scheduledTaskId8;
-	setParameter("ScheduledTaskId8", scheduledTaskId8);
+	setCoreParameter("ScheduledTaskId8", scheduledTaskId8);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskName9()const
@@ -418,7 +418,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskName9()const
 void DescribeScheduledTasksRequest::setScheduledTaskName9(const std::string& scheduledTaskName9)
 {
 	scheduledTaskName9_ = scheduledTaskName9;
-	setParameter("ScheduledTaskName9", scheduledTaskName9);
+	setCoreParameter("ScheduledTaskName9", scheduledTaskName9);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledAction20()const
@@ -429,7 +429,7 @@ std::string DescribeScheduledTasksRequest::getScheduledAction20()const
 void DescribeScheduledTasksRequest::setScheduledAction20(const std::string& scheduledAction20)
 {
 	scheduledAction20_ = scheduledAction20;
-	setParameter("ScheduledAction20", scheduledAction20);
+	setCoreParameter("ScheduledAction20", scheduledAction20);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskId7()const
@@ -440,7 +440,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskId7()const
 void DescribeScheduledTasksRequest::setScheduledTaskId7(const std::string& scheduledTaskId7)
 {
 	scheduledTaskId7_ = scheduledTaskId7;
-	setParameter("ScheduledTaskId7", scheduledTaskId7);
+	setCoreParameter("ScheduledTaskId7", scheduledTaskId7);
 }
 
 int DescribeScheduledTasksRequest::getPageSize()const
@@ -451,7 +451,7 @@ int DescribeScheduledTasksRequest::getPageSize()const
 void DescribeScheduledTasksRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+	setCoreParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskId12()const
@@ -462,7 +462,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskId12()const
 void DescribeScheduledTasksRequest::setScheduledTaskId12(const std::string& scheduledTaskId12)
 {
 	scheduledTaskId12_ = scheduledTaskId12;
-	setParameter("ScheduledTaskId12", scheduledTaskId12);
+	setCoreParameter("ScheduledTaskId12", scheduledTaskId12);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskName7()const
@@ -473,7 +473,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskName7()const
 void DescribeScheduledTasksRequest::setScheduledTaskName7(const std::string& scheduledTaskName7)
 {
 	scheduledTaskName7_ = scheduledTaskName7;
-	setParameter("ScheduledTaskName7", scheduledTaskName7);
+	setCoreParameter("ScheduledTaskName7", scheduledTaskName7);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskId9()const
@@ -484,7 +484,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskId9()const
 void DescribeScheduledTasksRequest::setScheduledTaskId9(const std::string& scheduledTaskId9)
 {
 	scheduledTaskId9_ = scheduledTaskId9;
-	setParameter("ScheduledTaskId9", scheduledTaskId9);
+	setCoreParameter("ScheduledTaskId9", scheduledTaskId9);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskId13()const
@@ -495,7 +495,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskId13()const
 void DescribeScheduledTasksRequest::setScheduledTaskId13(const std::string& scheduledTaskId13)
 {
 	scheduledTaskId13_ = scheduledTaskId13;
-	setParameter("ScheduledTaskId13", scheduledTaskId13);
+	setCoreParameter("ScheduledTaskId13", scheduledTaskId13);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskName8()const
@@ -506,7 +506,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskName8()const
 void DescribeScheduledTasksRequest::setScheduledTaskName8(const std::string& scheduledTaskName8)
 {
 	scheduledTaskName8_ = scheduledTaskName8;
-	setParameter("ScheduledTaskName8", scheduledTaskName8);
+	setCoreParameter("ScheduledTaskName8", scheduledTaskName8);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskId10()const
@@ -517,7 +517,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskId10()const
 void DescribeScheduledTasksRequest::setScheduledTaskId10(const std::string& scheduledTaskId10)
 {
 	scheduledTaskId10_ = scheduledTaskId10;
-	setParameter("ScheduledTaskId10", scheduledTaskId10);
+	setCoreParameter("ScheduledTaskId10", scheduledTaskId10);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskName5()const
@@ -528,7 +528,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskName5()const
 void DescribeScheduledTasksRequest::setScheduledTaskName5(const std::string& scheduledTaskName5)
 {
 	scheduledTaskName5_ = scheduledTaskName5;
-	setParameter("ScheduledTaskName5", scheduledTaskName5);
+	setCoreParameter("ScheduledTaskName5", scheduledTaskName5);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskId11()const
@@ -539,7 +539,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskId11()const
 void DescribeScheduledTasksRequest::setScheduledTaskId11(const std::string& scheduledTaskId11)
 {
 	scheduledTaskId11_ = scheduledTaskId11;
-	setParameter("ScheduledTaskId11", scheduledTaskId11);
+	setCoreParameter("ScheduledTaskId11", scheduledTaskId11);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskName6()const
@@ -550,7 +550,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskName6()const
 void DescribeScheduledTasksRequest::setScheduledTaskName6(const std::string& scheduledTaskName6)
 {
 	scheduledTaskName6_ = scheduledTaskName6;
-	setParameter("ScheduledTaskName6", scheduledTaskName6);
+	setCoreParameter("ScheduledTaskName6", scheduledTaskName6);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskId16()const
@@ -561,7 +561,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskId16()const
 void DescribeScheduledTasksRequest::setScheduledTaskId16(const std::string& scheduledTaskId16)
 {
 	scheduledTaskId16_ = scheduledTaskId16;
-	setParameter("ScheduledTaskId16", scheduledTaskId16);
+	setCoreParameter("ScheduledTaskId16", scheduledTaskId16);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskName3()const
@@ -572,7 +572,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskName3()const
 void DescribeScheduledTasksRequest::setScheduledTaskName3(const std::string& scheduledTaskName3)
 {
 	scheduledTaskName3_ = scheduledTaskName3;
-	setParameter("ScheduledTaskName3", scheduledTaskName3);
+	setCoreParameter("ScheduledTaskName3", scheduledTaskName3);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskId17()const
@@ -583,7 +583,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskId17()const
 void DescribeScheduledTasksRequest::setScheduledTaskId17(const std::string& scheduledTaskId17)
 {
 	scheduledTaskId17_ = scheduledTaskId17;
-	setParameter("ScheduledTaskId17", scheduledTaskId17);
+	setCoreParameter("ScheduledTaskId17", scheduledTaskId17);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskName4()const
@@ -594,7 +594,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskName4()const
 void DescribeScheduledTasksRequest::setScheduledTaskName4(const std::string& scheduledTaskName4)
 {
 	scheduledTaskName4_ = scheduledTaskName4;
-	setParameter("ScheduledTaskName4", scheduledTaskName4);
+	setCoreParameter("ScheduledTaskName4", scheduledTaskName4);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskId14()const
@@ -605,7 +605,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskId14()const
 void DescribeScheduledTasksRequest::setScheduledTaskId14(const std::string& scheduledTaskId14)
 {
 	scheduledTaskId14_ = scheduledTaskId14;
-	setParameter("ScheduledTaskId14", scheduledTaskId14);
+	setCoreParameter("ScheduledTaskId14", scheduledTaskId14);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskName1()const
@@ -616,7 +616,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskName1()const
 void DescribeScheduledTasksRequest::setScheduledTaskName1(const std::string& scheduledTaskName1)
 {
 	scheduledTaskName1_ = scheduledTaskName1;
-	setParameter("ScheduledTaskName1", scheduledTaskName1);
+	setCoreParameter("ScheduledTaskName1", scheduledTaskName1);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskId15()const
@@ -627,7 +627,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskId15()const
 void DescribeScheduledTasksRequest::setScheduledTaskId15(const std::string& scheduledTaskId15)
 {
 	scheduledTaskId15_ = scheduledTaskId15;
-	setParameter("ScheduledTaskId15", scheduledTaskId15);
+	setCoreParameter("ScheduledTaskId15", scheduledTaskId15);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledTaskName2()const
@@ -638,7 +638,7 @@ std::string DescribeScheduledTasksRequest::getScheduledTaskName2()const
 void DescribeScheduledTasksRequest::setScheduledTaskName2(const std::string& scheduledTaskName2)
 {
 	scheduledTaskName2_ = scheduledTaskName2;
-	setParameter("ScheduledTaskName2", scheduledTaskName2);
+	setCoreParameter("ScheduledTaskName2", scheduledTaskName2);
 }
 
 std::string DescribeScheduledTasksRequest::getResourceOwnerAccount()const
@@ -649,7 +649,7 @@ std::string DescribeScheduledTasksRequest::getResourceOwnerAccount()const
 void DescribeScheduledTasksRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DescribeScheduledTasksRequest::getOwnerAccount()const
@@ -660,7 +660,7 @@ std::string DescribeScheduledTasksRequest::getOwnerAccount()const
 void DescribeScheduledTasksRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledAction18()const
@@ -671,7 +671,7 @@ std::string DescribeScheduledTasksRequest::getScheduledAction18()const
 void DescribeScheduledTasksRequest::setScheduledAction18(const std::string& scheduledAction18)
 {
 	scheduledAction18_ = scheduledAction18;
-	setParameter("ScheduledAction18", scheduledAction18);
+	setCoreParameter("ScheduledAction18", scheduledAction18);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledAction19()const
@@ -682,7 +682,7 @@ std::string DescribeScheduledTasksRequest::getScheduledAction19()const
 void DescribeScheduledTasksRequest::setScheduledAction19(const std::string& scheduledAction19)
 {
 	scheduledAction19_ = scheduledAction19;
-	setParameter("ScheduledAction19", scheduledAction19);
+	setCoreParameter("ScheduledAction19", scheduledAction19);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledAction16()const
@@ -693,7 +693,7 @@ std::string DescribeScheduledTasksRequest::getScheduledAction16()const
 void DescribeScheduledTasksRequest::setScheduledAction16(const std::string& scheduledAction16)
 {
 	scheduledAction16_ = scheduledAction16;
-	setParameter("ScheduledAction16", scheduledAction16);
+	setCoreParameter("ScheduledAction16", scheduledAction16);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledAction17()const
@@ -704,7 +704,7 @@ std::string DescribeScheduledTasksRequest::getScheduledAction17()const
 void DescribeScheduledTasksRequest::setScheduledAction17(const std::string& scheduledAction17)
 {
 	scheduledAction17_ = scheduledAction17;
-	setParameter("ScheduledAction17", scheduledAction17);
+	setCoreParameter("ScheduledAction17", scheduledAction17);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledAction14()const
@@ -715,7 +715,7 @@ std::string DescribeScheduledTasksRequest::getScheduledAction14()const
 void DescribeScheduledTasksRequest::setScheduledAction14(const std::string& scheduledAction14)
 {
 	scheduledAction14_ = scheduledAction14;
-	setParameter("ScheduledAction14", scheduledAction14);
+	setCoreParameter("ScheduledAction14", scheduledAction14);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledAction15()const
@@ -726,7 +726,7 @@ std::string DescribeScheduledTasksRequest::getScheduledAction15()const
 void DescribeScheduledTasksRequest::setScheduledAction15(const std::string& scheduledAction15)
 {
 	scheduledAction15_ = scheduledAction15;
-	setParameter("ScheduledAction15", scheduledAction15);
+	setCoreParameter("ScheduledAction15", scheduledAction15);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledAction12()const
@@ -737,7 +737,7 @@ std::string DescribeScheduledTasksRequest::getScheduledAction12()const
 void DescribeScheduledTasksRequest::setScheduledAction12(const std::string& scheduledAction12)
 {
 	scheduledAction12_ = scheduledAction12;
-	setParameter("ScheduledAction12", scheduledAction12);
+	setCoreParameter("ScheduledAction12", scheduledAction12);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledAction13()const
@@ -748,7 +748,7 @@ std::string DescribeScheduledTasksRequest::getScheduledAction13()const
 void DescribeScheduledTasksRequest::setScheduledAction13(const std::string& scheduledAction13)
 {
 	scheduledAction13_ = scheduledAction13;
-	setParameter("ScheduledAction13", scheduledAction13);
+	setCoreParameter("ScheduledAction13", scheduledAction13);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledAction10()const
@@ -759,7 +759,7 @@ std::string DescribeScheduledTasksRequest::getScheduledAction10()const
 void DescribeScheduledTasksRequest::setScheduledAction10(const std::string& scheduledAction10)
 {
 	scheduledAction10_ = scheduledAction10;
-	setParameter("ScheduledAction10", scheduledAction10);
+	setCoreParameter("ScheduledAction10", scheduledAction10);
 }
 
 std::string DescribeScheduledTasksRequest::getScheduledAction11()const
@@ -770,6 +770,6 @@ std::string DescribeScheduledTasksRequest::getScheduledAction11()const
 void DescribeScheduledTasksRequest::setScheduledAction11(const std::string& scheduledAction11)
 {
 	scheduledAction11_ = scheduledAction11;
-	setParameter("ScheduledAction11", scheduledAction11);
+	setCoreParameter("ScheduledAction11", scheduledAction11);
 }
 

ess/src/model/DetachDBInstancesRequest.cc

@@ -33,7 +33,7 @@ std::string DetachDBInstancesRequest::getResourceOwnerAccount()const
 void DetachDBInstancesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DetachDBInstancesRequest::getScalingGroupId()const
@@ -44,7 +44,7 @@ std::string DetachDBInstancesRequest::getScalingGroupId()const
 void DetachDBInstancesRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 std::vector<std::string> DetachDBInstancesRequest::getDBInstance()const
@@ -56,7 +56,7 @@ void DetachDBInstancesRequest::setDBInstance(const std::vector<std::string>& dBI
 {
 	dBInstance_ = dBInstance;
 	for(int i = 0; i!= dBInstance.size(); i++)
-		setParameter("DBInstance."+ std::to_string(i), dBInstance.at(i));
+		setCoreParameter("DBInstance."+ std::to_string(i), dBInstance.at(i));
 }
 
 bool DetachDBInstancesRequest::getForceDetach()const
@@ -67,7 +67,7 @@ bool DetachDBInstancesRequest::getForceDetach()const
 void DetachDBInstancesRequest::setForceDetach(bool forceDetach)
 {
 	forceDetach_ = forceDetach;
-	setParameter("ForceDetach", std::to_string(forceDetach));
+	setCoreParameter("ForceDetach", forceDetach ? "true" : "false");
 }
 
 long DetachDBInstancesRequest::getOwnerId()const
@@ -78,7 +78,7 @@ long DetachDBInstancesRequest::getOwnerId()const
 void DetachDBInstancesRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DetachDBInstancesRequest::getAccessKeyId()const
@@ -89,6 +89,6 @@ std::string DetachDBInstancesRequest::getAccessKeyId()const
 void DetachDBInstancesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DetachInstancesRequest.cc

@@ -33,7 +33,7 @@ long DetachInstancesRequest::getResourceOwnerId()const
 void DetachInstancesRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::vector<std::string> DetachInstancesRequest::getInstanceId()const
@@ -45,7 +45,7 @@ void DetachInstancesRequest::setInstanceId(const std::vector<std::string>& insta
 {
 	instanceId_ = instanceId;
 	for(int i = 0; i!= instanceId.size(); i++)
-		setParameter("InstanceId."+ std::to_string(i), instanceId.at(i));
+		setCoreParameter("InstanceId."+ std::to_string(i), instanceId.at(i));
 }
 
 std::string DetachInstancesRequest::getResourceOwnerAccount()const
@@ -56,7 +56,7 @@ std::string DetachInstancesRequest::getResourceOwnerAccount()const
 void DetachInstancesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DetachInstancesRequest::getScalingGroupId()const
@@ -67,7 +67,7 @@ std::string DetachInstancesRequest::getScalingGroupId()const
 void DetachInstancesRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 std::string DetachInstancesRequest::getOwnerAccount()const
@@ -78,7 +78,7 @@ std::string DetachInstancesRequest::getOwnerAccount()const
 void DetachInstancesRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 long DetachInstancesRequest::getOwnerId()const
@@ -89,7 +89,7 @@ long DetachInstancesRequest::getOwnerId()const
 void DetachInstancesRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DetachInstancesRequest::getAccessKeyId()const
@@ -100,6 +100,6 @@ std::string DetachInstancesRequest::getAccessKeyId()const
 void DetachInstancesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DetachLoadBalancersRequest.cc

@@ -34,7 +34,7 @@ void DetachLoadBalancersRequest::setLoadBalancer(const std::vector<std::string>&
 {
 	loadBalancer_ = loadBalancer;
 	for(int i = 0; i!= loadBalancer.size(); i++)
-		setParameter("LoadBalancer."+ std::to_string(i), loadBalancer.at(i));
+		setCoreParameter("LoadBalancer."+ std::to_string(i), loadBalancer.at(i));
 }
 
 std::string DetachLoadBalancersRequest::getResourceOwnerAccount()const
@@ -45,7 +45,7 @@ std::string DetachLoadBalancersRequest::getResourceOwnerAccount()const
 void DetachLoadBalancersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DetachLoadBalancersRequest::getScalingGroupId()const
@@ -56,7 +56,7 @@ std::string DetachLoadBalancersRequest::getScalingGroupId()const
 void DetachLoadBalancersRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 bool DetachLoadBalancersRequest::getForceDetach()const
@@ -67,7 +67,7 @@ bool DetachLoadBalancersRequest::getForceDetach()const
 void DetachLoadBalancersRequest::setForceDetach(bool forceDetach)
 {
 	forceDetach_ = forceDetach;
-	setParameter("ForceDetach", std::to_string(forceDetach));
+	setCoreParameter("ForceDetach", forceDetach ? "true" : "false");
 }
 
 long DetachLoadBalancersRequest::getOwnerId()const
@@ -78,7 +78,7 @@ long DetachLoadBalancersRequest::getOwnerId()const
 void DetachLoadBalancersRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DetachLoadBalancersRequest::getAccessKeyId()const
@@ -89,6 +89,6 @@ std::string DetachLoadBalancersRequest::getAccessKeyId()const
 void DetachLoadBalancersRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DetachVServerGroupsRequest.cc

@@ -0,0 +1,110 @@
+/*
+ * 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/DetachVServerGroupsRequest.h>
+
+using AlibabaCloud::Ess::Model::DetachVServerGroupsRequest;
+
+DetachVServerGroupsRequest::DetachVServerGroupsRequest() :
+	RpcServiceRequest("ess", "2014-08-28", "DetachVServerGroups")
+{}
+
+DetachVServerGroupsRequest::~DetachVServerGroupsRequest()
+{}
+
+std::string DetachVServerGroupsRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DetachVServerGroupsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DetachVServerGroupsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DetachVServerGroupsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string DetachVServerGroupsRequest::getScalingGroupId()const
+{
+	return scalingGroupId_;
+}
+
+void DetachVServerGroupsRequest::setScalingGroupId(const std::string& scalingGroupId)
+{
+	scalingGroupId_ = scalingGroupId;
+	setCoreParameter("ScalingGroupId", scalingGroupId);
+}
+
+bool DetachVServerGroupsRequest::getForceDetach()const
+{
+	return forceDetach_;
+}
+
+void DetachVServerGroupsRequest::setForceDetach(bool forceDetach)
+{
+	forceDetach_ = forceDetach;
+	setCoreParameter("ForceDetach", forceDetach ? "true" : "false");
+}
+
+long DetachVServerGroupsRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DetachVServerGroupsRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setCoreParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::vector<DetachVServerGroupsRequest::VServerGroup> DetachVServerGroupsRequest::getVServerGroup()const
+{
+	return vServerGroup_;
+}
+
+void DetachVServerGroupsRequest::setVServerGroup(const std::vector<VServerGroup>& vServerGroup)
+{
+	vServerGroup_ = vServerGroup;
+	int i = 0;
+	for(int i = 0; i!= vServerGroup.size(); i++)	{
+		auto obj = vServerGroup.at(i);
+		std::string str ="VServerGroup."+ std::to_string(i);
+		setCoreParameter(str + ".LoadBalancerId", obj.loadBalancerId);
+		setCoreParameter(str + ".VServerGroupAttribute", std::to_string(obj.vServerGroupAttribute));
+	}
+}
+
+std::string DetachVServerGroupsRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DetachVServerGroupsRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setCoreParameter("AccessKeyId", accessKeyId);
+}
+

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

ess/src/model/DisableAlarmRequest.cc

@@ -33,7 +33,7 @@ std::string DisableAlarmRequest::getResourceOwnerAccount()const
 void DisableAlarmRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DisableAlarmRequest::getRegionId()const
@@ -44,7 +44,7 @@ std::string DisableAlarmRequest::getRegionId()const
 void DisableAlarmRequest::setRegionId(const std::string& regionId)
 {
 	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+	setCoreParameter("RegionId", regionId);
 }
 
 long DisableAlarmRequest::getOwnerId()const
@@ -55,7 +55,7 @@ long DisableAlarmRequest::getOwnerId()const
 void DisableAlarmRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DisableAlarmRequest::getAlarmTaskId()const
@@ -66,7 +66,7 @@ std::string DisableAlarmRequest::getAlarmTaskId()const
 void DisableAlarmRequest::setAlarmTaskId(const std::string& alarmTaskId)
 {
 	alarmTaskId_ = alarmTaskId;
-	setParameter("AlarmTaskId", alarmTaskId);
+	setCoreParameter("AlarmTaskId", alarmTaskId);
 }
 
 std::string DisableAlarmRequest::getAccessKeyId()const
@@ -77,6 +77,6 @@ std::string DisableAlarmRequest::getAccessKeyId()const
 void DisableAlarmRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/DisableScalingGroupRequest.cc

@@ -33,7 +33,7 @@ long DisableScalingGroupRequest::getResourceOwnerId()const
 void DisableScalingGroupRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string DisableScalingGroupRequest::getResourceOwnerAccount()const
@@ -44,7 +44,7 @@ std::string DisableScalingGroupRequest::getResourceOwnerAccount()const
 void DisableScalingGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string DisableScalingGroupRequest::getScalingGroupId()const
@@ -55,7 +55,7 @@ std::string DisableScalingGroupRequest::getScalingGroupId()const
 void DisableScalingGroupRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 std::string DisableScalingGroupRequest::getOwnerAccount()const
@@ -66,7 +66,7 @@ std::string DisableScalingGroupRequest::getOwnerAccount()const
 void DisableScalingGroupRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 long DisableScalingGroupRequest::getOwnerId()const
@@ -77,7 +77,7 @@ long DisableScalingGroupRequest::getOwnerId()const
 void DisableScalingGroupRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DisableScalingGroupRequest::getAccessKeyId()const
@@ -88,6 +88,6 @@ std::string DisableScalingGroupRequest::getAccessKeyId()const
 void DisableScalingGroupRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/EnableAlarmRequest.cc

@@ -33,7 +33,7 @@ std::string EnableAlarmRequest::getResourceOwnerAccount()const
 void EnableAlarmRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string EnableAlarmRequest::getRegionId()const
@@ -44,7 +44,7 @@ std::string EnableAlarmRequest::getRegionId()const
 void EnableAlarmRequest::setRegionId(const std::string& regionId)
 {
 	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+	setCoreParameter("RegionId", regionId);
 }
 
 long EnableAlarmRequest::getOwnerId()const
@@ -55,7 +55,7 @@ long EnableAlarmRequest::getOwnerId()const
 void EnableAlarmRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string EnableAlarmRequest::getAlarmTaskId()const
@@ -66,7 +66,7 @@ std::string EnableAlarmRequest::getAlarmTaskId()const
 void EnableAlarmRequest::setAlarmTaskId(const std::string& alarmTaskId)
 {
 	alarmTaskId_ = alarmTaskId;
-	setParameter("AlarmTaskId", alarmTaskId);
+	setCoreParameter("AlarmTaskId", alarmTaskId);
 }
 
 std::string EnableAlarmRequest::getAccessKeyId()const
@@ -77,6 +77,6 @@ std::string EnableAlarmRequest::getAccessKeyId()const
 void EnableAlarmRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/EnableScalingGroupRequest.cc

@@ -33,7 +33,7 @@ int EnableScalingGroupRequest::getLoadBalancerWeight6()const
 void EnableScalingGroupRequest::setLoadBalancerWeight6(int loadBalancerWeight6)
 {
 	loadBalancerWeight6_ = loadBalancerWeight6;
-	setParameter("LoadBalancerWeight6", std::to_string(loadBalancerWeight6));
+	setCoreParameter("LoadBalancerWeight6", std::to_string(loadBalancerWeight6));
 }
 
 int EnableScalingGroupRequest::getLoadBalancerWeight11()const
@@ -44,7 +44,7 @@ int EnableScalingGroupRequest::getLoadBalancerWeight11()const
 void EnableScalingGroupRequest::setLoadBalancerWeight11(int loadBalancerWeight11)
 {
 	loadBalancerWeight11_ = loadBalancerWeight11;
-	setParameter("LoadBalancerWeight11", std::to_string(loadBalancerWeight11));
+	setCoreParameter("LoadBalancerWeight11", std::to_string(loadBalancerWeight11));
 }
 
 int EnableScalingGroupRequest::getLoadBalancerWeight7()const
@@ -55,7 +55,7 @@ int EnableScalingGroupRequest::getLoadBalancerWeight7()const
 void EnableScalingGroupRequest::setLoadBalancerWeight7(int loadBalancerWeight7)
 {
 	loadBalancerWeight7_ = loadBalancerWeight7;
-	setParameter("LoadBalancerWeight7", std::to_string(loadBalancerWeight7));
+	setCoreParameter("LoadBalancerWeight7", std::to_string(loadBalancerWeight7));
 }
 
 int EnableScalingGroupRequest::getLoadBalancerWeight12()const
@@ -66,7 +66,7 @@ int EnableScalingGroupRequest::getLoadBalancerWeight12()const
 void EnableScalingGroupRequest::setLoadBalancerWeight12(int loadBalancerWeight12)
 {
 	loadBalancerWeight12_ = loadBalancerWeight12;
-	setParameter("LoadBalancerWeight12", std::to_string(loadBalancerWeight12));
+	setCoreParameter("LoadBalancerWeight12", std::to_string(loadBalancerWeight12));
 }
 
 long EnableScalingGroupRequest::getResourceOwnerId()const
@@ -77,7 +77,7 @@ long EnableScalingGroupRequest::getResourceOwnerId()const
 void EnableScalingGroupRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 int EnableScalingGroupRequest::getLoadBalancerWeight8()const
@@ -88,7 +88,7 @@ int EnableScalingGroupRequest::getLoadBalancerWeight8()const
 void EnableScalingGroupRequest::setLoadBalancerWeight8(int loadBalancerWeight8)
 {
 	loadBalancerWeight8_ = loadBalancerWeight8;
-	setParameter("LoadBalancerWeight8", std::to_string(loadBalancerWeight8));
+	setCoreParameter("LoadBalancerWeight8", std::to_string(loadBalancerWeight8));
 }
 
 int EnableScalingGroupRequest::getLoadBalancerWeight9()const
@@ -99,7 +99,7 @@ int EnableScalingGroupRequest::getLoadBalancerWeight9()const
 void EnableScalingGroupRequest::setLoadBalancerWeight9(int loadBalancerWeight9)
 {
 	loadBalancerWeight9_ = loadBalancerWeight9;
-	setParameter("LoadBalancerWeight9", std::to_string(loadBalancerWeight9));
+	setCoreParameter("LoadBalancerWeight9", std::to_string(loadBalancerWeight9));
 }
 
 int EnableScalingGroupRequest::getLoadBalancerWeight10()const
@@ -110,7 +110,7 @@ int EnableScalingGroupRequest::getLoadBalancerWeight10()const
 void EnableScalingGroupRequest::setLoadBalancerWeight10(int loadBalancerWeight10)
 {
 	loadBalancerWeight10_ = loadBalancerWeight10;
-	setParameter("LoadBalancerWeight10", std::to_string(loadBalancerWeight10));
+	setCoreParameter("LoadBalancerWeight10", std::to_string(loadBalancerWeight10));
 }
 
 int EnableScalingGroupRequest::getLoadBalancerWeight2()const
@@ -121,7 +121,7 @@ int EnableScalingGroupRequest::getLoadBalancerWeight2()const
 void EnableScalingGroupRequest::setLoadBalancerWeight2(int loadBalancerWeight2)
 {
 	loadBalancerWeight2_ = loadBalancerWeight2;
-	setParameter("LoadBalancerWeight2", std::to_string(loadBalancerWeight2));
+	setCoreParameter("LoadBalancerWeight2", std::to_string(loadBalancerWeight2));
 }
 
 int EnableScalingGroupRequest::getLoadBalancerWeight15()const
@@ -132,7 +132,7 @@ int EnableScalingGroupRequest::getLoadBalancerWeight15()const
 void EnableScalingGroupRequest::setLoadBalancerWeight15(int loadBalancerWeight15)
 {
 	loadBalancerWeight15_ = loadBalancerWeight15;
-	setParameter("LoadBalancerWeight15", std::to_string(loadBalancerWeight15));
+	setCoreParameter("LoadBalancerWeight15", std::to_string(loadBalancerWeight15));
 }
 
 int EnableScalingGroupRequest::getLoadBalancerWeight3()const
@@ -143,7 +143,7 @@ int EnableScalingGroupRequest::getLoadBalancerWeight3()const
 void EnableScalingGroupRequest::setLoadBalancerWeight3(int loadBalancerWeight3)
 {
 	loadBalancerWeight3_ = loadBalancerWeight3;
-	setParameter("LoadBalancerWeight3", std::to_string(loadBalancerWeight3));
+	setCoreParameter("LoadBalancerWeight3", std::to_string(loadBalancerWeight3));
 }
 
 int EnableScalingGroupRequest::getLoadBalancerWeight16()const
@@ -154,7 +154,7 @@ int EnableScalingGroupRequest::getLoadBalancerWeight16()const
 void EnableScalingGroupRequest::setLoadBalancerWeight16(int loadBalancerWeight16)
 {
 	loadBalancerWeight16_ = loadBalancerWeight16;
-	setParameter("LoadBalancerWeight16", std::to_string(loadBalancerWeight16));
+	setCoreParameter("LoadBalancerWeight16", std::to_string(loadBalancerWeight16));
 }
 
 int EnableScalingGroupRequest::getLoadBalancerWeight4()const
@@ -165,7 +165,7 @@ int EnableScalingGroupRequest::getLoadBalancerWeight4()const
 void EnableScalingGroupRequest::setLoadBalancerWeight4(int loadBalancerWeight4)
 {
 	loadBalancerWeight4_ = loadBalancerWeight4;
-	setParameter("LoadBalancerWeight4", std::to_string(loadBalancerWeight4));
+	setCoreParameter("LoadBalancerWeight4", std::to_string(loadBalancerWeight4));
 }
 
 int EnableScalingGroupRequest::getLoadBalancerWeight13()const
@@ -176,7 +176,7 @@ int EnableScalingGroupRequest::getLoadBalancerWeight13()const
 void EnableScalingGroupRequest::setLoadBalancerWeight13(int loadBalancerWeight13)
 {
 	loadBalancerWeight13_ = loadBalancerWeight13;
-	setParameter("LoadBalancerWeight13", std::to_string(loadBalancerWeight13));
+	setCoreParameter("LoadBalancerWeight13", std::to_string(loadBalancerWeight13));
 }
 
 int EnableScalingGroupRequest::getLoadBalancerWeight5()const
@@ -187,7 +187,7 @@ int EnableScalingGroupRequest::getLoadBalancerWeight5()const
 void EnableScalingGroupRequest::setLoadBalancerWeight5(int loadBalancerWeight5)
 {
 	loadBalancerWeight5_ = loadBalancerWeight5;
-	setParameter("LoadBalancerWeight5", std::to_string(loadBalancerWeight5));
+	setCoreParameter("LoadBalancerWeight5", std::to_string(loadBalancerWeight5));
 }
 
 int EnableScalingGroupRequest::getLoadBalancerWeight14()const
@@ -198,7 +198,7 @@ int EnableScalingGroupRequest::getLoadBalancerWeight14()const
 void EnableScalingGroupRequest::setLoadBalancerWeight14(int loadBalancerWeight14)
 {
 	loadBalancerWeight14_ = loadBalancerWeight14;
-	setParameter("LoadBalancerWeight14", std::to_string(loadBalancerWeight14));
+	setCoreParameter("LoadBalancerWeight14", std::to_string(loadBalancerWeight14));
 }
 
 std::string EnableScalingGroupRequest::getActiveScalingConfigurationId()const
@@ -209,7 +209,7 @@ std::string EnableScalingGroupRequest::getActiveScalingConfigurationId()const
 void EnableScalingGroupRequest::setActiveScalingConfigurationId(const std::string& activeScalingConfigurationId)
 {
 	activeScalingConfigurationId_ = activeScalingConfigurationId;
-	setParameter("ActiveScalingConfigurationId", activeScalingConfigurationId);
+	setCoreParameter("ActiveScalingConfigurationId", activeScalingConfigurationId);
 }
 
 int EnableScalingGroupRequest::getLoadBalancerWeight1()const
@@ -220,7 +220,7 @@ int EnableScalingGroupRequest::getLoadBalancerWeight1()const
 void EnableScalingGroupRequest::setLoadBalancerWeight1(int loadBalancerWeight1)
 {
 	loadBalancerWeight1_ = loadBalancerWeight1;
-	setParameter("LoadBalancerWeight1", std::to_string(loadBalancerWeight1));
+	setCoreParameter("LoadBalancerWeight1", std::to_string(loadBalancerWeight1));
 }
 
 std::string EnableScalingGroupRequest::getInstanceId1()const
@@ -231,7 +231,7 @@ std::string EnableScalingGroupRequest::getInstanceId1()const
 void EnableScalingGroupRequest::setInstanceId1(const std::string& instanceId1)
 {
 	instanceId1_ = instanceId1;
-	setParameter("InstanceId1", instanceId1);
+	setCoreParameter("InstanceId1", instanceId1);
 }
 
 int EnableScalingGroupRequest::getLoadBalancerWeight20()const
@@ -242,7 +242,7 @@ int EnableScalingGroupRequest::getLoadBalancerWeight20()const
 void EnableScalingGroupRequest::setLoadBalancerWeight20(int loadBalancerWeight20)
 {
 	loadBalancerWeight20_ = loadBalancerWeight20;
-	setParameter("LoadBalancerWeight20", std::to_string(loadBalancerWeight20));
+	setCoreParameter("LoadBalancerWeight20", std::to_string(loadBalancerWeight20));
 }
 
 std::string EnableScalingGroupRequest::getInstanceId3()const
@@ -253,7 +253,7 @@ std::string EnableScalingGroupRequest::getInstanceId3()const
 void EnableScalingGroupRequest::setInstanceId3(const std::string& instanceId3)
 {
 	instanceId3_ = instanceId3;
-	setParameter("InstanceId3", instanceId3);
+	setCoreParameter("InstanceId3", instanceId3);
 }
 
 std::string EnableScalingGroupRequest::getLaunchTemplateId()const
@@ -264,7 +264,7 @@ std::string EnableScalingGroupRequest::getLaunchTemplateId()const
 void EnableScalingGroupRequest::setLaunchTemplateId(const std::string& launchTemplateId)
 {
 	launchTemplateId_ = launchTemplateId;
-	setParameter("LaunchTemplateId", launchTemplateId);
+	setCoreParameter("LaunchTemplateId", launchTemplateId);
 }
 
 std::string EnableScalingGroupRequest::getInstanceId2()const
@@ -275,7 +275,7 @@ std::string EnableScalingGroupRequest::getInstanceId2()const
 void EnableScalingGroupRequest::setInstanceId2(const std::string& instanceId2)
 {
 	instanceId2_ = instanceId2;
-	setParameter("InstanceId2", instanceId2);
+	setCoreParameter("InstanceId2", instanceId2);
 }
 
 std::string EnableScalingGroupRequest::getInstanceId5()const
@@ -286,7 +286,7 @@ std::string EnableScalingGroupRequest::getInstanceId5()const
 void EnableScalingGroupRequest::setInstanceId5(const std::string& instanceId5)
 {
 	instanceId5_ = instanceId5;
-	setParameter("InstanceId5", instanceId5);
+	setCoreParameter("InstanceId5", instanceId5);
 }
 
 std::string EnableScalingGroupRequest::getInstanceId4()const
@@ -297,7 +297,7 @@ std::string EnableScalingGroupRequest::getInstanceId4()const
 void EnableScalingGroupRequest::setInstanceId4(const std::string& instanceId4)
 {
 	instanceId4_ = instanceId4;
-	setParameter("InstanceId4", instanceId4);
+	setCoreParameter("InstanceId4", instanceId4);
 }
 
 std::string EnableScalingGroupRequest::getInstanceId7()const
@@ -308,7 +308,7 @@ std::string EnableScalingGroupRequest::getInstanceId7()const
 void EnableScalingGroupRequest::setInstanceId7(const std::string& instanceId7)
 {
 	instanceId7_ = instanceId7;
-	setParameter("InstanceId7", instanceId7);
+	setCoreParameter("InstanceId7", instanceId7);
 }
 
 std::string EnableScalingGroupRequest::getInstanceId6()const
@@ -319,7 +319,7 @@ std::string EnableScalingGroupRequest::getInstanceId6()const
 void EnableScalingGroupRequest::setInstanceId6(const std::string& instanceId6)
 {
 	instanceId6_ = instanceId6;
-	setParameter("InstanceId6", instanceId6);
+	setCoreParameter("InstanceId6", instanceId6);
 }
 
 std::string EnableScalingGroupRequest::getInstanceId9()const
@@ -330,7 +330,7 @@ std::string EnableScalingGroupRequest::getInstanceId9()const
 void EnableScalingGroupRequest::setInstanceId9(const std::string& instanceId9)
 {
 	instanceId9_ = instanceId9;
-	setParameter("InstanceId9", instanceId9);
+	setCoreParameter("InstanceId9", instanceId9);
 }
 
 std::string EnableScalingGroupRequest::getInstanceId8()const
@@ -341,7 +341,7 @@ std::string EnableScalingGroupRequest::getInstanceId8()const
 void EnableScalingGroupRequest::setInstanceId8(const std::string& instanceId8)
 {
 	instanceId8_ = instanceId8;
-	setParameter("InstanceId8", instanceId8);
+	setCoreParameter("InstanceId8", instanceId8);
 }
 
 long EnableScalingGroupRequest::getOwnerId()const
@@ -352,7 +352,7 @@ long EnableScalingGroupRequest::getOwnerId()const
 void EnableScalingGroupRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 int EnableScalingGroupRequest::getLoadBalancerWeight19()const
@@ -363,7 +363,7 @@ int EnableScalingGroupRequest::getLoadBalancerWeight19()const
 void EnableScalingGroupRequest::setLoadBalancerWeight19(int loadBalancerWeight19)
 {
 	loadBalancerWeight19_ = loadBalancerWeight19;
-	setParameter("LoadBalancerWeight19", std::to_string(loadBalancerWeight19));
+	setCoreParameter("LoadBalancerWeight19", std::to_string(loadBalancerWeight19));
 }
 
 int EnableScalingGroupRequest::getLoadBalancerWeight17()const
@@ -374,7 +374,7 @@ int EnableScalingGroupRequest::getLoadBalancerWeight17()const
 void EnableScalingGroupRequest::setLoadBalancerWeight17(int loadBalancerWeight17)
 {
 	loadBalancerWeight17_ = loadBalancerWeight17;
-	setParameter("LoadBalancerWeight17", std::to_string(loadBalancerWeight17));
+	setCoreParameter("LoadBalancerWeight17", std::to_string(loadBalancerWeight17));
 }
 
 int EnableScalingGroupRequest::getLoadBalancerWeight18()const
@@ -385,7 +385,7 @@ int EnableScalingGroupRequest::getLoadBalancerWeight18()const
 void EnableScalingGroupRequest::setLoadBalancerWeight18(int loadBalancerWeight18)
 {
 	loadBalancerWeight18_ = loadBalancerWeight18;
-	setParameter("LoadBalancerWeight18", std::to_string(loadBalancerWeight18));
+	setCoreParameter("LoadBalancerWeight18", std::to_string(loadBalancerWeight18));
 }
 
 std::string EnableScalingGroupRequest::getInstanceId10()const
@@ -396,7 +396,7 @@ std::string EnableScalingGroupRequest::getInstanceId10()const
 void EnableScalingGroupRequest::setInstanceId10(const std::string& instanceId10)
 {
 	instanceId10_ = instanceId10;
-	setParameter("InstanceId10", instanceId10);
+	setCoreParameter("InstanceId10", instanceId10);
 }
 
 std::string EnableScalingGroupRequest::getInstanceId12()const
@@ -407,7 +407,7 @@ std::string EnableScalingGroupRequest::getInstanceId12()const
 void EnableScalingGroupRequest::setInstanceId12(const std::string& instanceId12)
 {
 	instanceId12_ = instanceId12;
-	setParameter("InstanceId12", instanceId12);
+	setCoreParameter("InstanceId12", instanceId12);
 }
 
 std::string EnableScalingGroupRequest::getInstanceId11()const
@@ -418,7 +418,7 @@ std::string EnableScalingGroupRequest::getInstanceId11()const
 void EnableScalingGroupRequest::setInstanceId11(const std::string& instanceId11)
 {
 	instanceId11_ = instanceId11;
-	setParameter("InstanceId11", instanceId11);
+	setCoreParameter("InstanceId11", instanceId11);
 }
 
 std::string EnableScalingGroupRequest::getScalingGroupId()const
@@ -429,7 +429,7 @@ std::string EnableScalingGroupRequest::getScalingGroupId()const
 void EnableScalingGroupRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 std::string EnableScalingGroupRequest::getAccessKeyId()const
@@ -440,7 +440,7 @@ std::string EnableScalingGroupRequest::getAccessKeyId()const
 void EnableScalingGroupRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string EnableScalingGroupRequest::getInstanceId20()const
@@ -451,7 +451,7 @@ std::string EnableScalingGroupRequest::getInstanceId20()const
 void EnableScalingGroupRequest::setInstanceId20(const std::string& instanceId20)
 {
 	instanceId20_ = instanceId20;
-	setParameter("InstanceId20", instanceId20);
+	setCoreParameter("InstanceId20", instanceId20);
 }
 
 std::string EnableScalingGroupRequest::getResourceOwnerAccount()const
@@ -462,7 +462,7 @@ std::string EnableScalingGroupRequest::getResourceOwnerAccount()const
 void EnableScalingGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string EnableScalingGroupRequest::getOwnerAccount()const
@@ -473,7 +473,7 @@ std::string EnableScalingGroupRequest::getOwnerAccount()const
 void EnableScalingGroupRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 std::string EnableScalingGroupRequest::getLaunchTemplateVersion()const
@@ -484,7 +484,7 @@ std::string EnableScalingGroupRequest::getLaunchTemplateVersion()const
 void EnableScalingGroupRequest::setLaunchTemplateVersion(const std::string& launchTemplateVersion)
 {
 	launchTemplateVersion_ = launchTemplateVersion;
-	setParameter("LaunchTemplateVersion", launchTemplateVersion);
+	setCoreParameter("LaunchTemplateVersion", launchTemplateVersion);
 }
 
 std::string EnableScalingGroupRequest::getInstanceId18()const
@@ -495,7 +495,7 @@ std::string EnableScalingGroupRequest::getInstanceId18()const
 void EnableScalingGroupRequest::setInstanceId18(const std::string& instanceId18)
 {
 	instanceId18_ = instanceId18;
-	setParameter("InstanceId18", instanceId18);
+	setCoreParameter("InstanceId18", instanceId18);
 }
 
 std::string EnableScalingGroupRequest::getInstanceId17()const
@@ -506,7 +506,7 @@ std::string EnableScalingGroupRequest::getInstanceId17()const
 void EnableScalingGroupRequest::setInstanceId17(const std::string& instanceId17)
 {
 	instanceId17_ = instanceId17;
-	setParameter("InstanceId17", instanceId17);
+	setCoreParameter("InstanceId17", instanceId17);
 }
 
 std::string EnableScalingGroupRequest::getInstanceId19()const
@@ -517,7 +517,7 @@ std::string EnableScalingGroupRequest::getInstanceId19()const
 void EnableScalingGroupRequest::setInstanceId19(const std::string& instanceId19)
 {
 	instanceId19_ = instanceId19;
-	setParameter("InstanceId19", instanceId19);
+	setCoreParameter("InstanceId19", instanceId19);
 }
 
 std::string EnableScalingGroupRequest::getInstanceId14()const
@@ -528,7 +528,7 @@ std::string EnableScalingGroupRequest::getInstanceId14()const
 void EnableScalingGroupRequest::setInstanceId14(const std::string& instanceId14)
 {
 	instanceId14_ = instanceId14;
-	setParameter("InstanceId14", instanceId14);
+	setCoreParameter("InstanceId14", instanceId14);
 }
 
 std::string EnableScalingGroupRequest::getInstanceId13()const
@@ -539,7 +539,7 @@ std::string EnableScalingGroupRequest::getInstanceId13()const
 void EnableScalingGroupRequest::setInstanceId13(const std::string& instanceId13)
 {
 	instanceId13_ = instanceId13;
-	setParameter("InstanceId13", instanceId13);
+	setCoreParameter("InstanceId13", instanceId13);
 }
 
 std::string EnableScalingGroupRequest::getInstanceId16()const
@@ -550,7 +550,7 @@ std::string EnableScalingGroupRequest::getInstanceId16()const
 void EnableScalingGroupRequest::setInstanceId16(const std::string& instanceId16)
 {
 	instanceId16_ = instanceId16;
-	setParameter("InstanceId16", instanceId16);
+	setCoreParameter("InstanceId16", instanceId16);
 }
 
 std::string EnableScalingGroupRequest::getInstanceId15()const
@@ -561,6 +561,6 @@ std::string EnableScalingGroupRequest::getInstanceId15()const
 void EnableScalingGroupRequest::setInstanceId15(const std::string& instanceId15)
 {
 	instanceId15_ = instanceId15;
-	setParameter("InstanceId15", instanceId15);
+	setCoreParameter("InstanceId15", instanceId15);
 }
 

ess/src/model/EnterStandbyRequest.cc

@@ -34,7 +34,7 @@ void EnterStandbyRequest::setInstanceId(const std::vector<std::string>& instance
 {
 	instanceId_ = instanceId;
 	for(int i = 0; i!= instanceId.size(); i++)
-		setParameter("InstanceId."+ std::to_string(i), instanceId.at(i));
+		setCoreParameter("InstanceId."+ std::to_string(i), instanceId.at(i));
 }
 
 std::string EnterStandbyRequest::getResourceOwnerAccount()const
@@ -45,7 +45,7 @@ std::string EnterStandbyRequest::getResourceOwnerAccount()const
 void EnterStandbyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string EnterStandbyRequest::getScalingGroupId()const
@@ -56,7 +56,7 @@ std::string EnterStandbyRequest::getScalingGroupId()const
 void EnterStandbyRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 long EnterStandbyRequest::getOwnerId()const
@@ -67,7 +67,7 @@ long EnterStandbyRequest::getOwnerId()const
 void EnterStandbyRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string EnterStandbyRequest::getAccessKeyId()const
@@ -78,6 +78,6 @@ std::string EnterStandbyRequest::getAccessKeyId()const
 void EnterStandbyRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/ExecuteScalingRuleRequest.cc

@@ -33,7 +33,7 @@ long ExecuteScalingRuleRequest::getResourceOwnerId()const
 void ExecuteScalingRuleRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string ExecuteScalingRuleRequest::getScalingRuleAri()const
@@ -44,7 +44,7 @@ std::string ExecuteScalingRuleRequest::getScalingRuleAri()const
 void ExecuteScalingRuleRequest::setScalingRuleAri(const std::string& scalingRuleAri)
 {
 	scalingRuleAri_ = scalingRuleAri;
-	setParameter("ScalingRuleAri", scalingRuleAri);
+	setCoreParameter("ScalingRuleAri", scalingRuleAri);
 }
 
 std::string ExecuteScalingRuleRequest::getResourceOwnerAccount()const
@@ -55,7 +55,7 @@ std::string ExecuteScalingRuleRequest::getResourceOwnerAccount()const
 void ExecuteScalingRuleRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string ExecuteScalingRuleRequest::getClientToken()const
@@ -66,7 +66,18 @@ std::string ExecuteScalingRuleRequest::getClientToken()const
 void ExecuteScalingRuleRequest::setClientToken(const std::string& clientToken)
 {
 	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+	setCoreParameter("ClientToken", clientToken);
+}
+
+float ExecuteScalingRuleRequest::getBreachThreshold()const
+{
+	return breachThreshold_;
+}
+
+void ExecuteScalingRuleRequest::setBreachThreshold(float breachThreshold)
+{
+	breachThreshold_ = breachThreshold;
+	setCoreParameter("BreachThreshold", std::to_string(breachThreshold));
 }
 
 std::string ExecuteScalingRuleRequest::getOwnerAccount()const
@@ -77,7 +88,7 @@ std::string ExecuteScalingRuleRequest::getOwnerAccount()const
 void ExecuteScalingRuleRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 long ExecuteScalingRuleRequest::getOwnerId()const
@@ -88,7 +99,18 @@ long ExecuteScalingRuleRequest::getOwnerId()const
 void ExecuteScalingRuleRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
+}
+
+float ExecuteScalingRuleRequest::getMetricValue()const
+{
+	return metricValue_;
+}
+
+void ExecuteScalingRuleRequest::setMetricValue(float metricValue)
+{
+	metricValue_ = metricValue;
+	setCoreParameter("MetricValue", std::to_string(metricValue));
 }
 
 std::string ExecuteScalingRuleRequest::getAccessKeyId()const
@@ -99,6 +121,6 @@ std::string ExecuteScalingRuleRequest::getAccessKeyId()const
 void ExecuteScalingRuleRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/ExitStandbyRequest.cc

@@ -34,7 +34,7 @@ void ExitStandbyRequest::setInstanceId(const std::vector<std::string>& instanceI
 {
 	instanceId_ = instanceId;
 	for(int i = 0; i!= instanceId.size(); i++)
-		setParameter("InstanceId."+ std::to_string(i), instanceId.at(i));
+		setCoreParameter("InstanceId."+ std::to_string(i), instanceId.at(i));
 }
 
 std::string ExitStandbyRequest::getResourceOwnerAccount()const
@@ -45,7 +45,7 @@ std::string ExitStandbyRequest::getResourceOwnerAccount()const
 void ExitStandbyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string ExitStandbyRequest::getScalingGroupId()const
@@ -56,7 +56,7 @@ std::string ExitStandbyRequest::getScalingGroupId()const
 void ExitStandbyRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 long ExitStandbyRequest::getOwnerId()const
@@ -67,7 +67,7 @@ long ExitStandbyRequest::getOwnerId()const
 void ExitStandbyRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string ExitStandbyRequest::getAccessKeyId()const
@@ -78,6 +78,6 @@ std::string ExitStandbyRequest::getAccessKeyId()const
 void ExitStandbyRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/ModifyAlarmRequest.cc

@@ -25,37 +25,48 @@ ModifyAlarmRequest::ModifyAlarmRequest() :
 ModifyAlarmRequest::~ModifyAlarmRequest()
 {}
 
-std::string ModifyAlarmRequest::getResourceOwnerAccount()const
+std::string ModifyAlarmRequest::getMetricType()const
 {
-	return resourceOwnerAccount_;
+	return metricType_;
 }
 
-void ModifyAlarmRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+void ModifyAlarmRequest::setMetricType(const std::string& metricType)
 {
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	metricType_ = metricType;
+	setCoreParameter("MetricType", metricType);
 }
 
-std::string ModifyAlarmRequest::getRegionId()const
+int ModifyAlarmRequest::getPeriod()const
 {
-	return regionId_;
+	return period_;
 }
 
-void ModifyAlarmRequest::setRegionId(const std::string& regionId)
+void ModifyAlarmRequest::setPeriod(int period)
 {
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+	period_ = period;
+	setCoreParameter("Period", std::to_string(period));
 }
 
-std::string ModifyAlarmRequest::getName()const
+std::string ModifyAlarmRequest::getResourceOwnerAccount()const
 {
-	return name_;
+	return resourceOwnerAccount_;
 }
 
-void ModifyAlarmRequest::setName(const std::string& name)
+void ModifyAlarmRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
-	name_ = name;
-	setParameter("Name", name);
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+int ModifyAlarmRequest::getGroupId()const
+{
+	return groupId_;
+}
+
+void ModifyAlarmRequest::setGroupId(int groupId)
+{
+	groupId_ = groupId;
+	setCoreParameter("GroupId", std::to_string(groupId));
 }
 
 std::string ModifyAlarmRequest::getDescription()const
@@ -66,7 +77,7 @@ std::string ModifyAlarmRequest::getDescription()const
 void ModifyAlarmRequest::setDescription(const std::string& description)
 {
 	description_ = description;
-	setParameter("Description", description);
+	setCoreParameter("Description", description);
 }
 
 std::vector<std::string> ModifyAlarmRequest::getAlarmAction()const
@@ -78,7 +89,18 @@ void ModifyAlarmRequest::setAlarmAction(const std::vector<std::string>& alarmAct
 {
 	alarmAction_ = alarmAction;
 	for(int i = 0; i!= alarmAction.size(); i++)
-		setParameter("AlarmAction."+ std::to_string(i), alarmAction.at(i));
+		setCoreParameter("AlarmAction."+ std::to_string(i), alarmAction.at(i));
+}
+
+float ModifyAlarmRequest::getThreshold()const
+{
+	return threshold_;
+}
+
+void ModifyAlarmRequest::setThreshold(float threshold)
+{
+	threshold_ = threshold;
+	setCoreParameter("Threshold", std::to_string(threshold));
 }
 
 long ModifyAlarmRequest::getOwnerId()const
@@ -89,7 +111,7 @@ long ModifyAlarmRequest::getOwnerId()const
 void ModifyAlarmRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string ModifyAlarmRequest::getAlarmTaskId()const
@@ -100,7 +122,7 @@ std::string ModifyAlarmRequest::getAlarmTaskId()const
 void ModifyAlarmRequest::setAlarmTaskId(const std::string& alarmTaskId)
 {
 	alarmTaskId_ = alarmTaskId;
-	setParameter("AlarmTaskId", alarmTaskId);
+	setCoreParameter("AlarmTaskId", alarmTaskId);
 }
 
 std::string ModifyAlarmRequest::getAccessKeyId()const
@@ -111,6 +133,89 @@ std::string ModifyAlarmRequest::getAccessKeyId()const
 void ModifyAlarmRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
+}
+
+std::string ModifyAlarmRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ModifyAlarmRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setCoreParameter("RegionId", regionId);
+}
+
+std::string ModifyAlarmRequest::getName()const
+{
+	return name_;
+}
+
+void ModifyAlarmRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setCoreParameter("Name", name);
+}
+
+int ModifyAlarmRequest::getEvaluationCount()const
+{
+	return evaluationCount_;
+}
+
+void ModifyAlarmRequest::setEvaluationCount(int evaluationCount)
+{
+	evaluationCount_ = evaluationCount;
+	setCoreParameter("EvaluationCount", std::to_string(evaluationCount));
+}
+
+std::string ModifyAlarmRequest::getMetricName()const
+{
+	return metricName_;
+}
+
+void ModifyAlarmRequest::setMetricName(const std::string& metricName)
+{
+	metricName_ = metricName;
+	setCoreParameter("MetricName", metricName);
+}
+
+std::string ModifyAlarmRequest::getComparisonOperator()const
+{
+	return comparisonOperator_;
+}
+
+void ModifyAlarmRequest::setComparisonOperator(const std::string& comparisonOperator)
+{
+	comparisonOperator_ = comparisonOperator;
+	setCoreParameter("ComparisonOperator", comparisonOperator);
+}
+
+std::vector<ModifyAlarmRequest::Dimension> ModifyAlarmRequest::getDimension()const
+{
+	return dimension_;
+}
+
+void ModifyAlarmRequest::setDimension(const std::vector<Dimension>& dimension)
+{
+	dimension_ = dimension;
+	int i = 0;
+	for(int i = 0; i!= dimension.size(); i++)	{
+		auto obj = dimension.at(i);
+		std::string str ="Dimension."+ std::to_string(i);
+		setCoreParameter(str + ".DimensionValue", obj.dimensionValue);
+		setCoreParameter(str + ".DimensionKey", obj.dimensionKey);
+	}
+}
+
+std::string ModifyAlarmRequest::getStatistics()const
+{
+	return statistics_;
+}
+
+void ModifyAlarmRequest::setStatistics(const std::string& statistics)
+{
+	statistics_ = statistics;
+	setCoreParameter("Statistics", statistics);
 }
 

ess/src/model/ModifyAlertConfigRequest.cc

@@ -33,7 +33,7 @@ int ModifyAlertConfigRequest::getSuccessConfig()const
 void ModifyAlertConfigRequest::setSuccessConfig(int successConfig)
 {
 	successConfig_ = successConfig;
-	setParameter("SuccessConfig", std::to_string(successConfig));
+	setCoreParameter("SuccessConfig", std::to_string(successConfig));
 }
 
 int ModifyAlertConfigRequest::getRejectConfig()const
@@ -44,7 +44,7 @@ int ModifyAlertConfigRequest::getRejectConfig()const
 void ModifyAlertConfigRequest::setRejectConfig(int rejectConfig)
 {
 	rejectConfig_ = rejectConfig;
-	setParameter("RejectConfig", std::to_string(rejectConfig));
+	setCoreParameter("RejectConfig", std::to_string(rejectConfig));
 }
 
 std::string ModifyAlertConfigRequest::getResourceOwnerAccount()const
@@ -55,7 +55,7 @@ std::string ModifyAlertConfigRequest::getResourceOwnerAccount()const
 void ModifyAlertConfigRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string ModifyAlertConfigRequest::getScalingGroupId()const
@@ -66,7 +66,7 @@ std::string ModifyAlertConfigRequest::getScalingGroupId()const
 void ModifyAlertConfigRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 long ModifyAlertConfigRequest::getOwnerId()const
@@ -77,7 +77,7 @@ long ModifyAlertConfigRequest::getOwnerId()const
 void ModifyAlertConfigRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 int ModifyAlertConfigRequest::getFailConfig()const
@@ -88,7 +88,7 @@ int ModifyAlertConfigRequest::getFailConfig()const
 void ModifyAlertConfigRequest::setFailConfig(int failConfig)
 {
 	failConfig_ = failConfig;
-	setParameter("FailConfig", std::to_string(failConfig));
+	setCoreParameter("FailConfig", std::to_string(failConfig));
 }
 
 std::string ModifyAlertConfigRequest::getAccessKeyId()const
@@ -99,6 +99,6 @@ std::string ModifyAlertConfigRequest::getAccessKeyId()const
 void ModifyAlertConfigRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/ModifyLifecycleHookRequest.cc

@@ -33,7 +33,7 @@ std::string ModifyLifecycleHookRequest::getDefaultResult()const
 void ModifyLifecycleHookRequest::setDefaultResult(const std::string& defaultResult)
 {
 	defaultResult_ = defaultResult;
-	setParameter("DefaultResult", defaultResult);
+	setCoreParameter("DefaultResult", defaultResult);
 }
 
 std::string ModifyLifecycleHookRequest::getResourceOwnerAccount()const
@@ -44,7 +44,7 @@ std::string ModifyLifecycleHookRequest::getResourceOwnerAccount()const
 void ModifyLifecycleHookRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 int ModifyLifecycleHookRequest::getHeartbeatTimeout()const
@@ -55,7 +55,7 @@ int ModifyLifecycleHookRequest::getHeartbeatTimeout()const
 void ModifyLifecycleHookRequest::setHeartbeatTimeout(int heartbeatTimeout)
 {
 	heartbeatTimeout_ = heartbeatTimeout;
-	setParameter("HeartbeatTimeout", std::to_string(heartbeatTimeout));
+	setCoreParameter("HeartbeatTimeout", std::to_string(heartbeatTimeout));
 }
 
 std::string ModifyLifecycleHookRequest::getLifecycleHookId()const
@@ -66,7 +66,7 @@ std::string ModifyLifecycleHookRequest::getLifecycleHookId()const
 void ModifyLifecycleHookRequest::setLifecycleHookId(const std::string& lifecycleHookId)
 {
 	lifecycleHookId_ = lifecycleHookId;
-	setParameter("LifecycleHookId", lifecycleHookId);
+	setCoreParameter("LifecycleHookId", lifecycleHookId);
 }
 
 std::string ModifyLifecycleHookRequest::getScalingGroupId()const
@@ -77,7 +77,7 @@ std::string ModifyLifecycleHookRequest::getScalingGroupId()const
 void ModifyLifecycleHookRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 std::string ModifyLifecycleHookRequest::getOwnerAccount()const
@@ -88,7 +88,7 @@ std::string ModifyLifecycleHookRequest::getOwnerAccount()const
 void ModifyLifecycleHookRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 std::string ModifyLifecycleHookRequest::getNotificationMetadata()const
@@ -99,7 +99,7 @@ std::string ModifyLifecycleHookRequest::getNotificationMetadata()const
 void ModifyLifecycleHookRequest::setNotificationMetadata(const std::string& notificationMetadata)
 {
 	notificationMetadata_ = notificationMetadata;
-	setParameter("NotificationMetadata", notificationMetadata);
+	setCoreParameter("NotificationMetadata", notificationMetadata);
 }
 
 long ModifyLifecycleHookRequest::getOwnerId()const
@@ -110,7 +110,7 @@ long ModifyLifecycleHookRequest::getOwnerId()const
 void ModifyLifecycleHookRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string ModifyLifecycleHookRequest::getLifecycleTransition()const
@@ -121,7 +121,7 @@ std::string ModifyLifecycleHookRequest::getLifecycleTransition()const
 void ModifyLifecycleHookRequest::setLifecycleTransition(const std::string& lifecycleTransition)
 {
 	lifecycleTransition_ = lifecycleTransition;
-	setParameter("LifecycleTransition", lifecycleTransition);
+	setCoreParameter("LifecycleTransition", lifecycleTransition);
 }
 
 std::string ModifyLifecycleHookRequest::getAccessKeyId()const
@@ -132,7 +132,7 @@ std::string ModifyLifecycleHookRequest::getAccessKeyId()const
 void ModifyLifecycleHookRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string ModifyLifecycleHookRequest::getLifecycleHookName()const
@@ -143,7 +143,7 @@ std::string ModifyLifecycleHookRequest::getLifecycleHookName()const
 void ModifyLifecycleHookRequest::setLifecycleHookName(const std::string& lifecycleHookName)
 {
 	lifecycleHookName_ = lifecycleHookName;
-	setParameter("LifecycleHookName", lifecycleHookName);
+	setCoreParameter("LifecycleHookName", lifecycleHookName);
 }
 
 std::string ModifyLifecycleHookRequest::getNotificationArn()const
@@ -154,6 +154,6 @@ std::string ModifyLifecycleHookRequest::getNotificationArn()const
 void ModifyLifecycleHookRequest::setNotificationArn(const std::string& notificationArn)
 {
 	notificationArn_ = notificationArn;
-	setParameter("NotificationArn", notificationArn);
+	setCoreParameter("NotificationArn", notificationArn);
 }
 

ess/src/model/ModifyNotificationConfigurationRequest.cc

@@ -33,7 +33,7 @@ std::string ModifyNotificationConfigurationRequest::getResourceOwnerAccount()con
 void ModifyNotificationConfigurationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string ModifyNotificationConfigurationRequest::getScalingGroupId()const
@@ -44,7 +44,7 @@ std::string ModifyNotificationConfigurationRequest::getScalingGroupId()const
 void ModifyNotificationConfigurationRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 std::string ModifyNotificationConfigurationRequest::getNotificationArn()const
@@ -55,7 +55,7 @@ std::string ModifyNotificationConfigurationRequest::getNotificationArn()const
 void ModifyNotificationConfigurationRequest::setNotificationArn(const std::string& notificationArn)
 {
 	notificationArn_ = notificationArn;
-	setParameter("NotificationArn", notificationArn);
+	setCoreParameter("NotificationArn", notificationArn);
 }
 
 std::vector<std::string> ModifyNotificationConfigurationRequest::getNotificationType()const
@@ -67,7 +67,7 @@ void ModifyNotificationConfigurationRequest::setNotificationType(const std::vect
 {
 	notificationType_ = notificationType;
 	for(int i = 0; i!= notificationType.size(); i++)
-		setParameter("NotificationType."+ std::to_string(i), notificationType.at(i));
+		setCoreParameter("NotificationType."+ std::to_string(i), notificationType.at(i));
 }
 
 long ModifyNotificationConfigurationRequest::getOwnerId()const
@@ -78,7 +78,7 @@ long ModifyNotificationConfigurationRequest::getOwnerId()const
 void ModifyNotificationConfigurationRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string ModifyNotificationConfigurationRequest::getAccessKeyId()const
@@ -89,6 +89,6 @@ std::string ModifyNotificationConfigurationRequest::getAccessKeyId()const
 void ModifyNotificationConfigurationRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/ModifyScalingConfigurationRequest.cc

@@ -33,7 +33,7 @@ std::string ModifyScalingConfigurationRequest::getImageId()const
 void ModifyScalingConfigurationRequest::setImageId(const std::string& imageId)
 {
 	imageId_ = imageId;
-	setParameter("ImageId", imageId);
+	setCoreParameter("ImageId", imageId);
 }
 
 int ModifyScalingConfigurationRequest::getMemory()const
@@ -44,7 +44,7 @@ int ModifyScalingConfigurationRequest::getMemory()const
 void ModifyScalingConfigurationRequest::setMemory(int memory)
 {
 	memory_ = memory;
-	setParameter("Memory", std::to_string(memory));
+	setCoreParameter("Memory", std::to_string(memory));
 }
 
 std::string ModifyScalingConfigurationRequest::getIoOptimized()const
@@ -55,7 +55,7 @@ std::string ModifyScalingConfigurationRequest::getIoOptimized()const
 void ModifyScalingConfigurationRequest::setIoOptimized(const std::string& ioOptimized)
 {
 	ioOptimized_ = ioOptimized;
-	setParameter("IoOptimized", ioOptimized);
+	setCoreParameter("IoOptimized", ioOptimized);
 }
 
 std::vector<std::string> ModifyScalingConfigurationRequest::getInstanceTypes()const
@@ -67,7 +67,7 @@ void ModifyScalingConfigurationRequest::setInstanceTypes(const std::vector<std::
 {
 	instanceTypes_ = instanceTypes;
 	for(int i = 0; i!= instanceTypes.size(); i++)
-		setParameter("InstanceTypes."+ std::to_string(i), instanceTypes.at(i));
+		setCoreParameter("InstanceTypes."+ std::to_string(i), instanceTypes.at(i));
 }
 
 int ModifyScalingConfigurationRequest::getInternetMaxBandwidthOut()const
@@ -78,7 +78,7 @@ int ModifyScalingConfigurationRequest::getInternetMaxBandwidthOut()const
 void ModifyScalingConfigurationRequest::setInternetMaxBandwidthOut(int internetMaxBandwidthOut)
 {
 	internetMaxBandwidthOut_ = internetMaxBandwidthOut;
-	setParameter("InternetMaxBandwidthOut", std::to_string(internetMaxBandwidthOut));
+	setCoreParameter("InternetMaxBandwidthOut", std::to_string(internetMaxBandwidthOut));
 }
 
 std::string ModifyScalingConfigurationRequest::getSecurityGroupId()const
@@ -89,7 +89,7 @@ std::string ModifyScalingConfigurationRequest::getSecurityGroupId()const
 void ModifyScalingConfigurationRequest::setSecurityGroupId(const std::string& securityGroupId)
 {
 	securityGroupId_ = securityGroupId;
-	setParameter("SecurityGroupId", securityGroupId);
+	setCoreParameter("SecurityGroupId", securityGroupId);
 }
 
 std::string ModifyScalingConfigurationRequest::getKeyPairName()const
@@ -100,7 +100,7 @@ std::string ModifyScalingConfigurationRequest::getKeyPairName()const
 void ModifyScalingConfigurationRequest::setKeyPairName(const std::string& keyPairName)
 {
 	keyPairName_ = keyPairName;
-	setParameter("KeyPairName", keyPairName);
+	setCoreParameter("KeyPairName", keyPairName);
 }
 
 std::vector<ModifyScalingConfigurationRequest::SpotPriceLimit> ModifyScalingConfigurationRequest::getSpotPriceLimit()const
@@ -115,8 +115,8 @@ void ModifyScalingConfigurationRequest::setSpotPriceLimit(const std::vector<Spot
 	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));
+		setCoreParameter(str + ".InstanceType", obj.instanceType);
+		setCoreParameter(str + ".PriceLimit", std::to_string(obj.priceLimit));
 	}
 }
 
@@ -128,7 +128,7 @@ std::string ModifyScalingConfigurationRequest::getSystemDiskCategory()const
 void ModifyScalingConfigurationRequest::setSystemDiskCategory(const std::string& systemDiskCategory)
 {
 	systemDiskCategory_ = systemDiskCategory;
-	setParameter("SystemDiskCategory", systemDiskCategory);
+	setCoreParameter("SystemDiskCategory", systemDiskCategory);
 }
 
 std::string ModifyScalingConfigurationRequest::getAccessKeyId()const
@@ -139,7 +139,7 @@ std::string ModifyScalingConfigurationRequest::getAccessKeyId()const
 void ModifyScalingConfigurationRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string ModifyScalingConfigurationRequest::getUserData()const
@@ -150,7 +150,18 @@ std::string ModifyScalingConfigurationRequest::getUserData()const
 void ModifyScalingConfigurationRequest::setUserData(const std::string& userData)
 {
 	userData_ = userData;
-	setParameter("UserData", userData);
+	setCoreParameter("UserData", userData);
+}
+
+std::string ModifyScalingConfigurationRequest::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+void ModifyScalingConfigurationRequest::setResourceGroupId(const std::string& resourceGroupId)
+{
+	resourceGroupId_ = resourceGroupId;
+	setCoreParameter("ResourceGroupId", resourceGroupId);
 }
 
 std::string ModifyScalingConfigurationRequest::getHostName()const
@@ -161,7 +172,7 @@ std::string ModifyScalingConfigurationRequest::getHostName()const
 void ModifyScalingConfigurationRequest::setHostName(const std::string& hostName)
 {
 	hostName_ = hostName;
-	setParameter("HostName", hostName);
+	setCoreParameter("HostName", hostName);
 }
 
 bool ModifyScalingConfigurationRequest::getPasswordInherit()const
@@ -172,7 +183,7 @@ bool ModifyScalingConfigurationRequest::getPasswordInherit()const
 void ModifyScalingConfigurationRequest::setPasswordInherit(bool passwordInherit)
 {
 	passwordInherit_ = passwordInherit;
-	setParameter("PasswordInherit", std::to_string(passwordInherit));
+	setCoreParameter("PasswordInherit", passwordInherit ? "true" : "false");
 }
 
 std::string ModifyScalingConfigurationRequest::getImageName()const
@@ -183,7 +194,7 @@ std::string ModifyScalingConfigurationRequest::getImageName()const
 void ModifyScalingConfigurationRequest::setImageName(const std::string& imageName)
 {
 	imageName_ = imageName;
-	setParameter("ImageName", imageName);
+	setCoreParameter("ImageName", imageName);
 }
 
 bool ModifyScalingConfigurationRequest::getOverride()const
@@ -194,7 +205,7 @@ bool ModifyScalingConfigurationRequest::getOverride()const
 void ModifyScalingConfigurationRequest::setOverride(bool override)
 {
 	override_ = override;
-	setParameter("Override", std::to_string(override));
+	setCoreParameter("Override", override ? "true" : "false");
 }
 
 std::string ModifyScalingConfigurationRequest::getDeploymentSetId()const
@@ -205,7 +216,7 @@ std::string ModifyScalingConfigurationRequest::getDeploymentSetId()const
 void ModifyScalingConfigurationRequest::setDeploymentSetId(const std::string& deploymentSetId)
 {
 	deploymentSetId_ = deploymentSetId;
-	setParameter("DeploymentSetId", deploymentSetId);
+	setCoreParameter("DeploymentSetId", deploymentSetId);
 }
 
 std::string ModifyScalingConfigurationRequest::getResourceOwnerAccount()const
@@ -216,7 +227,7 @@ std::string ModifyScalingConfigurationRequest::getResourceOwnerAccount()const
 void ModifyScalingConfigurationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string ModifyScalingConfigurationRequest::getOwnerAccount()const
@@ -227,7 +238,7 @@ std::string ModifyScalingConfigurationRequest::getOwnerAccount()const
 void ModifyScalingConfigurationRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 int ModifyScalingConfigurationRequest::getCpu()const
@@ -238,7 +249,18 @@ int ModifyScalingConfigurationRequest::getCpu()const
 void ModifyScalingConfigurationRequest::setCpu(int cpu)
 {
 	cpu_ = cpu;
-	setParameter("Cpu", std::to_string(cpu));
+	setCoreParameter("Cpu", std::to_string(cpu));
+}
+
+std::string ModifyScalingConfigurationRequest::getSystemDiskDiskName()const
+{
+	return systemDiskDiskName_;
+}
+
+void ModifyScalingConfigurationRequest::setSystemDiskDiskName(const std::string& systemDiskDiskName)
+{
+	systemDiskDiskName_ = systemDiskDiskName;
+	setCoreParameter("SystemDiskDiskName", systemDiskDiskName);
 }
 
 std::string ModifyScalingConfigurationRequest::getRamRoleName()const
@@ -249,7 +271,7 @@ std::string ModifyScalingConfigurationRequest::getRamRoleName()const
 void ModifyScalingConfigurationRequest::setRamRoleName(const std::string& ramRoleName)
 {
 	ramRoleName_ = ramRoleName;
-	setParameter("RamRoleName", ramRoleName);
+	setCoreParameter("RamRoleName", ramRoleName);
 }
 
 long ModifyScalingConfigurationRequest::getOwnerId()const
@@ -260,7 +282,7 @@ long ModifyScalingConfigurationRequest::getOwnerId()const
 void ModifyScalingConfigurationRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::vector<ModifyScalingConfigurationRequest::DataDisk> ModifyScalingConfigurationRequest::getDataDisk()const
@@ -275,11 +297,15 @@ void ModifyScalingConfigurationRequest::setDataDisk(const std::vector<DataDisk>&
 	for(int i = 0; i!= dataDisk.size(); i++)	{
 		auto obj = dataDisk.at(i);
 		std::string str ="DataDisk."+ std::to_string(i);
-		setParameter(str + ".SnapshotId", obj.snapshotId);
-		setParameter(str + ".Size", std::to_string(obj.size));
-		setParameter(str + ".Category", obj.category);
-		setParameter(str + ".Device", obj.device);
-		setParameter(str + ".DeleteWithInstance", std::to_string(obj.deleteWithInstance));
+		setCoreParameter(str + ".DiskName", obj.diskName);
+		setCoreParameter(str + ".SnapshotId", obj.snapshotId);
+		setCoreParameter(str + ".Size", std::to_string(obj.size));
+		setCoreParameter(str + ".Encrypted", obj.encrypted);
+		setCoreParameter(str + ".Description", obj.description);
+		setCoreParameter(str + ".Category", obj.category);
+		setCoreParameter(str + ".KMSKeyId", obj.kMSKeyId);
+		setCoreParameter(str + ".Device", obj.device);
+		setCoreParameter(str + ".DeleteWithInstance", obj.deleteWithInstance ? "true" : "false");
 	}
 }
 
@@ -291,7 +317,7 @@ std::string ModifyScalingConfigurationRequest::getScalingConfigurationName()cons
 void ModifyScalingConfigurationRequest::setScalingConfigurationName(const std::string& scalingConfigurationName)
 {
 	scalingConfigurationName_ = scalingConfigurationName;
-	setParameter("ScalingConfigurationName", scalingConfigurationName);
+	setCoreParameter("ScalingConfigurationName", scalingConfigurationName);
 }
 
 std::string ModifyScalingConfigurationRequest::getTags()const
@@ -302,7 +328,7 @@ std::string ModifyScalingConfigurationRequest::getTags()const
 void ModifyScalingConfigurationRequest::setTags(const std::string& tags)
 {
 	tags_ = tags;
-	setParameter("Tags", tags);
+	setCoreParameter("Tags", tags);
 }
 
 std::string ModifyScalingConfigurationRequest::getScalingConfigurationId()const
@@ -313,7 +339,7 @@ std::string ModifyScalingConfigurationRequest::getScalingConfigurationId()const
 void ModifyScalingConfigurationRequest::setScalingConfigurationId(const std::string& scalingConfigurationId)
 {
 	scalingConfigurationId_ = scalingConfigurationId;
-	setParameter("ScalingConfigurationId", scalingConfigurationId);
+	setCoreParameter("ScalingConfigurationId", scalingConfigurationId);
 }
 
 std::string ModifyScalingConfigurationRequest::getSpotStrategy()const
@@ -324,7 +350,7 @@ std::string ModifyScalingConfigurationRequest::getSpotStrategy()const
 void ModifyScalingConfigurationRequest::setSpotStrategy(const std::string& spotStrategy)
 {
 	spotStrategy_ = spotStrategy;
-	setParameter("SpotStrategy", spotStrategy);
+	setCoreParameter("SpotStrategy", spotStrategy);
 }
 
 std::string ModifyScalingConfigurationRequest::getInstanceName()const
@@ -335,7 +361,7 @@ std::string ModifyScalingConfigurationRequest::getInstanceName()const
 void ModifyScalingConfigurationRequest::setInstanceName(const std::string& instanceName)
 {
 	instanceName_ = instanceName;
-	setParameter("InstanceName", instanceName);
+	setCoreParameter("InstanceName", instanceName);
 }
 
 int ModifyScalingConfigurationRequest::getLoadBalancerWeight()const
@@ -346,7 +372,7 @@ int ModifyScalingConfigurationRequest::getLoadBalancerWeight()const
 void ModifyScalingConfigurationRequest::setLoadBalancerWeight(int loadBalancerWeight)
 {
 	loadBalancerWeight_ = loadBalancerWeight;
-	setParameter("LoadBalancerWeight", std::to_string(loadBalancerWeight));
+	setCoreParameter("LoadBalancerWeight", std::to_string(loadBalancerWeight));
 }
 
 int ModifyScalingConfigurationRequest::getSystemDiskSize()const
@@ -357,7 +383,7 @@ int ModifyScalingConfigurationRequest::getSystemDiskSize()const
 void ModifyScalingConfigurationRequest::setSystemDiskSize(int systemDiskSize)
 {
 	systemDiskSize_ = systemDiskSize;
-	setParameter("SystemDiskSize", std::to_string(systemDiskSize));
+	setCoreParameter("SystemDiskSize", std::to_string(systemDiskSize));
 }
 
 std::string ModifyScalingConfigurationRequest::getInternetChargeType()const
@@ -368,6 +394,17 @@ std::string ModifyScalingConfigurationRequest::getInternetChargeType()const
 void ModifyScalingConfigurationRequest::setInternetChargeType(const std::string& internetChargeType)
 {
 	internetChargeType_ = internetChargeType;
-	setParameter("InternetChargeType", internetChargeType);
+	setCoreParameter("InternetChargeType", internetChargeType);
+}
+
+std::string ModifyScalingConfigurationRequest::getSystemDiskDescription()const
+{
+	return systemDiskDescription_;
+}
+
+void ModifyScalingConfigurationRequest::setSystemDiskDescription(const std::string& systemDiskDescription)
+{
+	systemDiskDescription_ = systemDiskDescription;
+	setCoreParameter("SystemDiskDescription", systemDiskDescription);
 }
 

ess/src/model/ModifyScalingGroupRequest.cc

@@ -33,7 +33,7 @@ long ModifyScalingGroupRequest::getResourceOwnerId()const
 void ModifyScalingGroupRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string ModifyScalingGroupRequest::getHealthCheckType()const
@@ -44,7 +44,7 @@ std::string ModifyScalingGroupRequest::getHealthCheckType()const
 void ModifyScalingGroupRequest::setHealthCheckType(const std::string& healthCheckType)
 {
 	healthCheckType_ = healthCheckType;
-	setParameter("HealthCheckType", healthCheckType);
+	setCoreParameter("HealthCheckType", healthCheckType);
 }
 
 std::string ModifyScalingGroupRequest::getLaunchTemplateId()const
@@ -55,7 +55,7 @@ std::string ModifyScalingGroupRequest::getLaunchTemplateId()const
 void ModifyScalingGroupRequest::setLaunchTemplateId(const std::string& launchTemplateId)
 {
 	launchTemplateId_ = launchTemplateId;
-	setParameter("LaunchTemplateId", launchTemplateId);
+	setCoreParameter("LaunchTemplateId", launchTemplateId);
 }
 
 std::string ModifyScalingGroupRequest::getResourceOwnerAccount()const
@@ -66,7 +66,7 @@ std::string ModifyScalingGroupRequest::getResourceOwnerAccount()const
 void ModifyScalingGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string ModifyScalingGroupRequest::getScalingGroupName()const
@@ -77,7 +77,7 @@ std::string ModifyScalingGroupRequest::getScalingGroupName()const
 void ModifyScalingGroupRequest::setScalingGroupName(const std::string& scalingGroupName)
 {
 	scalingGroupName_ = scalingGroupName;
-	setParameter("ScalingGroupName", scalingGroupName);
+	setCoreParameter("ScalingGroupName", scalingGroupName);
 }
 
 std::string ModifyScalingGroupRequest::getScalingGroupId()const
@@ -88,7 +88,19 @@ std::string ModifyScalingGroupRequest::getScalingGroupId()const
 void ModifyScalingGroupRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
+}
+
+std::vector<std::string> ModifyScalingGroupRequest::getVSwitchIds()const
+{
+	return vSwitchIds_;
+}
+
+void ModifyScalingGroupRequest::setVSwitchIds(const std::vector<std::string>& vSwitchIds)
+{
+	vSwitchIds_ = vSwitchIds;
+	for(int i = 0; i!= vSwitchIds.size(); i++)
+		setCoreParameter("VSwitchIds."+ std::to_string(i), vSwitchIds.at(i));
 }
 
 std::string ModifyScalingGroupRequest::getOwnerAccount()const
@@ -99,7 +111,7 @@ std::string ModifyScalingGroupRequest::getOwnerAccount()const
 void ModifyScalingGroupRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 std::string ModifyScalingGroupRequest::getActiveScalingConfigurationId()const
@@ -110,7 +122,7 @@ std::string ModifyScalingGroupRequest::getActiveScalingConfigurationId()const
 void ModifyScalingGroupRequest::setActiveScalingConfigurationId(const std::string& activeScalingConfigurationId)
 {
 	activeScalingConfigurationId_ = activeScalingConfigurationId;
-	setParameter("ActiveScalingConfigurationId", activeScalingConfigurationId);
+	setCoreParameter("ActiveScalingConfigurationId", activeScalingConfigurationId);
 }
 
 int ModifyScalingGroupRequest::getMinSize()const
@@ -121,7 +133,7 @@ int ModifyScalingGroupRequest::getMinSize()const
 void ModifyScalingGroupRequest::setMinSize(int minSize)
 {
 	minSize_ = minSize;
-	setParameter("MinSize", std::to_string(minSize));
+	setCoreParameter("MinSize", std::to_string(minSize));
 }
 
 long ModifyScalingGroupRequest::getOwnerId()const
@@ -132,7 +144,7 @@ long ModifyScalingGroupRequest::getOwnerId()const
 void ModifyScalingGroupRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string ModifyScalingGroupRequest::getLaunchTemplateVersion()const
@@ -143,7 +155,7 @@ std::string ModifyScalingGroupRequest::getLaunchTemplateVersion()const
 void ModifyScalingGroupRequest::setLaunchTemplateVersion(const std::string& launchTemplateVersion)
 {
 	launchTemplateVersion_ = launchTemplateVersion;
-	setParameter("LaunchTemplateVersion", launchTemplateVersion);
+	setCoreParameter("LaunchTemplateVersion", launchTemplateVersion);
 }
 
 std::string ModifyScalingGroupRequest::getAccessKeyId()const
@@ -154,7 +166,7 @@ std::string ModifyScalingGroupRequest::getAccessKeyId()const
 void ModifyScalingGroupRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 int ModifyScalingGroupRequest::getMaxSize()const
@@ -165,7 +177,7 @@ int ModifyScalingGroupRequest::getMaxSize()const
 void ModifyScalingGroupRequest::setMaxSize(int maxSize)
 {
 	maxSize_ = maxSize;
-	setParameter("MaxSize", std::to_string(maxSize));
+	setCoreParameter("MaxSize", std::to_string(maxSize));
 }
 
 int ModifyScalingGroupRequest::getDefaultCooldown()const
@@ -176,7 +188,7 @@ int ModifyScalingGroupRequest::getDefaultCooldown()const
 void ModifyScalingGroupRequest::setDefaultCooldown(int defaultCooldown)
 {
 	defaultCooldown_ = defaultCooldown;
-	setParameter("DefaultCooldown", std::to_string(defaultCooldown));
+	setCoreParameter("DefaultCooldown", std::to_string(defaultCooldown));
 }
 
 std::string ModifyScalingGroupRequest::getRemovalPolicy1()const
@@ -187,7 +199,7 @@ std::string ModifyScalingGroupRequest::getRemovalPolicy1()const
 void ModifyScalingGroupRequest::setRemovalPolicy1(const std::string& removalPolicy1)
 {
 	removalPolicy1_ = removalPolicy1;
-	setParameter("RemovalPolicy1", removalPolicy1);
+	setCoreParameter("RemovalPolicy1", removalPolicy1);
 }
 
 std::string ModifyScalingGroupRequest::getRemovalPolicy2()const
@@ -198,6 +210,6 @@ std::string ModifyScalingGroupRequest::getRemovalPolicy2()const
 void ModifyScalingGroupRequest::setRemovalPolicy2(const std::string& removalPolicy2)
 {
 	removalPolicy2_ = removalPolicy2;
-	setParameter("RemovalPolicy2", removalPolicy2);
+	setCoreParameter("RemovalPolicy2", removalPolicy2);
 }
 

ess/src/model/ModifyScalingRuleRequest.cc

@@ -25,17 +25,6 @@ ModifyScalingRuleRequest::ModifyScalingRuleRequest() :
 ModifyScalingRuleRequest::~ModifyScalingRuleRequest()
 {}
 
-std::string ModifyScalingRuleRequest::getScalingRuleName()const
-{
-	return scalingRuleName_;
-}
-
-void ModifyScalingRuleRequest::setScalingRuleName(const std::string& scalingRuleName)
-{
-	scalingRuleName_ = scalingRuleName;
-	setParameter("ScalingRuleName", scalingRuleName);
-}
-
 long ModifyScalingRuleRequest::getResourceOwnerId()const
 {
 	return resourceOwnerId_;
@@ -44,7 +33,7 @@ long ModifyScalingRuleRequest::getResourceOwnerId()const
 void ModifyScalingRuleRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string ModifyScalingRuleRequest::getResourceOwnerAccount()const
@@ -55,7 +44,7 @@ std::string ModifyScalingRuleRequest::getResourceOwnerAccount()const
 void ModifyScalingRuleRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 int ModifyScalingRuleRequest::getAdjustmentValue()const
@@ -66,29 +55,47 @@ int ModifyScalingRuleRequest::getAdjustmentValue()const
 void ModifyScalingRuleRequest::setAdjustmentValue(int adjustmentValue)
 {
 	adjustmentValue_ = adjustmentValue;
-	setParameter("AdjustmentValue", std::to_string(adjustmentValue));
+	setCoreParameter("AdjustmentValue", std::to_string(adjustmentValue));
 }
 
-std::string ModifyScalingRuleRequest::getOwnerAccount()const
+std::vector<ModifyScalingRuleRequest::StepAdjustment> ModifyScalingRuleRequest::getStepAdjustment()const
 {
-	return ownerAccount_;
+	return stepAdjustment_;
 }
 
-void ModifyScalingRuleRequest::setOwnerAccount(const std::string& ownerAccount)
+void ModifyScalingRuleRequest::setStepAdjustment(const std::vector<StepAdjustment>& stepAdjustment)
 {
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	stepAdjustment_ = stepAdjustment;
+	int i = 0;
+	for(int i = 0; i!= stepAdjustment.size(); i++)	{
+		auto obj = stepAdjustment.at(i);
+		std::string str ="StepAdjustment."+ std::to_string(i);
+		setCoreParameter(str + ".MetricIntervalLowerBound", std::to_string(obj.metricIntervalLowerBound));
+		setCoreParameter(str + ".MetricIntervalUpperBound", std::to_string(obj.metricIntervalUpperBound));
+		setCoreParameter(str + ".ScalingAdjustment", std::to_string(obj.scalingAdjustment));
+	}
 }
 
-int ModifyScalingRuleRequest::getCooldown()const
+int ModifyScalingRuleRequest::getEstimatedInstanceWarmup()const
 {
-	return cooldown_;
+	return estimatedInstanceWarmup_;
 }
 
-void ModifyScalingRuleRequest::setCooldown(int cooldown)
+void ModifyScalingRuleRequest::setEstimatedInstanceWarmup(int estimatedInstanceWarmup)
 {
-	cooldown_ = cooldown;
-	setParameter("Cooldown", std::to_string(cooldown));
+	estimatedInstanceWarmup_ = estimatedInstanceWarmup;
+	setCoreParameter("EstimatedInstanceWarmup", std::to_string(estimatedInstanceWarmup));
+}
+
+std::string ModifyScalingRuleRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void ModifyScalingRuleRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 std::string ModifyScalingRuleRequest::getAdjustmentType()const
@@ -99,7 +106,18 @@ std::string ModifyScalingRuleRequest::getAdjustmentType()const
 void ModifyScalingRuleRequest::setAdjustmentType(const std::string& adjustmentType)
 {
 	adjustmentType_ = adjustmentType;
-	setParameter("AdjustmentType", adjustmentType);
+	setCoreParameter("AdjustmentType", adjustmentType);
+}
+
+bool ModifyScalingRuleRequest::getDisableScaleIn()const
+{
+	return disableScaleIn_;
+}
+
+void ModifyScalingRuleRequest::setDisableScaleIn(bool disableScaleIn)
+{
+	disableScaleIn_ = disableScaleIn;
+	setCoreParameter("DisableScaleIn", disableScaleIn ? "true" : "false");
 }
 
 long ModifyScalingRuleRequest::getOwnerId()const
@@ -110,7 +128,7 @@ long ModifyScalingRuleRequest::getOwnerId()const
 void ModifyScalingRuleRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string ModifyScalingRuleRequest::getScalingRuleId()const
@@ -121,7 +139,7 @@ std::string ModifyScalingRuleRequest::getScalingRuleId()const
 void ModifyScalingRuleRequest::setScalingRuleId(const std::string& scalingRuleId)
 {
 	scalingRuleId_ = scalingRuleId;
-	setParameter("ScalingRuleId", scalingRuleId);
+	setCoreParameter("ScalingRuleId", scalingRuleId);
 }
 
 std::string ModifyScalingRuleRequest::getAccessKeyId()const
@@ -132,6 +150,61 @@ std::string ModifyScalingRuleRequest::getAccessKeyId()const
 void ModifyScalingRuleRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
+}
+
+std::string ModifyScalingRuleRequest::getScalingRuleName()const
+{
+	return scalingRuleName_;
+}
+
+void ModifyScalingRuleRequest::setScalingRuleName(const std::string& scalingRuleName)
+{
+	scalingRuleName_ = scalingRuleName;
+	setCoreParameter("ScalingRuleName", scalingRuleName);
+}
+
+int ModifyScalingRuleRequest::getCooldown()const
+{
+	return cooldown_;
+}
+
+void ModifyScalingRuleRequest::setCooldown(int cooldown)
+{
+	cooldown_ = cooldown;
+	setCoreParameter("Cooldown", std::to_string(cooldown));
+}
+
+int ModifyScalingRuleRequest::getMinAdjustmentMagnitude()const
+{
+	return minAdjustmentMagnitude_;
+}
+
+void ModifyScalingRuleRequest::setMinAdjustmentMagnitude(int minAdjustmentMagnitude)
+{
+	minAdjustmentMagnitude_ = minAdjustmentMagnitude;
+	setCoreParameter("MinAdjustmentMagnitude", std::to_string(minAdjustmentMagnitude));
+}
+
+float ModifyScalingRuleRequest::getTargetValue()const
+{
+	return targetValue_;
+}
+
+void ModifyScalingRuleRequest::setTargetValue(float targetValue)
+{
+	targetValue_ = targetValue;
+	setCoreParameter("TargetValue", std::to_string(targetValue));
+}
+
+std::string ModifyScalingRuleRequest::getMetricName()const
+{
+	return metricName_;
+}
+
+void ModifyScalingRuleRequest::setMetricName(const std::string& metricName)
+{
+	metricName_ = metricName;
+	setCoreParameter("MetricName", metricName);
 }
 

ess/src/model/ModifyScheduledTaskRequest.cc

@@ -33,7 +33,7 @@ std::string ModifyScheduledTaskRequest::getLaunchTime()const
 void ModifyScheduledTaskRequest::setLaunchTime(const std::string& launchTime)
 {
 	launchTime_ = launchTime;
-	setParameter("LaunchTime", launchTime);
+	setCoreParameter("LaunchTime", launchTime);
 }
 
 long ModifyScheduledTaskRequest::getResourceOwnerId()const
@@ -44,7 +44,7 @@ long ModifyScheduledTaskRequest::getResourceOwnerId()const
 void ModifyScheduledTaskRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string ModifyScheduledTaskRequest::getScheduledAction()const
@@ -55,7 +55,7 @@ std::string ModifyScheduledTaskRequest::getScheduledAction()const
 void ModifyScheduledTaskRequest::setScheduledAction(const std::string& scheduledAction)
 {
 	scheduledAction_ = scheduledAction;
-	setParameter("ScheduledAction", scheduledAction);
+	setCoreParameter("ScheduledAction", scheduledAction);
 }
 
 std::string ModifyScheduledTaskRequest::getResourceOwnerAccount()const
@@ -66,7 +66,7 @@ std::string ModifyScheduledTaskRequest::getResourceOwnerAccount()const
 void ModifyScheduledTaskRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string ModifyScheduledTaskRequest::getOwnerAccount()const
@@ -77,7 +77,7 @@ std::string ModifyScheduledTaskRequest::getOwnerAccount()const
 void ModifyScheduledTaskRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 std::string ModifyScheduledTaskRequest::getDescription()const
@@ -88,7 +88,7 @@ std::string ModifyScheduledTaskRequest::getDescription()const
 void ModifyScheduledTaskRequest::setDescription(const std::string& description)
 {
 	description_ = description;
-	setParameter("Description", description);
+	setCoreParameter("Description", description);
 }
 
 long ModifyScheduledTaskRequest::getOwnerId()const
@@ -99,7 +99,7 @@ long ModifyScheduledTaskRequest::getOwnerId()const
 void ModifyScheduledTaskRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string ModifyScheduledTaskRequest::getRecurrenceValue()const
@@ -110,7 +110,7 @@ std::string ModifyScheduledTaskRequest::getRecurrenceValue()const
 void ModifyScheduledTaskRequest::setRecurrenceValue(const std::string& recurrenceValue)
 {
 	recurrenceValue_ = recurrenceValue;
-	setParameter("RecurrenceValue", recurrenceValue);
+	setCoreParameter("RecurrenceValue", recurrenceValue);
 }
 
 int ModifyScheduledTaskRequest::getLaunchExpirationTime()const
@@ -121,7 +121,7 @@ int ModifyScheduledTaskRequest::getLaunchExpirationTime()const
 void ModifyScheduledTaskRequest::setLaunchExpirationTime(int launchExpirationTime)
 {
 	launchExpirationTime_ = launchExpirationTime;
-	setParameter("LaunchExpirationTime", std::to_string(launchExpirationTime));
+	setCoreParameter("LaunchExpirationTime", std::to_string(launchExpirationTime));
 }
 
 std::string ModifyScheduledTaskRequest::getRecurrenceEndTime()const
@@ -132,7 +132,7 @@ std::string ModifyScheduledTaskRequest::getRecurrenceEndTime()const
 void ModifyScheduledTaskRequest::setRecurrenceEndTime(const std::string& recurrenceEndTime)
 {
 	recurrenceEndTime_ = recurrenceEndTime;
-	setParameter("RecurrenceEndTime", recurrenceEndTime);
+	setCoreParameter("RecurrenceEndTime", recurrenceEndTime);
 }
 
 std::string ModifyScheduledTaskRequest::getAccessKeyId()const
@@ -143,7 +143,7 @@ std::string ModifyScheduledTaskRequest::getAccessKeyId()const
 void ModifyScheduledTaskRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 std::string ModifyScheduledTaskRequest::getScheduledTaskName()const
@@ -154,7 +154,7 @@ std::string ModifyScheduledTaskRequest::getScheduledTaskName()const
 void ModifyScheduledTaskRequest::setScheduledTaskName(const std::string& scheduledTaskName)
 {
 	scheduledTaskName_ = scheduledTaskName;
-	setParameter("ScheduledTaskName", scheduledTaskName);
+	setCoreParameter("ScheduledTaskName", scheduledTaskName);
 }
 
 bool ModifyScheduledTaskRequest::getTaskEnabled()const
@@ -165,7 +165,7 @@ bool ModifyScheduledTaskRequest::getTaskEnabled()const
 void ModifyScheduledTaskRequest::setTaskEnabled(bool taskEnabled)
 {
 	taskEnabled_ = taskEnabled;
-	setParameter("TaskEnabled", std::to_string(taskEnabled));
+	setCoreParameter("TaskEnabled", taskEnabled ? "true" : "false");
 }
 
 std::string ModifyScheduledTaskRequest::getScheduledTaskId()const
@@ -176,7 +176,7 @@ std::string ModifyScheduledTaskRequest::getScheduledTaskId()const
 void ModifyScheduledTaskRequest::setScheduledTaskId(const std::string& scheduledTaskId)
 {
 	scheduledTaskId_ = scheduledTaskId;
-	setParameter("ScheduledTaskId", scheduledTaskId);
+	setCoreParameter("ScheduledTaskId", scheduledTaskId);
 }
 
 std::string ModifyScheduledTaskRequest::getRecurrenceType()const
@@ -187,6 +187,6 @@ std::string ModifyScheduledTaskRequest::getRecurrenceType()const
 void ModifyScheduledTaskRequest::setRecurrenceType(const std::string& recurrenceType)
 {
 	recurrenceType_ = recurrenceType;
-	setParameter("RecurrenceType", recurrenceType);
+	setCoreParameter("RecurrenceType", recurrenceType);
 }
 

ess/src/model/RebalanceInstancesRequest.cc

@@ -33,7 +33,7 @@ long RebalanceInstancesRequest::getResourceOwnerId()const
 void RebalanceInstancesRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string RebalanceInstancesRequest::getResourceOwnerAccount()const
@@ -44,7 +44,7 @@ std::string RebalanceInstancesRequest::getResourceOwnerAccount()const
 void RebalanceInstancesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string RebalanceInstancesRequest::getScalingGroupId()const
@@ -55,7 +55,7 @@ std::string RebalanceInstancesRequest::getScalingGroupId()const
 void RebalanceInstancesRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 std::string RebalanceInstancesRequest::getOwnerAccount()const
@@ -66,7 +66,7 @@ std::string RebalanceInstancesRequest::getOwnerAccount()const
 void RebalanceInstancesRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 long RebalanceInstancesRequest::getOwnerId()const
@@ -77,7 +77,7 @@ long RebalanceInstancesRequest::getOwnerId()const
 void RebalanceInstancesRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string RebalanceInstancesRequest::getAccessKeyId()const
@@ -88,6 +88,6 @@ std::string RebalanceInstancesRequest::getAccessKeyId()const
 void RebalanceInstancesRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/RecordLifecycleActionHeartbeatRequest.cc

@@ -33,7 +33,7 @@ std::string RecordLifecycleActionHeartbeatRequest::getLifecycleActionToken()cons
 void RecordLifecycleActionHeartbeatRequest::setLifecycleActionToken(const std::string& lifecycleActionToken)
 {
 	lifecycleActionToken_ = lifecycleActionToken;
-	setParameter("LifecycleActionToken", lifecycleActionToken);
+	setCoreParameter("LifecycleActionToken", lifecycleActionToken);
 }
 
 std::string RecordLifecycleActionHeartbeatRequest::getResourceOwnerAccount()const
@@ -44,7 +44,7 @@ std::string RecordLifecycleActionHeartbeatRequest::getResourceOwnerAccount()cons
 void RecordLifecycleActionHeartbeatRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 int RecordLifecycleActionHeartbeatRequest::getHeartbeatTimeout()const
@@ -55,7 +55,7 @@ int RecordLifecycleActionHeartbeatRequest::getHeartbeatTimeout()const
 void RecordLifecycleActionHeartbeatRequest::setHeartbeatTimeout(int heartbeatTimeout)
 {
 	heartbeatTimeout_ = heartbeatTimeout;
-	setParameter("HeartbeatTimeout", std::to_string(heartbeatTimeout));
+	setCoreParameter("HeartbeatTimeout", std::to_string(heartbeatTimeout));
 }
 
 std::string RecordLifecycleActionHeartbeatRequest::getLifecycleHookId()const
@@ -66,7 +66,7 @@ std::string RecordLifecycleActionHeartbeatRequest::getLifecycleHookId()const
 void RecordLifecycleActionHeartbeatRequest::setLifecycleHookId(const std::string& lifecycleHookId)
 {
 	lifecycleHookId_ = lifecycleHookId;
-	setParameter("LifecycleHookId", lifecycleHookId);
+	setCoreParameter("LifecycleHookId", lifecycleHookId);
 }
 
 std::string RecordLifecycleActionHeartbeatRequest::getOwnerAccount()const
@@ -77,7 +77,7 @@ std::string RecordLifecycleActionHeartbeatRequest::getOwnerAccount()const
 void RecordLifecycleActionHeartbeatRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	setCoreParameter("OwnerAccount", ownerAccount);
 }
 
 long RecordLifecycleActionHeartbeatRequest::getOwnerId()const
@@ -88,7 +88,7 @@ long RecordLifecycleActionHeartbeatRequest::getOwnerId()const
 void RecordLifecycleActionHeartbeatRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string RecordLifecycleActionHeartbeatRequest::getAccessKeyId()const
@@ -99,6 +99,6 @@ std::string RecordLifecycleActionHeartbeatRequest::getAccessKeyId()const
 void RecordLifecycleActionHeartbeatRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/RemoveInstancesRequest.cc

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

ess/src/model/SetInstancesProtectionRequest.cc

@@ -34,7 +34,7 @@ void SetInstancesProtectionRequest::setInstanceId(const std::vector<std::string>
 {
 	instanceId_ = instanceId;
 	for(int i = 0; i!= instanceId.size(); i++)
-		setParameter("InstanceId."+ std::to_string(i), instanceId.at(i));
+		setCoreParameter("InstanceId."+ std::to_string(i), instanceId.at(i));
 }
 
 std::string SetInstancesProtectionRequest::getResourceOwnerAccount()const
@@ -45,7 +45,7 @@ std::string SetInstancesProtectionRequest::getResourceOwnerAccount()const
 void SetInstancesProtectionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 std::string SetInstancesProtectionRequest::getScalingGroupId()const
@@ -56,7 +56,7 @@ std::string SetInstancesProtectionRequest::getScalingGroupId()const
 void SetInstancesProtectionRequest::setScalingGroupId(const std::string& scalingGroupId)
 {
 	scalingGroupId_ = scalingGroupId;
-	setParameter("ScalingGroupId", scalingGroupId);
+	setCoreParameter("ScalingGroupId", scalingGroupId);
 }
 
 long SetInstancesProtectionRequest::getOwnerId()const
@@ -67,7 +67,7 @@ long SetInstancesProtectionRequest::getOwnerId()const
 void SetInstancesProtectionRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string SetInstancesProtectionRequest::getAccessKeyId()const
@@ -78,7 +78,7 @@ std::string SetInstancesProtectionRequest::getAccessKeyId()const
 void SetInstancesProtectionRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 
 bool SetInstancesProtectionRequest::getProtectedFromScaleIn()const
@@ -89,6 +89,6 @@ bool SetInstancesProtectionRequest::getProtectedFromScaleIn()const
 void SetInstancesProtectionRequest::setProtectedFromScaleIn(bool protectedFromScaleIn)
 {
 	protectedFromScaleIn_ = protectedFromScaleIn;
-	setParameter("ProtectedFromScaleIn", std::to_string(protectedFromScaleIn));
+	setCoreParameter("ProtectedFromScaleIn", protectedFromScaleIn ? "true" : "false");
 }
 

ess/src/model/VerifyAuthenticationRequest.cc

@@ -33,7 +33,7 @@ long VerifyAuthenticationRequest::getUid()const
 void VerifyAuthenticationRequest::setUid(long uid)
 {
 	uid_ = uid;
-	setParameter("Uid", std::to_string(uid));
+	setCoreParameter("Uid", std::to_string(uid));
 }
 
 long VerifyAuthenticationRequest::getResourceOwnerId()const
@@ -44,7 +44,7 @@ long VerifyAuthenticationRequest::getResourceOwnerId()const
 void VerifyAuthenticationRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string VerifyAuthenticationRequest::getResourceOwnerAccount()const
@@ -55,7 +55,7 @@ std::string VerifyAuthenticationRequest::getResourceOwnerAccount()const
 void VerifyAuthenticationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 long VerifyAuthenticationRequest::getOwnerId()const
@@ -66,7 +66,7 @@ long VerifyAuthenticationRequest::getOwnerId()const
 void VerifyAuthenticationRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string VerifyAuthenticationRequest::getAccessKeyId()const
@@ -77,6 +77,6 @@ std::string VerifyAuthenticationRequest::getAccessKeyId()const
 void VerifyAuthenticationRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }
 

ess/src/model/VerifyUserRequest.cc

@@ -33,7 +33,7 @@ long VerifyUserRequest::getResourceOwnerId()const
 void VerifyUserRequest::setResourceOwnerId(long resourceOwnerId)
 {
 	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
 std::string VerifyUserRequest::getResourceOwnerAccount()const
@@ -44,7 +44,7 @@ std::string VerifyUserRequest::getResourceOwnerAccount()const
 void VerifyUserRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
 {
 	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
 long VerifyUserRequest::getOwnerId()const
@@ -55,7 +55,7 @@ long VerifyUserRequest::getOwnerId()const
 void VerifyUserRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	setCoreParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string VerifyUserRequest::getAccessKeyId()const
@@ -66,6 +66,6 @@ std::string VerifyUserRequest::getAccessKeyId()const
 void VerifyUserRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	setCoreParameter("AccessKeyId", accessKeyId);
 }