由丰鲁成发起的ESS SDK自动发布, BUILD_ID=349, 版本号：1.0.5

发布日志：
1, First commit ess module

CMakeLists.txt

@@ -55,4 +55,5 @@ add_subdirectory(slb)
 add_subdirectory(vpc)
 add_subdirectory(cdn)
 add_subdirectory(rds)
-add_subdirectory(cloudphoto)
+add_subdirectory(cloudphoto)
+add_subdirectory(ess)

VERSION

@@ -1 +1 @@
-1.0.4
+1.0.5

ess/CMakeLists.txt

@@ -0,0 +1,206 @@
+#
+# 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.
+#
+
+set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
+set(ess_public_header
+	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/DescribeScalingActivitiesRequest.h
+	include/alibabacloud/ess/model/DescribeScalingActivitiesResult.h
+	include/alibabacloud/ess/model/DescribeScalingRulesRequest.h
+	include/alibabacloud/ess/model/DescribeScalingRulesResult.h
+	include/alibabacloud/ess/model/ModifyScalingGroupRequest.h
+	include/alibabacloud/ess/model/ModifyScalingGroupResult.h
+	include/alibabacloud/ess/model/EnableScalingGroupRequest.h
+	include/alibabacloud/ess/model/EnableScalingGroupResult.h
+	include/alibabacloud/ess/model/DeactivateScalingConfigurationRequest.h
+	include/alibabacloud/ess/model/DeactivateScalingConfigurationResult.h
+	include/alibabacloud/ess/model/VerifyAuthenticationRequest.h
+	include/alibabacloud/ess/model/VerifyAuthenticationResult.h
+	include/alibabacloud/ess/model/CreateScheduledTaskRequest.h
+	include/alibabacloud/ess/model/CreateScheduledTaskResult.h
+	include/alibabacloud/ess/model/DeleteScheduledTaskRequest.h
+	include/alibabacloud/ess/model/DeleteScheduledTaskResult.h
+	include/alibabacloud/ess/model/CreateScalingRuleRequest.h
+	include/alibabacloud/ess/model/CreateScalingRuleResult.h
+	include/alibabacloud/ess/model/DescribeScalingConfigurationsRequest.h
+	include/alibabacloud/ess/model/DescribeScalingConfigurationsResult.h
+	include/alibabacloud/ess/model/ModifyScheduledTaskRequest.h
+	include/alibabacloud/ess/model/ModifyScheduledTaskResult.h
+	include/alibabacloud/ess/model/RemoveInstancesRequest.h
+	include/alibabacloud/ess/model/RemoveInstancesResult.h
+	include/alibabacloud/ess/model/ExecuteScalingRuleRequest.h
+	include/alibabacloud/ess/model/ExecuteScalingRuleResult.h
+	include/alibabacloud/ess/model/DeleteScalingGroupRequest.h
+	include/alibabacloud/ess/model/DeleteScalingGroupResult.h
+	include/alibabacloud/ess/model/DescribeScalingInstancesRequest.h
+	include/alibabacloud/ess/model/DescribeScalingInstancesResult.h
+	include/alibabacloud/ess/model/CreateScalingConfigurationRequest.h
+	include/alibabacloud/ess/model/CreateScalingConfigurationResult.h
+	include/alibabacloud/ess/model/DescribeCapacityHistoryRequest.h
+	include/alibabacloud/ess/model/DescribeCapacityHistoryResult.h
+	include/alibabacloud/ess/model/DescribeRegionsRequest.h
+	include/alibabacloud/ess/model/DescribeRegionsResult.h
+	include/alibabacloud/ess/model/DescribeAccountAttributesRequest.h
+	include/alibabacloud/ess/model/DescribeAccountAttributesResult.h
+	include/alibabacloud/ess/model/DetachInstancesRequest.h
+	include/alibabacloud/ess/model/DetachInstancesResult.h
+	include/alibabacloud/ess/model/DescribeLimitationRequest.h
+	include/alibabacloud/ess/model/DescribeLimitationResult.h
+	include/alibabacloud/ess/model/DescribeScalingActivityDetailRequest.h
+	include/alibabacloud/ess/model/DescribeScalingActivityDetailResult.h
+	include/alibabacloud/ess/model/DescribeAlertConfigRequest.h
+	include/alibabacloud/ess/model/DescribeAlertConfigResult.h
+	include/alibabacloud/ess/model/CreateScalingGroupRequest.h
+	include/alibabacloud/ess/model/CreateScalingGroupResult.h
+	include/alibabacloud/ess/model/DeleteScalingConfigurationRequest.h
+	include/alibabacloud/ess/model/DeleteScalingConfigurationResult.h
+	include/alibabacloud/ess/model/DisableScalingGroupRequest.h
+	include/alibabacloud/ess/model/DisableScalingGroupResult.h
+	include/alibabacloud/ess/model/ModifyScalingRuleRequest.h
+	include/alibabacloud/ess/model/ModifyScalingRuleResult.h
+	include/alibabacloud/ess/model/DeleteScalingRuleRequest.h
+	include/alibabacloud/ess/model/DeleteScalingRuleResult.h
+	include/alibabacloud/ess/model/VerifyUserRequest.h
+	include/alibabacloud/ess/model/VerifyUserResult.h
+	include/alibabacloud/ess/model/ModifyAlertConfigRequest.h
+	include/alibabacloud/ess/model/ModifyAlertConfigResult.h
+	include/alibabacloud/ess/EssClient.h
+	include/alibabacloud/ess/EssExport.h
+	include/alibabacloud/ess/EssRequest.h
+	)
+
+set(ess_src
+	src/model/AttachInstancesRequest.cc
+	src/model/AttachInstancesResult.cc
+	src/model/DescribeScalingGroupsRequest.cc
+	src/model/DescribeScalingGroupsResult.cc
+	src/model/DescribeScalingActivitiesRequest.cc
+	src/model/DescribeScalingActivitiesResult.cc
+	src/model/DescribeScalingRulesRequest.cc
+	src/model/DescribeScalingRulesResult.cc
+	src/model/ModifyScalingGroupRequest.cc
+	src/model/ModifyScalingGroupResult.cc
+	src/model/EnableScalingGroupRequest.cc
+	src/model/EnableScalingGroupResult.cc
+	src/model/DeactivateScalingConfigurationRequest.cc
+	src/model/DeactivateScalingConfigurationResult.cc
+	src/model/VerifyAuthenticationRequest.cc
+	src/model/VerifyAuthenticationResult.cc
+	src/model/CreateScheduledTaskRequest.cc
+	src/model/CreateScheduledTaskResult.cc
+	src/model/DeleteScheduledTaskRequest.cc
+	src/model/DeleteScheduledTaskResult.cc
+	src/model/CreateScalingRuleRequest.cc
+	src/model/CreateScalingRuleResult.cc
+	src/model/DescribeScalingConfigurationsRequest.cc
+	src/model/DescribeScalingConfigurationsResult.cc
+	src/model/ModifyScheduledTaskRequest.cc
+	src/model/ModifyScheduledTaskResult.cc
+	src/model/RemoveInstancesRequest.cc
+	src/model/RemoveInstancesResult.cc
+	src/model/ExecuteScalingRuleRequest.cc
+	src/model/ExecuteScalingRuleResult.cc
+	src/model/DeleteScalingGroupRequest.cc
+	src/model/DeleteScalingGroupResult.cc
+	src/model/DescribeScalingInstancesRequest.cc
+	src/model/DescribeScalingInstancesResult.cc
+	src/model/CreateScalingConfigurationRequest.cc
+	src/model/CreateScalingConfigurationResult.cc
+	src/model/DescribeCapacityHistoryRequest.cc
+	src/model/DescribeCapacityHistoryResult.cc
+	src/model/DescribeRegionsRequest.cc
+	src/model/DescribeRegionsResult.cc
+	src/model/DescribeAccountAttributesRequest.cc
+	src/model/DescribeAccountAttributesResult.cc
+	src/model/DetachInstancesRequest.cc
+	src/model/DetachInstancesResult.cc
+	src/model/DescribeLimitationRequest.cc
+	src/model/DescribeLimitationResult.cc
+	src/model/DescribeScalingActivityDetailRequest.cc
+	src/model/DescribeScalingActivityDetailResult.cc
+	src/model/DescribeAlertConfigRequest.cc
+	src/model/DescribeAlertConfigResult.cc
+	src/model/CreateScalingGroupRequest.cc
+	src/model/CreateScalingGroupResult.cc
+	src/model/DeleteScalingConfigurationRequest.cc
+	src/model/DeleteScalingConfigurationResult.cc
+	src/model/DisableScalingGroupRequest.cc
+	src/model/DisableScalingGroupResult.cc
+	src/model/ModifyScalingRuleRequest.cc
+	src/model/ModifyScalingRuleResult.cc
+	src/model/DeleteScalingRuleRequest.cc
+	src/model/DeleteScalingRuleResult.cc
+	src/model/VerifyUserRequest.cc
+	src/model/VerifyUserResult.cc
+	src/model/ModifyAlertConfigRequest.cc
+	src/model/ModifyAlertConfigResult.cc
+	src/EssClient.cc
+	src/EssRequest.cc
+	)
+
+add_library(ess ${LIB_TYPE} ${ess_public_header} ${ess_src})
+
+set_target_properties(ess
+	PROPERTIES
+	LINKER_LANGUAGE CXX
+	ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+	OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}ess
+	PUBLIC_HEADER "${ess_public_header}"
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(ess
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_ESS_LIBRARY)
+endif()
+
+target_include_directories(ess
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(ess
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(ess
+		jsoncpp)
+	target_include_directories(ess
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(ess
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(ess
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(ess
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(ess
+		jsoncpp)
+endif()
+
+install(TARGETS ess
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/ess
+	)

ess/ChangeLog.txt

@@ -0,0 +1,3 @@
+2018-01-12 Version: 1.0.5
+1, First commit ess module
+

ess/include/alibabacloud/ess/EssClient.h

@@ -0,0 +1,305 @@
+/*
+ * 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_ESSCLIENT_H_
+#define ALIBABACLOUD_ESS_ESSCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "EssExport.h"
+#include "model/AttachInstancesRequest.h"
+#include "model/AttachInstancesResult.h"
+#include "model/DescribeScalingGroupsRequest.h"
+#include "model/DescribeScalingGroupsResult.h"
+#include "model/DescribeScalingActivitiesRequest.h"
+#include "model/DescribeScalingActivitiesResult.h"
+#include "model/DescribeScalingRulesRequest.h"
+#include "model/DescribeScalingRulesResult.h"
+#include "model/ModifyScalingGroupRequest.h"
+#include "model/ModifyScalingGroupResult.h"
+#include "model/EnableScalingGroupRequest.h"
+#include "model/EnableScalingGroupResult.h"
+#include "model/DeactivateScalingConfigurationRequest.h"
+#include "model/DeactivateScalingConfigurationResult.h"
+#include "model/VerifyAuthenticationRequest.h"
+#include "model/VerifyAuthenticationResult.h"
+#include "model/CreateScheduledTaskRequest.h"
+#include "model/CreateScheduledTaskResult.h"
+#include "model/DeleteScheduledTaskRequest.h"
+#include "model/DeleteScheduledTaskResult.h"
+#include "model/CreateScalingRuleRequest.h"
+#include "model/CreateScalingRuleResult.h"
+#include "model/DescribeScalingConfigurationsRequest.h"
+#include "model/DescribeScalingConfigurationsResult.h"
+#include "model/ModifyScheduledTaskRequest.h"
+#include "model/ModifyScheduledTaskResult.h"
+#include "model/RemoveInstancesRequest.h"
+#include "model/RemoveInstancesResult.h"
+#include "model/ExecuteScalingRuleRequest.h"
+#include "model/ExecuteScalingRuleResult.h"
+#include "model/DeleteScalingGroupRequest.h"
+#include "model/DeleteScalingGroupResult.h"
+#include "model/DescribeScalingInstancesRequest.h"
+#include "model/DescribeScalingInstancesResult.h"
+#include "model/CreateScalingConfigurationRequest.h"
+#include "model/CreateScalingConfigurationResult.h"
+#include "model/DescribeCapacityHistoryRequest.h"
+#include "model/DescribeCapacityHistoryResult.h"
+#include "model/DescribeRegionsRequest.h"
+#include "model/DescribeRegionsResult.h"
+#include "model/DescribeAccountAttributesRequest.h"
+#include "model/DescribeAccountAttributesResult.h"
+#include "model/DetachInstancesRequest.h"
+#include "model/DetachInstancesResult.h"
+#include "model/DescribeLimitationRequest.h"
+#include "model/DescribeLimitationResult.h"
+#include "model/DescribeScalingActivityDetailRequest.h"
+#include "model/DescribeScalingActivityDetailResult.h"
+#include "model/DescribeAlertConfigRequest.h"
+#include "model/DescribeAlertConfigResult.h"
+#include "model/CreateScalingGroupRequest.h"
+#include "model/CreateScalingGroupResult.h"
+#include "model/DeleteScalingConfigurationRequest.h"
+#include "model/DeleteScalingConfigurationResult.h"
+#include "model/DisableScalingGroupRequest.h"
+#include "model/DisableScalingGroupResult.h"
+#include "model/ModifyScalingRuleRequest.h"
+#include "model/ModifyScalingRuleResult.h"
+#include "model/DeleteScalingRuleRequest.h"
+#include "model/DeleteScalingRuleResult.h"
+#include "model/VerifyUserRequest.h"
+#include "model/VerifyUserResult.h"
+#include "model/ModifyAlertConfigRequest.h"
+#include "model/ModifyAlertConfigResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		class ALIBABACLOUD_ESS_EXPORT EssClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::AttachInstancesResult> AttachInstancesOutcome;			
+			typedef std::future<AttachInstancesOutcome> AttachInstancesOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::AttachInstancesRequest&, const AttachInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachInstancesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScalingGroupsResult> DescribeScalingGroupsOutcome;			
+			typedef std::future<DescribeScalingGroupsOutcome> DescribeScalingGroupsOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::DescribeScalingGroupsRequest&, const DescribeScalingGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingGroupsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScalingActivitiesResult> DescribeScalingActivitiesOutcome;			
+			typedef std::future<DescribeScalingActivitiesOutcome> DescribeScalingActivitiesOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::DescribeScalingActivitiesRequest&, const DescribeScalingActivitiesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingActivitiesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScalingRulesResult> DescribeScalingRulesOutcome;			
+			typedef std::future<DescribeScalingRulesOutcome> DescribeScalingRulesOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::DescribeScalingRulesRequest&, const DescribeScalingRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingRulesAsyncHandler;
+			typedef Outcome<Error, Model::ModifyScalingGroupResult> ModifyScalingGroupOutcome;			
+			typedef std::future<ModifyScalingGroupOutcome> ModifyScalingGroupOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::ModifyScalingGroupRequest&, const ModifyScalingGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyScalingGroupAsyncHandler;
+			typedef Outcome<Error, Model::EnableScalingGroupResult> EnableScalingGroupOutcome;			
+			typedef std::future<EnableScalingGroupOutcome> EnableScalingGroupOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::EnableScalingGroupRequest&, const EnableScalingGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableScalingGroupAsyncHandler;
+			typedef Outcome<Error, Model::DeactivateScalingConfigurationResult> DeactivateScalingConfigurationOutcome;			
+			typedef std::future<DeactivateScalingConfigurationOutcome> DeactivateScalingConfigurationOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::DeactivateScalingConfigurationRequest&, const DeactivateScalingConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeactivateScalingConfigurationAsyncHandler;
+			typedef Outcome<Error, Model::VerifyAuthenticationResult> VerifyAuthenticationOutcome;			
+			typedef std::future<VerifyAuthenticationOutcome> VerifyAuthenticationOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::VerifyAuthenticationRequest&, const VerifyAuthenticationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VerifyAuthenticationAsyncHandler;
+			typedef Outcome<Error, Model::CreateScheduledTaskResult> CreateScheduledTaskOutcome;			
+			typedef std::future<CreateScheduledTaskOutcome> CreateScheduledTaskOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::CreateScheduledTaskRequest&, const CreateScheduledTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateScheduledTaskAsyncHandler;
+			typedef Outcome<Error, Model::DeleteScheduledTaskResult> DeleteScheduledTaskOutcome;			
+			typedef std::future<DeleteScheduledTaskOutcome> DeleteScheduledTaskOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::DeleteScheduledTaskRequest&, const DeleteScheduledTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteScheduledTaskAsyncHandler;
+			typedef Outcome<Error, Model::CreateScalingRuleResult> CreateScalingRuleOutcome;			
+			typedef std::future<CreateScalingRuleOutcome> CreateScalingRuleOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::CreateScalingRuleRequest&, const CreateScalingRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateScalingRuleAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScalingConfigurationsResult> DescribeScalingConfigurationsOutcome;			
+			typedef std::future<DescribeScalingConfigurationsOutcome> DescribeScalingConfigurationsOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::DescribeScalingConfigurationsRequest&, const DescribeScalingConfigurationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingConfigurationsAsyncHandler;
+			typedef Outcome<Error, Model::ModifyScheduledTaskResult> ModifyScheduledTaskOutcome;			
+			typedef std::future<ModifyScheduledTaskOutcome> ModifyScheduledTaskOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::ModifyScheduledTaskRequest&, const ModifyScheduledTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyScheduledTaskAsyncHandler;
+			typedef Outcome<Error, Model::RemoveInstancesResult> RemoveInstancesOutcome;			
+			typedef std::future<RemoveInstancesOutcome> RemoveInstancesOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::RemoveInstancesRequest&, const RemoveInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveInstancesAsyncHandler;
+			typedef Outcome<Error, Model::ExecuteScalingRuleResult> ExecuteScalingRuleOutcome;			
+			typedef std::future<ExecuteScalingRuleOutcome> ExecuteScalingRuleOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::ExecuteScalingRuleRequest&, const ExecuteScalingRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExecuteScalingRuleAsyncHandler;
+			typedef Outcome<Error, Model::DeleteScalingGroupResult> DeleteScalingGroupOutcome;			
+			typedef std::future<DeleteScalingGroupOutcome> DeleteScalingGroupOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::DeleteScalingGroupRequest&, const DeleteScalingGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteScalingGroupAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScalingInstancesResult> DescribeScalingInstancesOutcome;			
+			typedef std::future<DescribeScalingInstancesOutcome> DescribeScalingInstancesOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::DescribeScalingInstancesRequest&, const DescribeScalingInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingInstancesAsyncHandler;
+			typedef Outcome<Error, Model::CreateScalingConfigurationResult> CreateScalingConfigurationOutcome;			
+			typedef std::future<CreateScalingConfigurationOutcome> CreateScalingConfigurationOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::CreateScalingConfigurationRequest&, const CreateScalingConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateScalingConfigurationAsyncHandler;
+			typedef Outcome<Error, Model::DescribeCapacityHistoryResult> DescribeCapacityHistoryOutcome;			
+			typedef std::future<DescribeCapacityHistoryOutcome> DescribeCapacityHistoryOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::DescribeCapacityHistoryRequest&, const DescribeCapacityHistoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCapacityHistoryAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;			
+			typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeAccountAttributesResult> DescribeAccountAttributesOutcome;			
+			typedef std::future<DescribeAccountAttributesOutcome> DescribeAccountAttributesOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::DescribeAccountAttributesRequest&, const DescribeAccountAttributesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccountAttributesAsyncHandler;
+			typedef Outcome<Error, Model::DetachInstancesResult> DetachInstancesOutcome;			
+			typedef std::future<DetachInstancesOutcome> DetachInstancesOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::DetachInstancesRequest&, const DetachInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachInstancesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLimitationResult> DescribeLimitationOutcome;			
+			typedef std::future<DescribeLimitationOutcome> DescribeLimitationOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::DescribeLimitationRequest&, const DescribeLimitationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLimitationAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScalingActivityDetailResult> DescribeScalingActivityDetailOutcome;			
+			typedef std::future<DescribeScalingActivityDetailOutcome> DescribeScalingActivityDetailOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::DescribeScalingActivityDetailRequest&, const DescribeScalingActivityDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScalingActivityDetailAsyncHandler;
+			typedef Outcome<Error, Model::DescribeAlertConfigResult> DescribeAlertConfigOutcome;			
+			typedef std::future<DescribeAlertConfigOutcome> DescribeAlertConfigOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::DescribeAlertConfigRequest&, const DescribeAlertConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAlertConfigAsyncHandler;
+			typedef Outcome<Error, Model::CreateScalingGroupResult> CreateScalingGroupOutcome;			
+			typedef std::future<CreateScalingGroupOutcome> CreateScalingGroupOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::CreateScalingGroupRequest&, const CreateScalingGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateScalingGroupAsyncHandler;
+			typedef Outcome<Error, Model::DeleteScalingConfigurationResult> DeleteScalingConfigurationOutcome;			
+			typedef std::future<DeleteScalingConfigurationOutcome> DeleteScalingConfigurationOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::DeleteScalingConfigurationRequest&, const DeleteScalingConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteScalingConfigurationAsyncHandler;
+			typedef Outcome<Error, Model::DisableScalingGroupResult> DisableScalingGroupOutcome;			
+			typedef std::future<DisableScalingGroupOutcome> DisableScalingGroupOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::DisableScalingGroupRequest&, const DisableScalingGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableScalingGroupAsyncHandler;
+			typedef Outcome<Error, Model::ModifyScalingRuleResult> ModifyScalingRuleOutcome;			
+			typedef std::future<ModifyScalingRuleOutcome> ModifyScalingRuleOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::ModifyScalingRuleRequest&, const ModifyScalingRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyScalingRuleAsyncHandler;
+			typedef Outcome<Error, Model::DeleteScalingRuleResult> DeleteScalingRuleOutcome;			
+			typedef std::future<DeleteScalingRuleOutcome> DeleteScalingRuleOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::DeleteScalingRuleRequest&, const DeleteScalingRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteScalingRuleAsyncHandler;
+			typedef Outcome<Error, Model::VerifyUserResult> VerifyUserOutcome;			
+			typedef std::future<VerifyUserOutcome> VerifyUserOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::VerifyUserRequest&, const VerifyUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VerifyUserAsyncHandler;
+			typedef Outcome<Error, Model::ModifyAlertConfigResult> ModifyAlertConfigOutcome;			
+			typedef std::future<ModifyAlertConfigOutcome> ModifyAlertConfigOutcomeCallable;			
+			typedef std::function<void(const EssClient*, const Model::ModifyAlertConfigRequest&, const ModifyAlertConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAlertConfigAsyncHandler;
+
+
+			EssClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			EssClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			EssClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~EssClient();
+
+            AttachInstancesOutcome attachInstances(const Model::AttachInstancesRequest &request)const;
+            void attachInstancesAsync(const Model::AttachInstancesRequest& request, const AttachInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            AttachInstancesOutcomeCallable attachInstancesCallable(const Model::AttachInstancesRequest& request) const;
+            DescribeScalingGroupsOutcome describeScalingGroups(const Model::DescribeScalingGroupsRequest &request)const;
+            void describeScalingGroupsAsync(const Model::DescribeScalingGroupsRequest& request, const DescribeScalingGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DescribeScalingGroupsOutcomeCallable describeScalingGroupsCallable(const Model::DescribeScalingGroupsRequest& request) const;
+            DescribeScalingActivitiesOutcome describeScalingActivities(const Model::DescribeScalingActivitiesRequest &request)const;
+            void describeScalingActivitiesAsync(const Model::DescribeScalingActivitiesRequest& request, const DescribeScalingActivitiesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DescribeScalingActivitiesOutcomeCallable describeScalingActivitiesCallable(const Model::DescribeScalingActivitiesRequest& request) const;
+            DescribeScalingRulesOutcome describeScalingRules(const Model::DescribeScalingRulesRequest &request)const;
+            void describeScalingRulesAsync(const Model::DescribeScalingRulesRequest& request, const DescribeScalingRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DescribeScalingRulesOutcomeCallable describeScalingRulesCallable(const Model::DescribeScalingRulesRequest& request) const;
+            ModifyScalingGroupOutcome modifyScalingGroup(const Model::ModifyScalingGroupRequest &request)const;
+            void modifyScalingGroupAsync(const Model::ModifyScalingGroupRequest& request, const ModifyScalingGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ModifyScalingGroupOutcomeCallable modifyScalingGroupCallable(const Model::ModifyScalingGroupRequest& request) const;
+            EnableScalingGroupOutcome enableScalingGroup(const Model::EnableScalingGroupRequest &request)const;
+            void enableScalingGroupAsync(const Model::EnableScalingGroupRequest& request, const EnableScalingGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            EnableScalingGroupOutcomeCallable enableScalingGroupCallable(const Model::EnableScalingGroupRequest& request) const;
+            DeactivateScalingConfigurationOutcome deactivateScalingConfiguration(const Model::DeactivateScalingConfigurationRequest &request)const;
+            void deactivateScalingConfigurationAsync(const Model::DeactivateScalingConfigurationRequest& request, const DeactivateScalingConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DeactivateScalingConfigurationOutcomeCallable deactivateScalingConfigurationCallable(const Model::DeactivateScalingConfigurationRequest& request) const;
+            VerifyAuthenticationOutcome verifyAuthentication(const Model::VerifyAuthenticationRequest &request)const;
+            void verifyAuthenticationAsync(const Model::VerifyAuthenticationRequest& request, const VerifyAuthenticationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            VerifyAuthenticationOutcomeCallable verifyAuthenticationCallable(const Model::VerifyAuthenticationRequest& request) const;
+            CreateScheduledTaskOutcome createScheduledTask(const Model::CreateScheduledTaskRequest &request)const;
+            void createScheduledTaskAsync(const Model::CreateScheduledTaskRequest& request, const CreateScheduledTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            CreateScheduledTaskOutcomeCallable createScheduledTaskCallable(const Model::CreateScheduledTaskRequest& request) const;
+            DeleteScheduledTaskOutcome deleteScheduledTask(const Model::DeleteScheduledTaskRequest &request)const;
+            void deleteScheduledTaskAsync(const Model::DeleteScheduledTaskRequest& request, const DeleteScheduledTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DeleteScheduledTaskOutcomeCallable deleteScheduledTaskCallable(const Model::DeleteScheduledTaskRequest& request) const;
+            CreateScalingRuleOutcome createScalingRule(const Model::CreateScalingRuleRequest &request)const;
+            void createScalingRuleAsync(const Model::CreateScalingRuleRequest& request, const CreateScalingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            CreateScalingRuleOutcomeCallable createScalingRuleCallable(const Model::CreateScalingRuleRequest& request) const;
+            DescribeScalingConfigurationsOutcome describeScalingConfigurations(const Model::DescribeScalingConfigurationsRequest &request)const;
+            void describeScalingConfigurationsAsync(const Model::DescribeScalingConfigurationsRequest& request, const DescribeScalingConfigurationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DescribeScalingConfigurationsOutcomeCallable describeScalingConfigurationsCallable(const Model::DescribeScalingConfigurationsRequest& request) const;
+            ModifyScheduledTaskOutcome modifyScheduledTask(const Model::ModifyScheduledTaskRequest &request)const;
+            void modifyScheduledTaskAsync(const Model::ModifyScheduledTaskRequest& request, const ModifyScheduledTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ModifyScheduledTaskOutcomeCallable modifyScheduledTaskCallable(const Model::ModifyScheduledTaskRequest& request) const;
+            RemoveInstancesOutcome removeInstances(const Model::RemoveInstancesRequest &request)const;
+            void removeInstancesAsync(const Model::RemoveInstancesRequest& request, const RemoveInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            RemoveInstancesOutcomeCallable removeInstancesCallable(const Model::RemoveInstancesRequest& request) const;
+            ExecuteScalingRuleOutcome executeScalingRule(const Model::ExecuteScalingRuleRequest &request)const;
+            void executeScalingRuleAsync(const Model::ExecuteScalingRuleRequest& request, const ExecuteScalingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ExecuteScalingRuleOutcomeCallable executeScalingRuleCallable(const Model::ExecuteScalingRuleRequest& request) const;
+            DeleteScalingGroupOutcome deleteScalingGroup(const Model::DeleteScalingGroupRequest &request)const;
+            void deleteScalingGroupAsync(const Model::DeleteScalingGroupRequest& request, const DeleteScalingGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DeleteScalingGroupOutcomeCallable deleteScalingGroupCallable(const Model::DeleteScalingGroupRequest& request) const;
+            DescribeScalingInstancesOutcome describeScalingInstances(const Model::DescribeScalingInstancesRequest &request)const;
+            void describeScalingInstancesAsync(const Model::DescribeScalingInstancesRequest& request, const DescribeScalingInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DescribeScalingInstancesOutcomeCallable describeScalingInstancesCallable(const Model::DescribeScalingInstancesRequest& request) const;
+            CreateScalingConfigurationOutcome createScalingConfiguration(const Model::CreateScalingConfigurationRequest &request)const;
+            void createScalingConfigurationAsync(const Model::CreateScalingConfigurationRequest& request, const CreateScalingConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            CreateScalingConfigurationOutcomeCallable createScalingConfigurationCallable(const Model::CreateScalingConfigurationRequest& request) const;
+            DescribeCapacityHistoryOutcome describeCapacityHistory(const Model::DescribeCapacityHistoryRequest &request)const;
+            void describeCapacityHistoryAsync(const Model::DescribeCapacityHistoryRequest& request, const DescribeCapacityHistoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DescribeCapacityHistoryOutcomeCallable describeCapacityHistoryCallable(const Model::DescribeCapacityHistoryRequest& request) const;
+            DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
+            void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
+            DescribeAccountAttributesOutcome describeAccountAttributes(const Model::DescribeAccountAttributesRequest &request)const;
+            void describeAccountAttributesAsync(const Model::DescribeAccountAttributesRequest& request, const DescribeAccountAttributesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DescribeAccountAttributesOutcomeCallable describeAccountAttributesCallable(const Model::DescribeAccountAttributesRequest& request) const;
+            DetachInstancesOutcome detachInstances(const Model::DetachInstancesRequest &request)const;
+            void detachInstancesAsync(const Model::DetachInstancesRequest& request, const DetachInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DetachInstancesOutcomeCallable detachInstancesCallable(const Model::DetachInstancesRequest& request) const;
+            DescribeLimitationOutcome describeLimitation(const Model::DescribeLimitationRequest &request)const;
+            void describeLimitationAsync(const Model::DescribeLimitationRequest& request, const DescribeLimitationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DescribeLimitationOutcomeCallable describeLimitationCallable(const Model::DescribeLimitationRequest& request) const;
+            DescribeScalingActivityDetailOutcome describeScalingActivityDetail(const Model::DescribeScalingActivityDetailRequest &request)const;
+            void describeScalingActivityDetailAsync(const Model::DescribeScalingActivityDetailRequest& request, const DescribeScalingActivityDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DescribeScalingActivityDetailOutcomeCallable describeScalingActivityDetailCallable(const Model::DescribeScalingActivityDetailRequest& request) const;
+            DescribeAlertConfigOutcome describeAlertConfig(const Model::DescribeAlertConfigRequest &request)const;
+            void describeAlertConfigAsync(const Model::DescribeAlertConfigRequest& request, const DescribeAlertConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DescribeAlertConfigOutcomeCallable describeAlertConfigCallable(const Model::DescribeAlertConfigRequest& request) const;
+            CreateScalingGroupOutcome createScalingGroup(const Model::CreateScalingGroupRequest &request)const;
+            void createScalingGroupAsync(const Model::CreateScalingGroupRequest& request, const CreateScalingGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            CreateScalingGroupOutcomeCallable createScalingGroupCallable(const Model::CreateScalingGroupRequest& request) const;
+            DeleteScalingConfigurationOutcome deleteScalingConfiguration(const Model::DeleteScalingConfigurationRequest &request)const;
+            void deleteScalingConfigurationAsync(const Model::DeleteScalingConfigurationRequest& request, const DeleteScalingConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DeleteScalingConfigurationOutcomeCallable deleteScalingConfigurationCallable(const Model::DeleteScalingConfigurationRequest& request) const;
+            DisableScalingGroupOutcome disableScalingGroup(const Model::DisableScalingGroupRequest &request)const;
+            void disableScalingGroupAsync(const Model::DisableScalingGroupRequest& request, const DisableScalingGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DisableScalingGroupOutcomeCallable disableScalingGroupCallable(const Model::DisableScalingGroupRequest& request) const;
+            ModifyScalingRuleOutcome modifyScalingRule(const Model::ModifyScalingRuleRequest &request)const;
+            void modifyScalingRuleAsync(const Model::ModifyScalingRuleRequest& request, const ModifyScalingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ModifyScalingRuleOutcomeCallable modifyScalingRuleCallable(const Model::ModifyScalingRuleRequest& request) const;
+            DeleteScalingRuleOutcome deleteScalingRule(const Model::DeleteScalingRuleRequest &request)const;
+            void deleteScalingRuleAsync(const Model::DeleteScalingRuleRequest& request, const DeleteScalingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DeleteScalingRuleOutcomeCallable deleteScalingRuleCallable(const Model::DeleteScalingRuleRequest& request) const;
+            VerifyUserOutcome verifyUser(const Model::VerifyUserRequest &request)const;
+            void verifyUserAsync(const Model::VerifyUserRequest& request, const VerifyUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            VerifyUserOutcomeCallable verifyUserCallable(const Model::VerifyUserRequest& request) const;
+            ModifyAlertConfigOutcome modifyAlertConfig(const Model::ModifyAlertConfigRequest &request)const;
+            void modifyAlertConfigAsync(const Model::ModifyAlertConfigRequest& request, const ModifyAlertConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ModifyAlertConfigOutcomeCallable modifyAlertConfigCallable(const Model::ModifyAlertConfigRequest& request) const;
+	
+		private:
+			virtual EndpointOutcome endpoint()const override;
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_ESS_ESSCLIENT_H_

ess/include/alibabacloud/ess/EssExport.h

@@ -0,0 +1,32 @@
+/*
+ * 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_ESSEXPORT_H_
+#define ALIBABACLOUD_ESS_ESSEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_ESS_LIBRARY)
+#		define ALIBABACLOUD_ESS_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_ESS_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_ESS_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_ESS_ESSEXPORT_H_

ess/include/alibabacloud/ess/EssRequest.h

@@ -0,0 +1,39 @@
+/*
+ * 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_ESSREQUEST_H_
+#define ALIBABACLOUD_ESS_ESSREQUEST_H_
+
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include "EssExport.h"
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		class ALIBABACLOUD_ESS_EXPORT EssRequest : public RpcServiceRequest
+		{
+		public:
+			explicit EssRequest(const std::string & action);
+			virtual ~EssRequest();
+
+		private:
+
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_ESS_ESSREQUEST_H_

ess/include/alibabacloud/ess/model/AttachInstancesRequest.h

@@ -0,0 +1,182 @@
+/*
+ * 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_ATTACHINSTANCESREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_ATTACHINSTANCESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT AttachInstancesRequest : public EssRequest
+			{
+
+			public:
+				AttachInstancesRequest();
+				~AttachInstancesRequest();
+
+				std::string getInstanceId10()const;
+				void setInstanceId10(const std::string& instanceId10);
+				int getLoadBalancerWeight6()const;
+				void setLoadBalancerWeight6(int loadBalancerWeight6);
+				int getLoadBalancerWeight11()const;
+				void setLoadBalancerWeight11(int loadBalancerWeight11);
+				int getLoadBalancerWeight7()const;
+				void setLoadBalancerWeight7(int loadBalancerWeight7);
+				int getLoadBalancerWeight12()const;
+				void setLoadBalancerWeight12(int loadBalancerWeight12);
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getInstanceId12()const;
+				void setInstanceId12(const std::string& instanceId12);
+				int getLoadBalancerWeight8()const;
+				void setLoadBalancerWeight8(int loadBalancerWeight8);
+				std::string getInstanceId11()const;
+				void setInstanceId11(const std::string& instanceId11);
+				int getLoadBalancerWeight9()const;
+				void setLoadBalancerWeight9(int loadBalancerWeight9);
+				int getLoadBalancerWeight10()const;
+				void setLoadBalancerWeight10(int loadBalancerWeight10);
+				int getLoadBalancerWeight2()const;
+				void setLoadBalancerWeight2(int loadBalancerWeight2);
+				int getLoadBalancerWeight15()const;
+				void setLoadBalancerWeight15(int loadBalancerWeight15);
+				int getLoadBalancerWeight3()const;
+				void setLoadBalancerWeight3(int loadBalancerWeight3);
+				int getLoadBalancerWeight16()const;
+				void setLoadBalancerWeight16(int loadBalancerWeight16);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				int getLoadBalancerWeight4()const;
+				void setLoadBalancerWeight4(int loadBalancerWeight4);
+				int getLoadBalancerWeight13()const;
+				void setLoadBalancerWeight13(int loadBalancerWeight13);
+				int getLoadBalancerWeight5()const;
+				void setLoadBalancerWeight5(int loadBalancerWeight5);
+				int getLoadBalancerWeight14()const;
+				void setLoadBalancerWeight14(int loadBalancerWeight14);
+				int getLoadBalancerWeight1()const;
+				void setLoadBalancerWeight1(int loadBalancerWeight1);
+				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);
+				int getLoadBalancerWeight20()const;
+				void setLoadBalancerWeight20(int loadBalancerWeight20);
+				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 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);
+				int getLoadBalancerWeight19()const;
+				void setLoadBalancerWeight19(int loadBalancerWeight19);
+				std::string getInstanceId17()const;
+				void setInstanceId17(const std::string& instanceId17);
+				int getLoadBalancerWeight17()const;
+				void setLoadBalancerWeight17(int loadBalancerWeight17);
+				std::string getInstanceId19()const;
+				void setInstanceId19(const std::string& instanceId19);
+				int getLoadBalancerWeight18()const;
+				void setLoadBalancerWeight18(int loadBalancerWeight18);
+				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);
+
+            private:
+				std::string instanceId10_;
+				int loadBalancerWeight6_;
+				int loadBalancerWeight11_;
+				int loadBalancerWeight7_;
+				int loadBalancerWeight12_;
+				long resourceOwnerId_;
+				std::string instanceId12_;
+				int loadBalancerWeight8_;
+				std::string instanceId11_;
+				int loadBalancerWeight9_;
+				int loadBalancerWeight10_;
+				int loadBalancerWeight2_;
+				int loadBalancerWeight15_;
+				int loadBalancerWeight3_;
+				int loadBalancerWeight16_;
+				std::string scalingGroupId_;
+				int loadBalancerWeight4_;
+				int loadBalancerWeight13_;
+				int loadBalancerWeight5_;
+				int loadBalancerWeight14_;
+				int loadBalancerWeight1_;
+				std::string accessKeyId_;
+				std::string instanceId20_;
+				std::string instanceId1_;
+				int loadBalancerWeight20_;
+				std::string instanceId3_;
+				std::string resourceOwnerAccount_;
+				std::string instanceId2_;
+				std::string instanceId5_;
+				std::string instanceId4_;
+				std::string ownerAccount_;
+				std::string instanceId7_;
+				std::string instanceId6_;
+				std::string instanceId9_;
+				std::string instanceId8_;
+				long ownerId_;
+				std::string instanceId18_;
+				int loadBalancerWeight19_;
+				std::string instanceId17_;
+				int loadBalancerWeight17_;
+				std::string instanceId19_;
+				int loadBalancerWeight18_;
+				std::string instanceId14_;
+				std::string instanceId13_;
+				std::string instanceId16_;
+				std::string instanceId15_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_ATTACHINSTANCESREQUEST_H_

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

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

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

@@ -0,0 +1,173 @@
+/*
+ * 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_CREATESCALINGCONFIGURATIONREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_CREATESCALINGCONFIGURATIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT CreateScalingConfigurationRequest : public EssRequest
+			{
+
+			public:
+				CreateScalingConfigurationRequest();
+				~CreateScalingConfigurationRequest();
+
+				int getDataDisk3Size()const;
+				void setDataDisk3Size(int dataDisk3Size);
+				std::string getImageId()const;
+				void setImageId(const std::string& imageId);
+				std::string getDataDisk1SnapshotId()const;
+				void setDataDisk1SnapshotId(const std::string& dataDisk1SnapshotId);
+				std::string getDataDisk3Category()const;
+				void setDataDisk3Category(const std::string& dataDisk3Category);
+				std::string getDataDisk1Device()const;
+				void setDataDisk1Device(const std::string& dataDisk1Device);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				std::string getDataDisk2Device()const;
+				void setDataDisk2Device(const std::string& dataDisk2Device);
+				std::vector<std::string> getInstanceTypes()const;
+				void setInstanceTypes(const std::vector<std::string>& instanceTypes);
+				std::string getIoOptimized()const;
+				void setIoOptimized(const std::string& ioOptimized);
+				std::string getSecurityGroupId()const;
+				void setSecurityGroupId(const std::string& securityGroupId);
+				int getInternetMaxBandwidthOut()const;
+				void setInternetMaxBandwidthOut(int internetMaxBandwidthOut);
+				std::string getSecurityEnhancementStrategy()const;
+				void setSecurityEnhancementStrategy(const std::string& securityEnhancementStrategy);
+				std::string getKeyPairName()const;
+				void setKeyPairName(const std::string& keyPairName);
+				std::string getSystemDiskCategory()const;
+				void setSystemDiskCategory(const std::string& systemDiskCategory);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getUserData()const;
+				void setUserData(const std::string& userData);
+				std::string getDataDisk4Category()const;
+				void setDataDisk4Category(const std::string& dataDisk4Category);
+				std::string getDataDisk2SnapshotId()const;
+				void setDataDisk2SnapshotId(const std::string& dataDisk2SnapshotId);
+				int getDataDisk4Size()const;
+				void setDataDisk4Size(int dataDisk4Size);
+				std::string getInstanceType()const;
+				void setInstanceType(const std::string& instanceType);
+				std::string getDataDisk2Category()const;
+				void setDataDisk2Category(const std::string& dataDisk2Category);
+				int getDataDisk1Size()const;
+				void setDataDisk1Size(int dataDisk1Size);
+				std::string getDataDisk3SnapshotId()const;
+				void setDataDisk3SnapshotId(const std::string& dataDisk3SnapshotId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				int getDataDisk2Size()const;
+				void setDataDisk2Size(int dataDisk2Size);
+				std::string getRamRoleName()const;
+				void setRamRoleName(const std::string& ramRoleName);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getScalingConfigurationName()const;
+				void setScalingConfigurationName(const std::string& scalingConfigurationName);
+				std::string getTags()const;
+				void setTags(const std::string& tags);
+				std::string getDataDisk2DeleteWithInstance()const;
+				void setDataDisk2DeleteWithInstance(const std::string& dataDisk2DeleteWithInstance);
+				std::string getDataDisk1Category()const;
+				void setDataDisk1Category(const std::string& dataDisk1Category);
+				std::string getDataDisk3DeleteWithInstance()const;
+				void setDataDisk3DeleteWithInstance(const std::string& dataDisk3DeleteWithInstance);
+				int getLoadBalancerWeight()const;
+				void setLoadBalancerWeight(int loadBalancerWeight);
+				std::string getInstanceName()const;
+				void setInstanceName(const std::string& instanceName);
+				int getSystemDiskSize()const;
+				void setSystemDiskSize(int systemDiskSize);
+				std::string getDataDisk4SnapshotId()const;
+				void setDataDisk4SnapshotId(const std::string& dataDisk4SnapshotId);
+				std::string getDataDisk4Device()const;
+				void setDataDisk4Device(const std::string& dataDisk4Device);
+				std::string getInternetChargeType()const;
+				void setInternetChargeType(const std::string& internetChargeType);
+				std::string getDataDisk3Device()const;
+				void setDataDisk3Device(const std::string& dataDisk3Device);
+				std::string getDataDisk4DeleteWithInstance()const;
+				void setDataDisk4DeleteWithInstance(const std::string& dataDisk4DeleteWithInstance);
+				int getInternetMaxBandwidthIn()const;
+				void setInternetMaxBandwidthIn(int internetMaxBandwidthIn);
+				std::string getDataDisk1DeleteWithInstance()const;
+				void setDataDisk1DeleteWithInstance(const std::string& dataDisk1DeleteWithInstance);
+
+            private:
+				int dataDisk3Size_;
+				std::string imageId_;
+				std::string dataDisk1SnapshotId_;
+				std::string dataDisk3Category_;
+				std::string dataDisk1Device_;
+				std::string scalingGroupId_;
+				std::string dataDisk2Device_;
+				std::vector<std::string> instanceTypes_;
+				std::string ioOptimized_;
+				std::string securityGroupId_;
+				int internetMaxBandwidthOut_;
+				std::string securityEnhancementStrategy_;
+				std::string keyPairName_;
+				std::string systemDiskCategory_;
+				std::string accessKeyId_;
+				std::string userData_;
+				std::string dataDisk4Category_;
+				std::string dataDisk2SnapshotId_;
+				int dataDisk4Size_;
+				std::string instanceType_;
+				std::string dataDisk2Category_;
+				int dataDisk1Size_;
+				std::string dataDisk3SnapshotId_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				int dataDisk2Size_;
+				std::string ramRoleName_;
+				long ownerId_;
+				std::string scalingConfigurationName_;
+				std::string tags_;
+				std::string dataDisk2DeleteWithInstance_;
+				std::string dataDisk1Category_;
+				std::string dataDisk3DeleteWithInstance_;
+				int loadBalancerWeight_;
+				std::string instanceName_;
+				int systemDiskSize_;
+				std::string dataDisk4SnapshotId_;
+				std::string dataDisk4Device_;
+				std::string internetChargeType_;
+				std::string dataDisk3Device_;
+				std::string dataDisk4DeleteWithInstance_;
+				int internetMaxBandwidthIn_;
+				std::string dataDisk1DeleteWithInstance_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_CREATESCALINGCONFIGURATIONREQUEST_H_

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

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

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

@@ -0,0 +1,89 @@
+/*
+ * 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_CREATESCALINGGROUPREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_CREATESCALINGGROUPREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT CreateScalingGroupRequest : public EssRequest
+			{
+
+			public:
+				CreateScalingGroupRequest();
+				~CreateScalingGroupRequest();
+
+				std::string getDBInstanceIds()const;
+				void setDBInstanceIds(const std::string& dBInstanceIds);
+				std::string getLoadBalancerIds()const;
+				void setLoadBalancerIds(const std::string& loadBalancerIds);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getScalingGroupName()const;
+				void setScalingGroupName(const std::string& scalingGroupName);
+				std::vector<std::string> getVSwitchIds()const;
+				void setVSwitchIds(const std::vector<std::string>& vSwitchIds);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				int getMinSize()const;
+				void setMinSize(int minSize);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getVSwitchId()const;
+				void setVSwitchId(const std::string& vSwitchId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				int getMaxSize()const;
+				void setMaxSize(int maxSize);
+				int getDefaultCooldown()const;
+				void setDefaultCooldown(int defaultCooldown);
+				std::string getRemovalPolicy1()const;
+				void setRemovalPolicy1(const std::string& removalPolicy1);
+				std::string getRemovalPolicy2()const;
+				void setRemovalPolicy2(const std::string& removalPolicy2);
+
+            private:
+				std::string dBInstanceIds_;
+				std::string loadBalancerIds_;
+				std::string resourceOwnerAccount_;
+				std::string scalingGroupName_;
+				std::vector<std::string> vSwitchIds_;
+				std::string ownerAccount_;
+				int minSize_;
+				long ownerId_;
+				std::string accessKeyId_;
+				std::string vSwitchId_;
+				std::string regionId_;
+				int maxSize_;
+				int defaultCooldown_;
+				std::string removalPolicy1_;
+				std::string removalPolicy2_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_CREATESCALINGGROUPREQUEST_H_

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

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

ess/include/alibabacloud/ess/model/CreateScalingRuleRequest.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_CREATESCALINGRULEREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_CREATESCALINGRULEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT CreateScalingRuleRequest : public EssRequest
+			{
+
+			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::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				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);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string scalingRuleName_;
+				std::string resourceOwnerAccount_;
+				int adjustmentValue_;
+				std::string scalingGroupId_;
+				std::string ownerAccount_;
+				int cooldown_;
+				std::string adjustmentType_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_CREATESCALINGRULEREQUEST_H_

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

@@ -0,0 +1,55 @@
+/*
+ * 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_CREATESCALINGRULERESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_CREATESCALINGRULERESULT_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 CreateScalingRuleResult : public ServiceResult
+			{
+			public:
+
+
+				CreateScalingRuleResult();
+				explicit CreateScalingRuleResult(const std::string &payload);
+				~CreateScalingRuleResult();
+				std::string getScalingRuleAri()const;
+				void setScalingRuleAri(const std::string& scalingRuleAri);
+				std::string getScalingRuleId()const;
+				void setScalingRuleId(const std::string& scalingRuleId);
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string scalingRuleAri_;
+				std::string scalingRuleId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_CREATESCALINGRULERESULT_H_

ess/include/alibabacloud/ess/model/CreateScheduledTaskRequest.h

@@ -0,0 +1,86 @@
+/*
+ * 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_CREATESCHEDULEDTASKREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_CREATESCHEDULEDTASKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT CreateScheduledTaskRequest : public EssRequest
+			{
+
+			public:
+				CreateScheduledTaskRequest();
+				~CreateScheduledTaskRequest();
+
+				std::string getLaunchTime()const;
+				void setLaunchTime(const std::string& launchTime);
+				std::string getScheduledAction()const;
+				void setScheduledAction(const std::string& scheduledAction);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getRecurrenceValue()const;
+				void setRecurrenceValue(const std::string& recurrenceValue);
+				int getLaunchExpirationTime()const;
+				void setLaunchExpirationTime(int launchExpirationTime);
+				std::string getRecurrenceEndTime()const;
+				void setRecurrenceEndTime(const std::string& recurrenceEndTime);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getScheduledTaskName()const;
+				void setScheduledTaskName(const std::string& scheduledTaskName);
+				bool getTaskEnabled()const;
+				void setTaskEnabled(bool taskEnabled);
+				std::string getRecurrenceType()const;
+				void setRecurrenceType(const std::string& recurrenceType);
+
+            private:
+				std::string launchTime_;
+				std::string scheduledAction_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				std::string description_;
+				long ownerId_;
+				std::string recurrenceValue_;
+				int launchExpirationTime_;
+				std::string recurrenceEndTime_;
+				std::string accessKeyId_;
+				std::string regionId_;
+				std::string scheduledTaskName_;
+				bool taskEnabled_;
+				std::string recurrenceType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_CREATESCHEDULEDTASKREQUEST_H_

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

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

ess/include/alibabacloud/ess/model/DeactivateScalingConfigurationRequest.h

@@ -0,0 +1,59 @@
+/*
+ * 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_DEACTIVATESCALINGCONFIGURATIONREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DEACTIVATESCALINGCONFIGURATIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT DeactivateScalingConfigurationRequest : public EssRequest
+			{
+
+			public:
+				DeactivateScalingConfigurationRequest();
+				~DeactivateScalingConfigurationRequest();
+
+				std::string getScalingConfigurationId()const;
+				void setScalingConfigurationId(const std::string& scalingConfigurationId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string scalingConfigurationId_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DEACTIVATESCALINGCONFIGURATIONREQUEST_H_

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

ess/include/alibabacloud/ess/model/DeleteScalingConfigurationRequest.h

@@ -0,0 +1,59 @@
+/*
+ * 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_DELETESCALINGCONFIGURATIONREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DELETESCALINGCONFIGURATIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT DeleteScalingConfigurationRequest : public EssRequest
+			{
+
+			public:
+				DeleteScalingConfigurationRequest();
+				~DeleteScalingConfigurationRequest();
+
+				std::string getScalingConfigurationId()const;
+				void setScalingConfigurationId(const std::string& scalingConfigurationId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string scalingConfigurationId_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DELETESCALINGCONFIGURATIONREQUEST_H_

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

ess/include/alibabacloud/ess/model/DeleteScalingGroupRequest.h

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

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

ess/include/alibabacloud/ess/model/DeleteScalingRuleRequest.h

@@ -0,0 +1,59 @@
+/*
+ * 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_DELETESCALINGRULEREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DELETESCALINGRULEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT DeleteScalingRuleRequest : public EssRequest
+			{
+
+			public:
+				DeleteScalingRuleRequest();
+				~DeleteScalingRuleRequest();
+
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				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);
+
+            private:
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string scalingRuleId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DELETESCALINGRULEREQUEST_H_

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

ess/include/alibabacloud/ess/model/DeleteScheduledTaskRequest.h

@@ -0,0 +1,59 @@
+/*
+ * 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_DELETESCHEDULEDTASKREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DELETESCHEDULEDTASKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT DeleteScheduledTaskRequest : public EssRequest
+			{
+
+			public:
+				DeleteScheduledTaskRequest();
+				~DeleteScheduledTaskRequest();
+
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getScheduledTaskId()const;
+				void setScheduledTaskId(const std::string& scheduledTaskId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string scheduledTaskId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DELETESCHEDULEDTASKREQUEST_H_

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

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

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBEACCOUNTATTRIBUTESREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBEACCOUNTATTRIBUTESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT DescribeAccountAttributesRequest : public EssRequest
+			{
+
+			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,76 @@
+/*
+ * 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;
+				void setMaxNumberOfScalingRules(int maxNumberOfScalingRules);
+				int getMaxNumberOfScalingInstances()const;
+				void setMaxNumberOfScalingInstances(int maxNumberOfScalingInstances);
+				int getMaxNumberOfScheduledTasks()const;
+				void setMaxNumberOfScheduledTasks(int maxNumberOfScheduledTasks);
+				int getMaxNumberOfLoadBalancers()const;
+				void setMaxNumberOfLoadBalancers(int maxNumberOfLoadBalancers);
+				int getMaxNumberOfMinSize()const;
+				void setMaxNumberOfMinSize(int maxNumberOfMinSize);
+				int getMaxNumberOfScalingGroups()const;
+				void setMaxNumberOfScalingGroups(int maxNumberOfScalingGroups);
+				int getMaxNumberOfScalingConfigurations()const;
+				void setMaxNumberOfScalingConfigurations(int maxNumberOfScalingConfigurations);
+				int getMaxNumberOfDBInstances()const;
+				void setMaxNumberOfDBInstances(int maxNumberOfDBInstances);
+				int getMaxNumberOfMaxSize()const;
+				void setMaxNumberOfMaxSize(int maxNumberOfMaxSize);
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int maxNumberOfScalingRules_;
+				int maxNumberOfScalingInstances_;
+				int maxNumberOfScheduledTasks_;
+				int maxNumberOfLoadBalancers_;
+				int maxNumberOfMinSize_;
+				int maxNumberOfScalingGroups_;
+				int maxNumberOfScalingConfigurations_;
+				int maxNumberOfDBInstances_;
+				int maxNumberOfMaxSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEACCOUNTATTRIBUTESRESULT_H_

ess/include/alibabacloud/ess/model/DescribeAlertConfigRequest.h

@@ -0,0 +1,56 @@
+/*
+ * 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_DESCRIBEALERTCONFIGREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBEALERTCONFIGREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT DescribeAlertConfigRequest : public EssRequest
+			{
+
+			public:
+				DescribeAlertConfigRequest();
+				~DescribeAlertConfigRequest();
+
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string resourceOwnerAccount_;
+				std::string scalingGroupId_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEALERTCONFIGREQUEST_H_

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

@@ -0,0 +1,58 @@
+/*
+ * 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_DESCRIBEALERTCONFIGRESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBEALERTCONFIGRESULT_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 DescribeAlertConfigResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeAlertConfigResult();
+				explicit DescribeAlertConfigResult(const std::string &payload);
+				~DescribeAlertConfigResult();
+				int getFailConfig()const;
+				void setFailConfig(int failConfig);
+				int getRejectConfig()const;
+				void setRejectConfig(int rejectConfig);
+				int getSuccessConfig()const;
+				void setSuccessConfig(int successConfig);
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int failConfig_;
+				int rejectConfig_;
+				int successConfig_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEALERTCONFIGRESULT_H_

ess/include/alibabacloud/ess/model/DescribeCapacityHistoryRequest.h

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

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

@@ -0,0 +1,69 @@
+/*
+ * 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_DESCRIBECAPACITYHISTORYRESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBECAPACITYHISTORYRESULT_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 DescribeCapacityHistoryResult : public ServiceResult
+			{
+			public:
+				struct CapacityHistoryModel
+				{
+					int attachedCapacity;
+					std::string scalingGroupId;
+					int totalCapacity;
+					int autoCreatedCapacity;
+					std::string timestamp;
+				};
+
+
+				DescribeCapacityHistoryResult();
+				explicit DescribeCapacityHistoryResult(const std::string &payload);
+				~DescribeCapacityHistoryResult();
+				int getTotalCount()const;
+				void setTotalCount(int totalCount);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::vector<CapacityHistoryModel> getCapacityHistoryItems()const;
+				void setCapacityHistoryItems(const std::vector<CapacityHistoryModel>& capacityHistoryItems);
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<CapacityHistoryModel> capacityHistoryItems_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBECAPACITYHISTORYRESULT_H_

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

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBELIMITATIONREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBELIMITATIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT DescribeLimitationRequest : public EssRequest
+			{
+
+			public:
+				DescribeLimitationRequest();
+				~DescribeLimitationRequest();
+
+				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_DESCRIBELIMITATIONREQUEST_H_

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

@@ -0,0 +1,76 @@
+/*
+ * 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_DESCRIBELIMITATIONRESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBELIMITATIONRESULT_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 DescribeLimitationResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeLimitationResult();
+				explicit DescribeLimitationResult(const std::string &payload);
+				~DescribeLimitationResult();
+				int getMaxNumberOfScalingRules()const;
+				void setMaxNumberOfScalingRules(int maxNumberOfScalingRules);
+				int getMaxNumberOfScalingInstances()const;
+				void setMaxNumberOfScalingInstances(int maxNumberOfScalingInstances);
+				int getMaxNumberOfScheduledTasks()const;
+				void setMaxNumberOfScheduledTasks(int maxNumberOfScheduledTasks);
+				int getMaxNumberOfLoadBalancers()const;
+				void setMaxNumberOfLoadBalancers(int maxNumberOfLoadBalancers);
+				int getMaxNumberOfMinSize()const;
+				void setMaxNumberOfMinSize(int maxNumberOfMinSize);
+				int getMaxNumberOfScalingGroups()const;
+				void setMaxNumberOfScalingGroups(int maxNumberOfScalingGroups);
+				int getMaxNumberOfScalingConfigurations()const;
+				void setMaxNumberOfScalingConfigurations(int maxNumberOfScalingConfigurations);
+				int getMaxNumberOfDBInstances()const;
+				void setMaxNumberOfDBInstances(int maxNumberOfDBInstances);
+				int getMaxNumberOfMaxSize()const;
+				void setMaxNumberOfMaxSize(int maxNumberOfMaxSize);
+
+			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_DESCRIBELIMITATIONRESULT_H_

ess/include/alibabacloud/ess/model/DescribeRegionsRequest.h

@@ -0,0 +1,56 @@
+/*
+ * 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_DESCRIBEREGIONSREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBEREGIONSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT DescribeRegionsRequest : public EssRequest
+			{
+
+			public:
+				DescribeRegionsRequest();
+				~DescribeRegionsRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				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:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEREGIONSREQUEST_H_

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

@@ -0,0 +1,58 @@
+/*
+ * 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_DESCRIBEREGIONSRESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBEREGIONSRESULT_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 DescribeRegionsResult : public ServiceResult
+			{
+			public:
+				struct Region
+				{
+					bool vpcUnavailable;
+					bool classicUnavailable;
+					std::string regionId;
+				};
+
+
+				DescribeRegionsResult();
+				explicit DescribeRegionsResult(const std::string &payload);
+				~DescribeRegionsResult();
+				std::vector<Region> getRegions()const;
+				void setRegions(const std::vector<Region>& regions);
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Region> regions_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEREGIONSRESULT_H_

ess/include/alibabacloud/ess/model/DescribeScalingActivitiesRequest.h

@@ -0,0 +1,134 @@
+/*
+ * 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_DESCRIBESCALINGACTIVITIESREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGACTIVITIESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT DescribeScalingActivitiesRequest : public EssRequest
+			{
+
+			public:
+				DescribeScalingActivitiesRequest();
+				~DescribeScalingActivitiesRequest();
+
+				std::string getScalingActivityId9()const;
+				void setScalingActivityId9(const std::string& scalingActivityId9);
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getScalingActivityId5()const;
+				void setScalingActivityId5(const std::string& scalingActivityId5);
+				std::string getScalingActivityId6()const;
+				void setScalingActivityId6(const std::string& scalingActivityId6);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				std::string getScalingActivityId7()const;
+				void setScalingActivityId7(const std::string& scalingActivityId7);
+				std::string getScalingActivityId8()const;
+				void setScalingActivityId8(const std::string& scalingActivityId8);
+				std::string getScalingActivityId1()const;
+				void setScalingActivityId1(const std::string& scalingActivityId1);
+				std::string getScalingActivityId2()const;
+				void setScalingActivityId2(const std::string& scalingActivityId2);
+				std::string getScalingActivityId3()const;
+				void setScalingActivityId3(const std::string& scalingActivityId3);
+				std::string getScalingActivityId4()const;
+				void setScalingActivityId4(const std::string& scalingActivityId4);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getStatusCode()const;
+				void setStatusCode(const std::string& statusCode);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getScalingActivityId11()const;
+				void setScalingActivityId11(const std::string& scalingActivityId11);
+				std::string getScalingActivityId10()const;
+				void setScalingActivityId10(const std::string& scalingActivityId10);
+				std::string getScalingActivityId13()const;
+				void setScalingActivityId13(const std::string& scalingActivityId13);
+				std::string getScalingActivityId12()const;
+				void setScalingActivityId12(const std::string& scalingActivityId12);
+				std::string getScalingActivityId15()const;
+				void setScalingActivityId15(const std::string& scalingActivityId15);
+				std::string getScalingActivityId14()const;
+				void setScalingActivityId14(const std::string& scalingActivityId14);
+				std::string getScalingActivityId17()const;
+				void setScalingActivityId17(const std::string& scalingActivityId17);
+				std::string getScalingActivityId16()const;
+				void setScalingActivityId16(const std::string& scalingActivityId16);
+				std::string getScalingActivityId19()const;
+				void setScalingActivityId19(const std::string& scalingActivityId19);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getScalingActivityId18()const;
+				void setScalingActivityId18(const std::string& scalingActivityId18);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getScalingActivityId20()const;
+				void setScalingActivityId20(const std::string& scalingActivityId20);
+
+            private:
+				std::string scalingActivityId9_;
+				long resourceOwnerId_;
+				std::string scalingActivityId5_;
+				std::string scalingActivityId6_;
+				std::string scalingGroupId_;
+				std::string scalingActivityId7_;
+				std::string scalingActivityId8_;
+				std::string scalingActivityId1_;
+				std::string scalingActivityId2_;
+				std::string scalingActivityId3_;
+				std::string scalingActivityId4_;
+				int pageNumber_;
+				std::string accessKeyId_;
+				std::string statusCode_;
+				std::string regionId_;
+				int pageSize_;
+				std::string scalingActivityId11_;
+				std::string scalingActivityId10_;
+				std::string scalingActivityId13_;
+				std::string scalingActivityId12_;
+				std::string scalingActivityId15_;
+				std::string scalingActivityId14_;
+				std::string scalingActivityId17_;
+				std::string scalingActivityId16_;
+				std::string scalingActivityId19_;
+				std::string resourceOwnerAccount_;
+				std::string scalingActivityId18_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string scalingActivityId20_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGACTIVITIESREQUEST_H_

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

@@ -0,0 +1,76 @@
+/*
+ * 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_DESCRIBESCALINGACTIVITIESRESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGACTIVITIESRESULT_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 DescribeScalingActivitiesResult : public ServiceResult
+			{
+			public:
+				struct ScalingActivity
+				{
+					int progress;
+					std::string description;
+					std::string endTime;
+					std::string attachedCapacity;
+					std::string scalingActivityId;
+					std::string scalingGroupId;
+					std::string cause;
+					std::string startTime;
+					std::string totalCapacity;
+					std::string statusCode;
+					std::string autoCreatedCapacity;
+					std::string statusMessage;
+				};
+
+
+				DescribeScalingActivitiesResult();
+				explicit DescribeScalingActivitiesResult(const std::string &payload);
+				~DescribeScalingActivitiesResult();
+				int getTotalCount()const;
+				void setTotalCount(int totalCount);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::vector<ScalingActivity> getScalingActivities()const;
+				void setScalingActivities(const std::vector<ScalingActivity>& scalingActivities);
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<ScalingActivity> scalingActivities_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGACTIVITIESRESULT_H_

ess/include/alibabacloud/ess/model/DescribeScalingActivityDetailRequest.h

@@ -0,0 +1,59 @@
+/*
+ * 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_DESCRIBESCALINGACTIVITYDETAILREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGACTIVITYDETAILREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT DescribeScalingActivityDetailRequest : public EssRequest
+			{
+
+			public:
+				DescribeScalingActivityDetailRequest();
+				~DescribeScalingActivityDetailRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getScalingActivityId()const;
+				void setScalingActivityId(const std::string& scalingActivityId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				long ownerId_;
+				std::string scalingActivityId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGACTIVITYDETAILREQUEST_H_

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

@@ -0,0 +1,55 @@
+/*
+ * 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_DESCRIBESCALINGACTIVITYDETAILRESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGACTIVITYDETAILRESULT_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 DescribeScalingActivityDetailResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeScalingActivityDetailResult();
+				explicit DescribeScalingActivityDetailResult(const std::string &payload);
+				~DescribeScalingActivityDetailResult();
+				std::string getScalingActivityId()const;
+				void setScalingActivityId(const std::string& scalingActivityId);
+				std::string getDetail()const;
+				void setDetail(const std::string& detail);
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string scalingActivityId_;
+				std::string detail_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGACTIVITYDETAILRESULT_H_

ess/include/alibabacloud/ess/model/DescribeScalingConfigurationsRequest.h

@@ -0,0 +1,131 @@
+/*
+ * 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_DESCRIBESCALINGCONFIGURATIONSREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGCONFIGURATIONSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT DescribeScalingConfigurationsRequest : public EssRequest
+			{
+
+			public:
+				DescribeScalingConfigurationsRequest();
+				~DescribeScalingConfigurationsRequest();
+
+				std::string getScalingConfigurationId6()const;
+				void setScalingConfigurationId6(const std::string& scalingConfigurationId6);
+				std::string getScalingConfigurationId7()const;
+				void setScalingConfigurationId7(const std::string& scalingConfigurationId7);
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getScalingConfigurationId4()const;
+				void setScalingConfigurationId4(const std::string& scalingConfigurationId4);
+				std::string getScalingConfigurationId5()const;
+				void setScalingConfigurationId5(const std::string& scalingConfigurationId5);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				std::string getScalingConfigurationId8()const;
+				void setScalingConfigurationId8(const std::string& scalingConfigurationId8);
+				std::string getScalingConfigurationId9()const;
+				void setScalingConfigurationId9(const std::string& scalingConfigurationId9);
+				std::string getScalingConfigurationId10()const;
+				void setScalingConfigurationId10(const std::string& scalingConfigurationId10);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getScalingConfigurationName2()const;
+				void setScalingConfigurationName2(const std::string& scalingConfigurationName2);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getScalingConfigurationName3()const;
+				void setScalingConfigurationName3(const std::string& scalingConfigurationName3);
+				std::string getScalingConfigurationName1()const;
+				void setScalingConfigurationName1(const std::string& scalingConfigurationName1);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getScalingConfigurationId2()const;
+				void setScalingConfigurationId2(const std::string& scalingConfigurationId2);
+				std::string getScalingConfigurationId3()const;
+				void setScalingConfigurationId3(const std::string& scalingConfigurationId3);
+				std::string getScalingConfigurationId1()const;
+				void setScalingConfigurationId1(const std::string& scalingConfigurationId1);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getScalingConfigurationName6()const;
+				void setScalingConfigurationName6(const std::string& scalingConfigurationName6);
+				std::string getScalingConfigurationName7()const;
+				void setScalingConfigurationName7(const std::string& scalingConfigurationName7);
+				std::string getScalingConfigurationName4()const;
+				void setScalingConfigurationName4(const std::string& scalingConfigurationName4);
+				std::string getScalingConfigurationName5()const;
+				void setScalingConfigurationName5(const std::string& scalingConfigurationName5);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getScalingConfigurationName8()const;
+				void setScalingConfigurationName8(const std::string& scalingConfigurationName8);
+				std::string getScalingConfigurationName9()const;
+				void setScalingConfigurationName9(const std::string& scalingConfigurationName9);
+				std::string getScalingConfigurationName10()const;
+				void setScalingConfigurationName10(const std::string& scalingConfigurationName10);
+
+            private:
+				std::string scalingConfigurationId6_;
+				std::string scalingConfigurationId7_;
+				long resourceOwnerId_;
+				std::string scalingConfigurationId4_;
+				std::string scalingConfigurationId5_;
+				std::string scalingGroupId_;
+				std::string scalingConfigurationId8_;
+				std::string scalingConfigurationId9_;
+				std::string scalingConfigurationId10_;
+				int pageNumber_;
+				std::string accessKeyId_;
+				std::string scalingConfigurationName2_;
+				std::string regionId_;
+				std::string scalingConfigurationName3_;
+				std::string scalingConfigurationName1_;
+				int pageSize_;
+				std::string scalingConfigurationId2_;
+				std::string scalingConfigurationId3_;
+				std::string scalingConfigurationId1_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				std::string scalingConfigurationName6_;
+				std::string scalingConfigurationName7_;
+				std::string scalingConfigurationName4_;
+				std::string scalingConfigurationName5_;
+				long ownerId_;
+				std::string scalingConfigurationName8_;
+				std::string scalingConfigurationName9_;
+				std::string scalingConfigurationName10_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGCONFIGURATIONSREQUEST_H_

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

@@ -0,0 +1,101 @@
+/*
+ * 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_DESCRIBESCALINGCONFIGURATIONSRESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGCONFIGURATIONSRESULT_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 DescribeScalingConfigurationsResult : public ServiceResult
+			{
+			public:
+				struct ScalingConfiguration
+				{
+					struct DataDisk
+					{
+						std::string snapshotId;
+						std::string category;
+						int size;
+						std::string device;
+					};
+					struct Tag
+					{
+						std::string value;
+						std::string key;
+					};
+					std::string scalingConfigurationName;
+					std::vector<ScalingConfiguration::DataDisk> dataDisks;
+					int systemDiskSize;
+					std::string userData;
+					std::string lifecycleState;
+					std::string ramRoleName;
+					std::string imageId;
+					std::vector<std::string> instanceTypes;
+					std::string instanceType;
+					std::vector<ScalingConfiguration::Tag> tags;
+					std::string keyPairName;
+					int loadBalancerWeight;
+					std::string ioOptimized;
+					std::string scalingGroupId;
+					std::string securityGroupId;
+					std::string internetChargeType;
+					std::string systemDiskCategory;
+					std::string instanceName;
+					std::string deploymentSetId;
+					int internetMaxBandwidthOut;
+					int internetMaxBandwidthIn;
+					std::string creationTime;
+					std::string instanceGeneration;
+					std::string scalingConfigurationId;
+					std::string securityEnhancementStrategy;
+				};
+
+
+				DescribeScalingConfigurationsResult();
+				explicit DescribeScalingConfigurationsResult(const std::string &payload);
+				~DescribeScalingConfigurationsResult();
+				int getTotalCount()const;
+				void setTotalCount(int totalCount);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::vector<ScalingConfiguration> getScalingConfigurations()const;
+				void setScalingConfigurations(const std::vector<ScalingConfiguration>& scalingConfigurations);
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<ScalingConfiguration> scalingConfigurations_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGCONFIGURATIONSRESULT_H_

ess/include/alibabacloud/ess/model/DescribeScalingGroupsRequest.h

@@ -0,0 +1,188 @@
+/*
+ * 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_DESCRIBESCALINGGROUPSREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGGROUPSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT DescribeScalingGroupsRequest : public EssRequest
+			{
+
+			public:
+				DescribeScalingGroupsRequest();
+				~DescribeScalingGroupsRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getScalingGroupId10()const;
+				void setScalingGroupId10(const std::string& scalingGroupId10);
+				std::string getScalingGroupId12()const;
+				void setScalingGroupId12(const std::string& scalingGroupId12);
+				std::string getScalingGroupId13()const;
+				void setScalingGroupId13(const std::string& scalingGroupId13);
+				std::string getScalingGroupId14()const;
+				void setScalingGroupId14(const std::string& scalingGroupId14);
+				std::string getScalingGroupId15()const;
+				void setScalingGroupId15(const std::string& scalingGroupId15);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getScalingGroupName20()const;
+				void setScalingGroupName20(const std::string& scalingGroupName20);
+				std::string getScalingGroupName19()const;
+				void setScalingGroupName19(const std::string& scalingGroupName19);
+				std::string getScalingGroupId20()const;
+				void setScalingGroupId20(const std::string& scalingGroupId20);
+				std::string getScalingGroupName18()const;
+				void setScalingGroupName18(const std::string& scalingGroupName18);
+				std::string getScalingGroupName17()const;
+				void setScalingGroupName17(const std::string& scalingGroupName17);
+				std::string getScalingGroupName16()const;
+				void setScalingGroupName16(const std::string& scalingGroupName16);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getScalingGroupName()const;
+				void setScalingGroupName(const std::string& scalingGroupName);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getScalingGroupName1()const;
+				void setScalingGroupName1(const std::string& scalingGroupName1);
+				std::string getScalingGroupName2()const;
+				void setScalingGroupName2(const std::string& scalingGroupName2);
+				std::string getScalingGroupId2()const;
+				void setScalingGroupId2(const std::string& scalingGroupId2);
+				std::string getScalingGroupId1()const;
+				void setScalingGroupId1(const std::string& scalingGroupId1);
+				std::string getScalingGroupId6()const;
+				void setScalingGroupId6(const std::string& scalingGroupId6);
+				std::string getScalingGroupId16()const;
+				void setScalingGroupId16(const std::string& scalingGroupId16);
+				std::string getScalingGroupName7()const;
+				void setScalingGroupName7(const std::string& scalingGroupName7);
+				std::string getScalingGroupName11()const;
+				void setScalingGroupName11(const std::string& scalingGroupName11);
+				std::string getScalingGroupId5()const;
+				void setScalingGroupId5(const std::string& scalingGroupId5);
+				std::string getScalingGroupId17()const;
+				void setScalingGroupId17(const std::string& scalingGroupId17);
+				std::string getScalingGroupName8()const;
+				void setScalingGroupName8(const std::string& scalingGroupName8);
+				std::string getScalingGroupName10()const;
+				void setScalingGroupName10(const std::string& scalingGroupName10);
+				std::string getScalingGroupId4()const;
+				void setScalingGroupId4(const std::string& scalingGroupId4);
+				std::string getScalingGroupId18()const;
+				void setScalingGroupId18(const std::string& scalingGroupId18);
+				std::string getScalingGroupName9()const;
+				void setScalingGroupName9(const std::string& scalingGroupName9);
+				std::string getScalingGroupId3()const;
+				void setScalingGroupId3(const std::string& scalingGroupId3);
+				std::string getScalingGroupId19()const;
+				void setScalingGroupId19(const std::string& scalingGroupId19);
+				std::string getScalingGroupName3()const;
+				void setScalingGroupName3(const std::string& scalingGroupName3);
+				std::string getScalingGroupName15()const;
+				void setScalingGroupName15(const std::string& scalingGroupName15);
+				std::string getScalingGroupId9()const;
+				void setScalingGroupId9(const std::string& scalingGroupId9);
+				std::string getScalingGroupName4()const;
+				void setScalingGroupName4(const std::string& scalingGroupName4);
+				std::string getScalingGroupName14()const;
+				void setScalingGroupName14(const std::string& scalingGroupName14);
+				std::string getScalingGroupId8()const;
+				void setScalingGroupId8(const std::string& scalingGroupId8);
+				std::string getScalingGroupName5()const;
+				void setScalingGroupName5(const std::string& scalingGroupName5);
+				std::string getScalingGroupName13()const;
+				void setScalingGroupName13(const std::string& scalingGroupName13);
+				std::string getScalingGroupId7()const;
+				void setScalingGroupId7(const std::string& scalingGroupId7);
+				std::string getScalingGroupName6()const;
+				void setScalingGroupName6(const std::string& scalingGroupName6);
+				std::string getScalingGroupName12()const;
+				void setScalingGroupName12(const std::string& scalingGroupName12);
+
+            private:
+				long resourceOwnerId_;
+				std::string scalingGroupId10_;
+				std::string scalingGroupId12_;
+				std::string scalingGroupId13_;
+				std::string scalingGroupId14_;
+				std::string scalingGroupId15_;
+				long ownerId_;
+				int pageNumber_;
+				std::string accessKeyId_;
+				std::string regionId_;
+				int pageSize_;
+				std::string scalingGroupName20_;
+				std::string scalingGroupName19_;
+				std::string scalingGroupId20_;
+				std::string scalingGroupName18_;
+				std::string scalingGroupName17_;
+				std::string scalingGroupName16_;
+				std::string resourceOwnerAccount_;
+				std::string scalingGroupName_;
+				std::string ownerAccount_;
+				std::string scalingGroupName1_;
+				std::string scalingGroupName2_;
+				std::string scalingGroupId2_;
+				std::string scalingGroupId1_;
+				std::string scalingGroupId6_;
+				std::string scalingGroupId16_;
+				std::string scalingGroupName7_;
+				std::string scalingGroupName11_;
+				std::string scalingGroupId5_;
+				std::string scalingGroupId17_;
+				std::string scalingGroupName8_;
+				std::string scalingGroupName10_;
+				std::string scalingGroupId4_;
+				std::string scalingGroupId18_;
+				std::string scalingGroupName9_;
+				std::string scalingGroupId3_;
+				std::string scalingGroupId19_;
+				std::string scalingGroupName3_;
+				std::string scalingGroupName15_;
+				std::string scalingGroupId9_;
+				std::string scalingGroupName4_;
+				std::string scalingGroupName14_;
+				std::string scalingGroupId8_;
+				std::string scalingGroupName5_;
+				std::string scalingGroupName13_;
+				std::string scalingGroupId7_;
+				std::string scalingGroupName6_;
+				std::string scalingGroupName12_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGGROUPSREQUEST_H_

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

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGGROUPSRESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGGROUPSRESULT_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 DescribeScalingGroupsResult : public ServiceResult
+			{
+			public:
+				struct ScalingGroup
+				{
+					int removingCapacity;
+					std::string activeScalingConfigurationId;
+					std::vector<std::string> vSwitchIds;
+					int pendingCapacity;
+					std::string scalingGroupId;
+					std::string vSwitchId;
+					std::vector<std::string> loadBalancerIds;
+					std::string lifecycleState;
+					std::string modificationTime;
+					int maxSize;
+					std::string scalingGroupName;
+					int activeCapacity;
+					int minSize;
+					int defaultCooldown;
+					std::string vpcId;
+					std::vector<std::string> removalPolicies;
+					std::string creationTime;
+					int totalCapacity;
+					std::string regionId;
+					std::vector<std::string> dBInstanceIds;
+				};
+
+
+				DescribeScalingGroupsResult();
+				explicit DescribeScalingGroupsResult(const std::string &payload);
+				~DescribeScalingGroupsResult();
+				int getTotalCount()const;
+				void setTotalCount(int totalCount);
+				std::vector<ScalingGroup> getScalingGroups()const;
+				void setScalingGroups(const std::vector<ScalingGroup>& scalingGroups);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::vector<ScalingGroup> scalingGroups_;
+				int pageSize_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGGROUPSRESULT_H_

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

@@ -0,0 +1,143 @@
+/*
+ * 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_DESCRIBESCALINGINSTANCESREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGINSTANCESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT DescribeScalingInstancesRequest : public EssRequest
+			{
+
+			public:
+				DescribeScalingInstancesRequest();
+				~DescribeScalingInstancesRequest();
+
+				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 getLifecycleState()const;
+				void setLifecycleState(const std::string& lifecycleState);
+				std::string getCreationType()const;
+				void setCreationType(const std::string& creationType);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getInstanceId20()const;
+				void setInstanceId20(const std::string& instanceId20);
+				std::string getInstanceId1()const;
+				void setInstanceId1(const std::string& instanceId1);
+				std::string getInstanceId3()const;
+				void setInstanceId3(const std::string& instanceId3);
+				std::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 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 getScalingConfigurationId()const;
+				void setScalingConfigurationId(const std::string& scalingConfigurationId);
+				std::string getHealthStatus()const;
+				void setHealthStatus(const std::string& healthStatus);
+				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);
+
+            private:
+				std::string instanceId10_;
+				long resourceOwnerId_;
+				std::string instanceId12_;
+				std::string instanceId11_;
+				std::string scalingGroupId_;
+				std::string lifecycleState_;
+				std::string creationType_;
+				int pageNumber_;
+				std::string accessKeyId_;
+				std::string regionId_;
+				int pageSize_;
+				std::string instanceId20_;
+				std::string instanceId1_;
+				std::string instanceId3_;
+				std::string resourceOwnerAccount_;
+				std::string instanceId2_;
+				std::string instanceId5_;
+				std::string instanceId4_;
+				std::string ownerAccount_;
+				std::string instanceId7_;
+				std::string instanceId6_;
+				std::string instanceId9_;
+				std::string instanceId8_;
+				long ownerId_;
+				std::string scalingConfigurationId_;
+				std::string healthStatus_;
+				std::string instanceId18_;
+				std::string instanceId17_;
+				std::string instanceId19_;
+				std::string instanceId14_;
+				std::string instanceId13_;
+				std::string instanceId16_;
+				std::string instanceId15_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGINSTANCESREQUEST_H_

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

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGINSTANCESRESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGINSTANCESRESULT_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 DescribeScalingInstancesResult : public ServiceResult
+			{
+			public:
+				struct ScalingInstance
+				{
+					int loadBalancerWeight;
+					std::string instanceId;
+					std::string scalingGroupId;
+					std::string healthStatus;
+					std::string creationTime;
+					std::string lifecycleState;
+					std::string scalingConfigurationId;
+					std::string creationType;
+				};
+
+
+				DescribeScalingInstancesResult();
+				explicit DescribeScalingInstancesResult(const std::string &payload);
+				~DescribeScalingInstancesResult();
+				int getTotalCount()const;
+				void setTotalCount(int totalCount);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::vector<ScalingInstance> getScalingInstances()const;
+				void setScalingInstances(const std::vector<ScalingInstance>& scalingInstances);
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<ScalingInstance> scalingInstances_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGINSTANCESRESULT_H_

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

@@ -0,0 +1,161 @@
+/*
+ * 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_DESCRIBESCALINGRULESREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGRULESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT DescribeScalingRulesRequest : public EssRequest
+			{
+
+			public:
+				DescribeScalingRulesRequest();
+				~DescribeScalingRulesRequest();
+
+				std::string getScalingRuleName1()const;
+				void setScalingRuleName1(const std::string& scalingRuleName1);
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getScalingRuleName2()const;
+				void setScalingRuleName2(const std::string& scalingRuleName2);
+				std::string getScalingRuleName3()const;
+				void setScalingRuleName3(const std::string& scalingRuleName3);
+				std::string getScalingRuleName4()const;
+				void setScalingRuleName4(const std::string& scalingRuleName4);
+				std::string getScalingRuleName5()const;
+				void setScalingRuleName5(const std::string& scalingRuleName5);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				std::string getScalingRuleName6()const;
+				void setScalingRuleName6(const std::string& scalingRuleName6);
+				std::string getScalingRuleName7()const;
+				void setScalingRuleName7(const std::string& scalingRuleName7);
+				std::string getScalingRuleName8()const;
+				void setScalingRuleName8(const std::string& scalingRuleName8);
+				std::string getScalingRuleAri9()const;
+				void setScalingRuleAri9(const std::string& scalingRuleAri9);
+				std::string getScalingRuleName9()const;
+				void setScalingRuleName9(const std::string& scalingRuleName9);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getScalingRuleId10()const;
+				void setScalingRuleId10(const std::string& scalingRuleId10);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getScalingRuleAri1()const;
+				void setScalingRuleAri1(const std::string& scalingRuleAri1);
+				std::string getScalingRuleAri2()const;
+				void setScalingRuleAri2(const std::string& scalingRuleAri2);
+				std::string getScalingRuleName10()const;
+				void setScalingRuleName10(const std::string& scalingRuleName10);
+				std::string getScalingRuleAri3()const;
+				void setScalingRuleAri3(const std::string& scalingRuleAri3);
+				std::string getScalingRuleAri4()const;
+				void setScalingRuleAri4(const std::string& scalingRuleAri4);
+				std::string getScalingRuleId8()const;
+				void setScalingRuleId8(const std::string& scalingRuleId8);
+				std::string getScalingRuleAri5()const;
+				void setScalingRuleAri5(const std::string& scalingRuleAri5);
+				std::string getScalingRuleId9()const;
+				void setScalingRuleId9(const std::string& scalingRuleId9);
+				std::string getScalingRuleAri6()const;
+				void setScalingRuleAri6(const std::string& scalingRuleAri6);
+				std::string getScalingRuleAri7()const;
+				void setScalingRuleAri7(const std::string& scalingRuleAri7);
+				std::string getScalingRuleAri10()const;
+				void setScalingRuleAri10(const std::string& scalingRuleAri10);
+				std::string getScalingRuleAri8()const;
+				void setScalingRuleAri8(const std::string& scalingRuleAri8);
+				std::string getScalingRuleId4()const;
+				void setScalingRuleId4(const std::string& scalingRuleId4);
+				std::string getScalingRuleId5()const;
+				void setScalingRuleId5(const std::string& scalingRuleId5);
+				std::string getScalingRuleId6()const;
+				void setScalingRuleId6(const std::string& scalingRuleId6);
+				std::string getScalingRuleId7()const;
+				void setScalingRuleId7(const std::string& scalingRuleId7);
+				std::string getScalingRuleId1()const;
+				void setScalingRuleId1(const std::string& scalingRuleId1);
+				std::string getScalingRuleId2()const;
+				void setScalingRuleId2(const std::string& scalingRuleId2);
+				std::string getScalingRuleId3()const;
+				void setScalingRuleId3(const std::string& scalingRuleId3);
+
+            private:
+				std::string scalingRuleName1_;
+				long resourceOwnerId_;
+				std::string scalingRuleName2_;
+				std::string scalingRuleName3_;
+				std::string scalingRuleName4_;
+				std::string scalingRuleName5_;
+				std::string scalingGroupId_;
+				std::string scalingRuleName6_;
+				std::string scalingRuleName7_;
+				std::string scalingRuleName8_;
+				std::string scalingRuleAri9_;
+				std::string scalingRuleName9_;
+				int pageNumber_;
+				std::string accessKeyId_;
+				std::string regionId_;
+				int pageSize_;
+				std::string scalingRuleId10_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string scalingRuleAri1_;
+				std::string scalingRuleAri2_;
+				std::string scalingRuleName10_;
+				std::string scalingRuleAri3_;
+				std::string scalingRuleAri4_;
+				std::string scalingRuleId8_;
+				std::string scalingRuleAri5_;
+				std::string scalingRuleId9_;
+				std::string scalingRuleAri6_;
+				std::string scalingRuleAri7_;
+				std::string scalingRuleAri10_;
+				std::string scalingRuleAri8_;
+				std::string scalingRuleId4_;
+				std::string scalingRuleId5_;
+				std::string scalingRuleId6_;
+				std::string scalingRuleId7_;
+				std::string scalingRuleId1_;
+				std::string scalingRuleId2_;
+				std::string scalingRuleId3_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGRULESREQUEST_H_

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

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGRULESRESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGRULESRESULT_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 DescribeScalingRulesResult : public ServiceResult
+			{
+			public:
+				struct ScalingRule
+				{
+					std::string scalingRuleAri;
+					int minSize;
+					std::string scalingRuleName;
+					int adjustmentValue;
+					std::string scalingGroupId;
+					int cooldown;
+					std::string scalingRuleId;
+					int maxSize;
+					std::string adjustmentType;
+				};
+
+
+				DescribeScalingRulesResult();
+				explicit DescribeScalingRulesResult(const std::string &payload);
+				~DescribeScalingRulesResult();
+				std::vector<ScalingRule> getScalingRules()const;
+				void setScalingRules(const std::vector<ScalingRule>& scalingRules);
+				int getTotalCount()const;
+				void setTotalCount(int totalCount);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<ScalingRule> scalingRules_;
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBESCALINGRULESRESULT_H_

ess/include/alibabacloud/ess/model/DetachInstancesRequest.h

@@ -0,0 +1,122 @@
+/*
+ * 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_DETACHINSTANCESREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DETACHINSTANCESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT DetachInstancesRequest : public EssRequest
+			{
+
+			public:
+				DetachInstancesRequest();
+				~DetachInstancesRequest();
+
+				std::string getInstanceId10()const;
+				void setInstanceId10(const std::string& instanceId10);
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getInstanceId12()const;
+				void setInstanceId12(const std::string& instanceId12);
+				std::string getInstanceId11()const;
+				void setInstanceId11(const std::string& instanceId11);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getInstanceId20()const;
+				void setInstanceId20(const std::string& instanceId20);
+				std::string getInstanceId1()const;
+				void setInstanceId1(const std::string& instanceId1);
+				std::string getInstanceId3()const;
+				void setInstanceId3(const std::string& instanceId3);
+				std::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 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);
+
+            private:
+				std::string instanceId10_;
+				long resourceOwnerId_;
+				std::string instanceId12_;
+				std::string instanceId11_;
+				std::string scalingGroupId_;
+				std::string accessKeyId_;
+				std::string instanceId20_;
+				std::string instanceId1_;
+				std::string instanceId3_;
+				std::string resourceOwnerAccount_;
+				std::string instanceId2_;
+				std::string instanceId5_;
+				std::string instanceId4_;
+				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_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DETACHINSTANCESREQUEST_H_

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

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

ess/include/alibabacloud/ess/model/DisableScalingGroupRequest.h

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

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

ess/include/alibabacloud/ess/model/EnableScalingGroupRequest.h

@@ -0,0 +1,185 @@
+/*
+ * 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_ENABLESCALINGGROUPREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_ENABLESCALINGGROUPREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT EnableScalingGroupRequest : public EssRequest
+			{
+
+			public:
+				EnableScalingGroupRequest();
+				~EnableScalingGroupRequest();
+
+				std::string getInstanceId10()const;
+				void setInstanceId10(const std::string& instanceId10);
+				int getLoadBalancerWeight6()const;
+				void setLoadBalancerWeight6(int loadBalancerWeight6);
+				int getLoadBalancerWeight11()const;
+				void setLoadBalancerWeight11(int loadBalancerWeight11);
+				int getLoadBalancerWeight7()const;
+				void setLoadBalancerWeight7(int loadBalancerWeight7);
+				int getLoadBalancerWeight12()const;
+				void setLoadBalancerWeight12(int loadBalancerWeight12);
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getInstanceId12()const;
+				void setInstanceId12(const std::string& instanceId12);
+				int getLoadBalancerWeight8()const;
+				void setLoadBalancerWeight8(int loadBalancerWeight8);
+				std::string getInstanceId11()const;
+				void setInstanceId11(const std::string& instanceId11);
+				int getLoadBalancerWeight9()const;
+				void setLoadBalancerWeight9(int loadBalancerWeight9);
+				int getLoadBalancerWeight10()const;
+				void setLoadBalancerWeight10(int loadBalancerWeight10);
+				int getLoadBalancerWeight2()const;
+				void setLoadBalancerWeight2(int loadBalancerWeight2);
+				int getLoadBalancerWeight15()const;
+				void setLoadBalancerWeight15(int loadBalancerWeight15);
+				int getLoadBalancerWeight3()const;
+				void setLoadBalancerWeight3(int loadBalancerWeight3);
+				int getLoadBalancerWeight16()const;
+				void setLoadBalancerWeight16(int loadBalancerWeight16);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				int getLoadBalancerWeight4()const;
+				void setLoadBalancerWeight4(int loadBalancerWeight4);
+				int getLoadBalancerWeight13()const;
+				void setLoadBalancerWeight13(int loadBalancerWeight13);
+				int getLoadBalancerWeight5()const;
+				void setLoadBalancerWeight5(int loadBalancerWeight5);
+				int getLoadBalancerWeight14()const;
+				void setLoadBalancerWeight14(int loadBalancerWeight14);
+				std::string getActiveScalingConfigurationId()const;
+				void setActiveScalingConfigurationId(const std::string& activeScalingConfigurationId);
+				int getLoadBalancerWeight1()const;
+				void setLoadBalancerWeight1(int loadBalancerWeight1);
+				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);
+				int getLoadBalancerWeight20()const;
+				void setLoadBalancerWeight20(int loadBalancerWeight20);
+				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 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);
+				int getLoadBalancerWeight19()const;
+				void setLoadBalancerWeight19(int loadBalancerWeight19);
+				std::string getInstanceId17()const;
+				void setInstanceId17(const std::string& instanceId17);
+				int getLoadBalancerWeight17()const;
+				void setLoadBalancerWeight17(int loadBalancerWeight17);
+				std::string getInstanceId19()const;
+				void setInstanceId19(const std::string& instanceId19);
+				int getLoadBalancerWeight18()const;
+				void setLoadBalancerWeight18(int loadBalancerWeight18);
+				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);
+
+            private:
+				std::string instanceId10_;
+				int loadBalancerWeight6_;
+				int loadBalancerWeight11_;
+				int loadBalancerWeight7_;
+				int loadBalancerWeight12_;
+				long resourceOwnerId_;
+				std::string instanceId12_;
+				int loadBalancerWeight8_;
+				std::string instanceId11_;
+				int loadBalancerWeight9_;
+				int loadBalancerWeight10_;
+				int loadBalancerWeight2_;
+				int loadBalancerWeight15_;
+				int loadBalancerWeight3_;
+				int loadBalancerWeight16_;
+				std::string scalingGroupId_;
+				int loadBalancerWeight4_;
+				int loadBalancerWeight13_;
+				int loadBalancerWeight5_;
+				int loadBalancerWeight14_;
+				std::string activeScalingConfigurationId_;
+				int loadBalancerWeight1_;
+				std::string accessKeyId_;
+				std::string instanceId20_;
+				std::string instanceId1_;
+				int loadBalancerWeight20_;
+				std::string instanceId3_;
+				std::string resourceOwnerAccount_;
+				std::string instanceId2_;
+				std::string instanceId5_;
+				std::string instanceId4_;
+				std::string ownerAccount_;
+				std::string instanceId7_;
+				std::string instanceId6_;
+				std::string instanceId9_;
+				std::string instanceId8_;
+				long ownerId_;
+				std::string instanceId18_;
+				int loadBalancerWeight19_;
+				std::string instanceId17_;
+				int loadBalancerWeight17_;
+				std::string instanceId19_;
+				int loadBalancerWeight18_;
+				std::string instanceId14_;
+				std::string instanceId13_;
+				std::string instanceId16_;
+				std::string instanceId15_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_ENABLESCALINGGROUPREQUEST_H_

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

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

@@ -0,0 +1,65 @@
+/*
+ * 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_EXECUTESCALINGRULEREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_EXECUTESCALINGRULEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT ExecuteScalingRuleRequest : public EssRequest
+			{
+
+			public:
+				ExecuteScalingRuleRequest();
+				~ExecuteScalingRuleRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getScalingRuleAri()const;
+				void setScalingRuleAri(const std::string& scalingRuleAri);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				long resourceOwnerId_;
+				std::string scalingRuleAri_;
+				std::string resourceOwnerAccount_;
+				std::string clientToken_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_EXECUTESCALINGRULEREQUEST_H_

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

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

ess/include/alibabacloud/ess/model/ModifyAlertConfigRequest.h

@@ -0,0 +1,65 @@
+/*
+ * 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_MODIFYALERTCONFIGREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_MODIFYALERTCONFIGREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT ModifyAlertConfigRequest : public EssRequest
+			{
+
+			public:
+				ModifyAlertConfigRequest();
+				~ModifyAlertConfigRequest();
+
+				int getSuccessConfig()const;
+				void setSuccessConfig(int successConfig);
+				int getRejectConfig()const;
+				void setRejectConfig(int rejectConfig);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				int getFailConfig()const;
+				void setFailConfig(int failConfig);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				int successConfig_;
+				int rejectConfig_;
+				std::string resourceOwnerAccount_;
+				std::string scalingGroupId_;
+				long ownerId_;
+				int failConfig_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_MODIFYALERTCONFIGREQUEST_H_

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

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

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ESS_MODEL_MODIFYSCALINGGROUPREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_MODIFYSCALINGGROUPREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT ModifyScalingGroupRequest : public EssRequest
+			{
+
+			public:
+				ModifyScalingGroupRequest();
+				~ModifyScalingGroupRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getScalingGroupName()const;
+				void setScalingGroupName(const std::string& scalingGroupName);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getActiveScalingConfigurationId()const;
+				void setActiveScalingConfigurationId(const std::string& activeScalingConfigurationId);
+				int getMinSize()const;
+				void setMinSize(int minSize);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				int getMaxSize()const;
+				void setMaxSize(int maxSize);
+				int getDefaultCooldown()const;
+				void setDefaultCooldown(int defaultCooldown);
+				std::string getRemovalPolicy1()const;
+				void setRemovalPolicy1(const std::string& removalPolicy1);
+				std::string getRemovalPolicy2()const;
+				void setRemovalPolicy2(const std::string& removalPolicy2);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string scalingGroupName_;
+				std::string scalingGroupId_;
+				std::string ownerAccount_;
+				std::string activeScalingConfigurationId_;
+				int minSize_;
+				long ownerId_;
+				std::string accessKeyId_;
+				int maxSize_;
+				int defaultCooldown_;
+				std::string removalPolicy1_;
+				std::string removalPolicy2_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_MODIFYSCALINGGROUPREQUEST_H_

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

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

@@ -0,0 +1,74 @@
+/*
+ * 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_MODIFYSCALINGRULEREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_MODIFYSCALINGRULEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT ModifyScalingRuleRequest : public EssRequest
+			{
+
+			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::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);
+				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);
+
+            private:
+				std::string scalingRuleName_;
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				int adjustmentValue_;
+				std::string ownerAccount_;
+				int cooldown_;
+				std::string adjustmentType_;
+				long ownerId_;
+				std::string scalingRuleId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_MODIFYSCALINGRULEREQUEST_H_

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

ess/include/alibabacloud/ess/model/ModifyScheduledTaskRequest.h

@@ -0,0 +1,89 @@
+/*
+ * 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_MODIFYSCHEDULEDTASKREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_MODIFYSCHEDULEDTASKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT ModifyScheduledTaskRequest : public EssRequest
+			{
+
+			public:
+				ModifyScheduledTaskRequest();
+				~ModifyScheduledTaskRequest();
+
+				std::string getLaunchTime()const;
+				void setLaunchTime(const std::string& launchTime);
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getScheduledAction()const;
+				void setScheduledAction(const std::string& scheduledAction);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getRecurrenceValue()const;
+				void setRecurrenceValue(const std::string& recurrenceValue);
+				int getLaunchExpirationTime()const;
+				void setLaunchExpirationTime(int launchExpirationTime);
+				std::string getRecurrenceEndTime()const;
+				void setRecurrenceEndTime(const std::string& recurrenceEndTime);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getScheduledTaskName()const;
+				void setScheduledTaskName(const std::string& scheduledTaskName);
+				bool getTaskEnabled()const;
+				void setTaskEnabled(bool taskEnabled);
+				std::string getScheduledTaskId()const;
+				void setScheduledTaskId(const std::string& scheduledTaskId);
+				std::string getRecurrenceType()const;
+				void setRecurrenceType(const std::string& recurrenceType);
+
+            private:
+				std::string launchTime_;
+				long resourceOwnerId_;
+				std::string scheduledAction_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				std::string description_;
+				long ownerId_;
+				std::string recurrenceValue_;
+				int launchExpirationTime_;
+				std::string recurrenceEndTime_;
+				std::string accessKeyId_;
+				std::string scheduledTaskName_;
+				bool taskEnabled_;
+				std::string scheduledTaskId_;
+				std::string recurrenceType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_MODIFYSCHEDULEDTASKREQUEST_H_

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

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

@@ -0,0 +1,122 @@
+/*
+ * 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_REMOVEINSTANCESREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_REMOVEINSTANCESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT RemoveInstancesRequest : public EssRequest
+			{
+
+			public:
+				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::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 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);
+
+            private:
+				std::string instanceId10_;
+				long resourceOwnerId_;
+				std::string instanceId12_;
+				std::string instanceId11_;
+				std::string scalingGroupId_;
+				std::string accessKeyId_;
+				std::string instanceId20_;
+				std::string instanceId1_;
+				std::string instanceId3_;
+				std::string resourceOwnerAccount_;
+				std::string instanceId2_;
+				std::string instanceId5_;
+				std::string instanceId4_;
+				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_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_REMOVEINSTANCESREQUEST_H_

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

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

ess/include/alibabacloud/ess/model/VerifyAuthenticationRequest.h

@@ -0,0 +1,59 @@
+/*
+ * 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_VERIFYAUTHENTICATIONREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_VERIFYAUTHENTICATIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT VerifyAuthenticationRequest : public EssRequest
+			{
+
+			public:
+				VerifyAuthenticationRequest();
+				~VerifyAuthenticationRequest();
+
+				long getUid()const;
+				void setUid(long uid);
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				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:
+				long uid_;
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_VERIFYAUTHENTICATIONREQUEST_H_

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

ess/include/alibabacloud/ess/model/VerifyUserRequest.h

@@ -0,0 +1,56 @@
+/*
+ * 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_VERIFYUSERREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_VERIFYUSERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/ess/EssRequest.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT VerifyUserRequest : public EssRequest
+			{
+
+			public:
+				VerifyUserRequest();
+				~VerifyUserRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				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:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_VERIFYUSERREQUEST_H_

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

ess/src/EssClient.cc

@@ -0,0 +1,1213 @@
+/*
+ * 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/EssClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Ess;
+using namespace AlibabaCloud::Ess::Model;
+
+EssClient::EssClient(const Credentials &credentials, const ClientConfiguration &configuration) :
+	RpcServiceClient(std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), "ess");
+}
+
+EssClient::EssClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
+	RpcServiceClient(credentialsProvider, configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), "ess");
+}
+
+EssClient::EssClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
+	RpcServiceClient(std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), "ess");
+}
+
+EssClient::~EssClient()
+{}
+
+CoreClient::EndpointOutcome EssClient::endpoint()const
+{
+	if(!configuration().endpoint().empty())
+		return CoreClient::EndpointOutcome(configuration().endpoint());
+
+	auto endpoint = endpointProvider_->getEndpoint();
+	
+	if (endpoint.empty())
+		return CoreClient::EndpointOutcome(Error("InvalidEndpoint",""));
+	else
+		return CoreClient::EndpointOutcome(endpoint);
+}
+
+EssClient::AttachInstancesOutcome EssClient::attachInstances(const AttachInstancesRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return AttachInstancesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AttachInstancesOutcome(AttachInstancesResult(outcome.result()));
+	else
+		return AttachInstancesOutcome(outcome.error());
+}
+
+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, attachInstances(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::AttachInstancesOutcomeCallable EssClient::attachInstancesCallable(const AttachInstancesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AttachInstancesOutcome()>>(
+			[this, request]()
+			{
+			return this->attachInstances(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::DescribeScalingGroupsOutcome EssClient::describeScalingGroups(const DescribeScalingGroupsRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScalingGroupsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScalingGroupsOutcome(DescribeScalingGroupsResult(outcome.result()));
+	else
+		return DescribeScalingGroupsOutcome(outcome.error());
+}
+
+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, describeScalingGroups(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DescribeScalingGroupsOutcomeCallable EssClient::describeScalingGroupsCallable(const DescribeScalingGroupsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScalingGroupsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScalingGroups(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::DescribeScalingActivitiesOutcome EssClient::describeScalingActivities(const DescribeScalingActivitiesRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScalingActivitiesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScalingActivitiesOutcome(DescribeScalingActivitiesResult(outcome.result()));
+	else
+		return DescribeScalingActivitiesOutcome(outcome.error());
+}
+
+void EssClient::describeScalingActivitiesAsync(const DescribeScalingActivitiesRequest& request, const DescribeScalingActivitiesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScalingActivities(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DescribeScalingActivitiesOutcomeCallable EssClient::describeScalingActivitiesCallable(const DescribeScalingActivitiesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScalingActivitiesOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScalingActivities(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::DescribeScalingRulesOutcome EssClient::describeScalingRules(const DescribeScalingRulesRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScalingRulesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScalingRulesOutcome(DescribeScalingRulesResult(outcome.result()));
+	else
+		return DescribeScalingRulesOutcome(outcome.error());
+}
+
+void EssClient::describeScalingRulesAsync(const DescribeScalingRulesRequest& request, const DescribeScalingRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScalingRules(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DescribeScalingRulesOutcomeCallable EssClient::describeScalingRulesCallable(const DescribeScalingRulesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScalingRulesOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScalingRules(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::ModifyScalingGroupOutcome EssClient::modifyScalingGroup(const ModifyScalingGroupRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyScalingGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyScalingGroupOutcome(ModifyScalingGroupResult(outcome.result()));
+	else
+		return ModifyScalingGroupOutcome(outcome.error());
+}
+
+void EssClient::modifyScalingGroupAsync(const ModifyScalingGroupRequest& request, const ModifyScalingGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyScalingGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::ModifyScalingGroupOutcomeCallable EssClient::modifyScalingGroupCallable(const ModifyScalingGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyScalingGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyScalingGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::EnableScalingGroupOutcome EssClient::enableScalingGroup(const EnableScalingGroupRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return EnableScalingGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EnableScalingGroupOutcome(EnableScalingGroupResult(outcome.result()));
+	else
+		return EnableScalingGroupOutcome(outcome.error());
+}
+
+void EssClient::enableScalingGroupAsync(const EnableScalingGroupRequest& request, const EnableScalingGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, enableScalingGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::EnableScalingGroupOutcomeCallable EssClient::enableScalingGroupCallable(const EnableScalingGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EnableScalingGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->enableScalingGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::DeactivateScalingConfigurationOutcome EssClient::deactivateScalingConfiguration(const DeactivateScalingConfigurationRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeactivateScalingConfigurationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeactivateScalingConfigurationOutcome(DeactivateScalingConfigurationResult(outcome.result()));
+	else
+		return DeactivateScalingConfigurationOutcome(outcome.error());
+}
+
+void EssClient::deactivateScalingConfigurationAsync(const DeactivateScalingConfigurationRequest& request, const DeactivateScalingConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deactivateScalingConfiguration(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DeactivateScalingConfigurationOutcomeCallable EssClient::deactivateScalingConfigurationCallable(const DeactivateScalingConfigurationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeactivateScalingConfigurationOutcome()>>(
+			[this, request]()
+			{
+			return this->deactivateScalingConfiguration(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::VerifyAuthenticationOutcome EssClient::verifyAuthentication(const VerifyAuthenticationRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return VerifyAuthenticationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return VerifyAuthenticationOutcome(VerifyAuthenticationResult(outcome.result()));
+	else
+		return VerifyAuthenticationOutcome(outcome.error());
+}
+
+void EssClient::verifyAuthenticationAsync(const VerifyAuthenticationRequest& request, const VerifyAuthenticationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, verifyAuthentication(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::VerifyAuthenticationOutcomeCallable EssClient::verifyAuthenticationCallable(const VerifyAuthenticationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<VerifyAuthenticationOutcome()>>(
+			[this, request]()
+			{
+			return this->verifyAuthentication(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::CreateScheduledTaskOutcome EssClient::createScheduledTask(const CreateScheduledTaskRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateScheduledTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateScheduledTaskOutcome(CreateScheduledTaskResult(outcome.result()));
+	else
+		return CreateScheduledTaskOutcome(outcome.error());
+}
+
+void EssClient::createScheduledTaskAsync(const CreateScheduledTaskRequest& request, const CreateScheduledTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createScheduledTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::CreateScheduledTaskOutcomeCallable EssClient::createScheduledTaskCallable(const CreateScheduledTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateScheduledTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->createScheduledTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::DeleteScheduledTaskOutcome EssClient::deleteScheduledTask(const DeleteScheduledTaskRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteScheduledTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteScheduledTaskOutcome(DeleteScheduledTaskResult(outcome.result()));
+	else
+		return DeleteScheduledTaskOutcome(outcome.error());
+}
+
+void EssClient::deleteScheduledTaskAsync(const DeleteScheduledTaskRequest& request, const DeleteScheduledTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteScheduledTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DeleteScheduledTaskOutcomeCallable EssClient::deleteScheduledTaskCallable(const DeleteScheduledTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteScheduledTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteScheduledTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::CreateScalingRuleOutcome EssClient::createScalingRule(const CreateScalingRuleRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateScalingRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateScalingRuleOutcome(CreateScalingRuleResult(outcome.result()));
+	else
+		return CreateScalingRuleOutcome(outcome.error());
+}
+
+void EssClient::createScalingRuleAsync(const CreateScalingRuleRequest& request, const CreateScalingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createScalingRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::CreateScalingRuleOutcomeCallable EssClient::createScalingRuleCallable(const CreateScalingRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateScalingRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->createScalingRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::DescribeScalingConfigurationsOutcome EssClient::describeScalingConfigurations(const DescribeScalingConfigurationsRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScalingConfigurationsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScalingConfigurationsOutcome(DescribeScalingConfigurationsResult(outcome.result()));
+	else
+		return DescribeScalingConfigurationsOutcome(outcome.error());
+}
+
+void EssClient::describeScalingConfigurationsAsync(const DescribeScalingConfigurationsRequest& request, const DescribeScalingConfigurationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScalingConfigurations(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DescribeScalingConfigurationsOutcomeCallable EssClient::describeScalingConfigurationsCallable(const DescribeScalingConfigurationsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScalingConfigurationsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScalingConfigurations(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::ModifyScheduledTaskOutcome EssClient::modifyScheduledTask(const ModifyScheduledTaskRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyScheduledTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyScheduledTaskOutcome(ModifyScheduledTaskResult(outcome.result()));
+	else
+		return ModifyScheduledTaskOutcome(outcome.error());
+}
+
+void EssClient::modifyScheduledTaskAsync(const ModifyScheduledTaskRequest& request, const ModifyScheduledTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyScheduledTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::ModifyScheduledTaskOutcomeCallable EssClient::modifyScheduledTaskCallable(const ModifyScheduledTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyScheduledTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyScheduledTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::RemoveInstancesOutcome EssClient::removeInstances(const RemoveInstancesRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return RemoveInstancesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RemoveInstancesOutcome(RemoveInstancesResult(outcome.result()));
+	else
+		return RemoveInstancesOutcome(outcome.error());
+}
+
+void EssClient::removeInstancesAsync(const RemoveInstancesRequest& request, const RemoveInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, removeInstances(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::RemoveInstancesOutcomeCallable EssClient::removeInstancesCallable(const RemoveInstancesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RemoveInstancesOutcome()>>(
+			[this, request]()
+			{
+			return this->removeInstances(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::ExecuteScalingRuleOutcome EssClient::executeScalingRule(const ExecuteScalingRuleRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ExecuteScalingRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ExecuteScalingRuleOutcome(ExecuteScalingRuleResult(outcome.result()));
+	else
+		return ExecuteScalingRuleOutcome(outcome.error());
+}
+
+void EssClient::executeScalingRuleAsync(const ExecuteScalingRuleRequest& request, const ExecuteScalingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, executeScalingRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::ExecuteScalingRuleOutcomeCallable EssClient::executeScalingRuleCallable(const ExecuteScalingRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ExecuteScalingRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->executeScalingRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::DeleteScalingGroupOutcome EssClient::deleteScalingGroup(const DeleteScalingGroupRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteScalingGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteScalingGroupOutcome(DeleteScalingGroupResult(outcome.result()));
+	else
+		return DeleteScalingGroupOutcome(outcome.error());
+}
+
+void EssClient::deleteScalingGroupAsync(const DeleteScalingGroupRequest& request, const DeleteScalingGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteScalingGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DeleteScalingGroupOutcomeCallable EssClient::deleteScalingGroupCallable(const DeleteScalingGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteScalingGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteScalingGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::DescribeScalingInstancesOutcome EssClient::describeScalingInstances(const DescribeScalingInstancesRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScalingInstancesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScalingInstancesOutcome(DescribeScalingInstancesResult(outcome.result()));
+	else
+		return DescribeScalingInstancesOutcome(outcome.error());
+}
+
+void EssClient::describeScalingInstancesAsync(const DescribeScalingInstancesRequest& request, const DescribeScalingInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScalingInstances(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DescribeScalingInstancesOutcomeCallable EssClient::describeScalingInstancesCallable(const DescribeScalingInstancesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScalingInstancesOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScalingInstances(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::CreateScalingConfigurationOutcome EssClient::createScalingConfiguration(const CreateScalingConfigurationRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateScalingConfigurationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateScalingConfigurationOutcome(CreateScalingConfigurationResult(outcome.result()));
+	else
+		return CreateScalingConfigurationOutcome(outcome.error());
+}
+
+void EssClient::createScalingConfigurationAsync(const CreateScalingConfigurationRequest& request, const CreateScalingConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createScalingConfiguration(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::CreateScalingConfigurationOutcomeCallable EssClient::createScalingConfigurationCallable(const CreateScalingConfigurationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateScalingConfigurationOutcome()>>(
+			[this, request]()
+			{
+			return this->createScalingConfiguration(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::DescribeCapacityHistoryOutcome EssClient::describeCapacityHistory(const DescribeCapacityHistoryRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeCapacityHistoryOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeCapacityHistoryOutcome(DescribeCapacityHistoryResult(outcome.result()));
+	else
+		return DescribeCapacityHistoryOutcome(outcome.error());
+}
+
+void EssClient::describeCapacityHistoryAsync(const DescribeCapacityHistoryRequest& request, const DescribeCapacityHistoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeCapacityHistory(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DescribeCapacityHistoryOutcomeCallable EssClient::describeCapacityHistoryCallable(const DescribeCapacityHistoryRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeCapacityHistoryOutcome()>>(
+			[this, request]()
+			{
+			return this->describeCapacityHistory(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::DescribeRegionsOutcome EssClient::describeRegions(const DescribeRegionsRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeRegionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeRegionsOutcome(DescribeRegionsResult(outcome.result()));
+	else
+		return DescribeRegionsOutcome(outcome.error());
+}
+
+void EssClient::describeRegionsAsync(const DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeRegions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DescribeRegionsOutcomeCallable EssClient::describeRegionsCallable(const DescribeRegionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeRegionsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeRegions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::DescribeAccountAttributesOutcome EssClient::describeAccountAttributes(const DescribeAccountAttributesRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeAccountAttributesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeAccountAttributesOutcome(DescribeAccountAttributesResult(outcome.result()));
+	else
+		return DescribeAccountAttributesOutcome(outcome.error());
+}
+
+void EssClient::describeAccountAttributesAsync(const DescribeAccountAttributesRequest& request, const DescribeAccountAttributesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeAccountAttributes(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DescribeAccountAttributesOutcomeCallable EssClient::describeAccountAttributesCallable(const DescribeAccountAttributesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeAccountAttributesOutcome()>>(
+			[this, request]()
+			{
+			return this->describeAccountAttributes(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::DetachInstancesOutcome EssClient::detachInstances(const DetachInstancesRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetachInstancesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetachInstancesOutcome(DetachInstancesResult(outcome.result()));
+	else
+		return DetachInstancesOutcome(outcome.error());
+}
+
+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, detachInstances(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DetachInstancesOutcomeCallable EssClient::detachInstancesCallable(const DetachInstancesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetachInstancesOutcome()>>(
+			[this, request]()
+			{
+			return this->detachInstances(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::DescribeLimitationOutcome EssClient::describeLimitation(const DescribeLimitationRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLimitationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLimitationOutcome(DescribeLimitationResult(outcome.result()));
+	else
+		return DescribeLimitationOutcome(outcome.error());
+}
+
+void EssClient::describeLimitationAsync(const DescribeLimitationRequest& request, const DescribeLimitationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLimitation(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DescribeLimitationOutcomeCallable EssClient::describeLimitationCallable(const DescribeLimitationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLimitationOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLimitation(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::DescribeScalingActivityDetailOutcome EssClient::describeScalingActivityDetail(const DescribeScalingActivityDetailRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScalingActivityDetailOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScalingActivityDetailOutcome(DescribeScalingActivityDetailResult(outcome.result()));
+	else
+		return DescribeScalingActivityDetailOutcome(outcome.error());
+}
+
+void EssClient::describeScalingActivityDetailAsync(const DescribeScalingActivityDetailRequest& request, const DescribeScalingActivityDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScalingActivityDetail(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DescribeScalingActivityDetailOutcomeCallable EssClient::describeScalingActivityDetailCallable(const DescribeScalingActivityDetailRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScalingActivityDetailOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScalingActivityDetail(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::DescribeAlertConfigOutcome EssClient::describeAlertConfig(const DescribeAlertConfigRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeAlertConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeAlertConfigOutcome(DescribeAlertConfigResult(outcome.result()));
+	else
+		return DescribeAlertConfigOutcome(outcome.error());
+}
+
+void EssClient::describeAlertConfigAsync(const DescribeAlertConfigRequest& request, const DescribeAlertConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeAlertConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DescribeAlertConfigOutcomeCallable EssClient::describeAlertConfigCallable(const DescribeAlertConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeAlertConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->describeAlertConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::CreateScalingGroupOutcome EssClient::createScalingGroup(const CreateScalingGroupRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateScalingGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateScalingGroupOutcome(CreateScalingGroupResult(outcome.result()));
+	else
+		return CreateScalingGroupOutcome(outcome.error());
+}
+
+void EssClient::createScalingGroupAsync(const CreateScalingGroupRequest& request, const CreateScalingGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createScalingGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::CreateScalingGroupOutcomeCallable EssClient::createScalingGroupCallable(const CreateScalingGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateScalingGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->createScalingGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::DeleteScalingConfigurationOutcome EssClient::deleteScalingConfiguration(const DeleteScalingConfigurationRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteScalingConfigurationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteScalingConfigurationOutcome(DeleteScalingConfigurationResult(outcome.result()));
+	else
+		return DeleteScalingConfigurationOutcome(outcome.error());
+}
+
+void EssClient::deleteScalingConfigurationAsync(const DeleteScalingConfigurationRequest& request, const DeleteScalingConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteScalingConfiguration(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DeleteScalingConfigurationOutcomeCallable EssClient::deleteScalingConfigurationCallable(const DeleteScalingConfigurationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteScalingConfigurationOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteScalingConfiguration(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::DisableScalingGroupOutcome EssClient::disableScalingGroup(const DisableScalingGroupRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DisableScalingGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DisableScalingGroupOutcome(DisableScalingGroupResult(outcome.result()));
+	else
+		return DisableScalingGroupOutcome(outcome.error());
+}
+
+void EssClient::disableScalingGroupAsync(const DisableScalingGroupRequest& request, const DisableScalingGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, disableScalingGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DisableScalingGroupOutcomeCallable EssClient::disableScalingGroupCallable(const DisableScalingGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DisableScalingGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->disableScalingGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::ModifyScalingRuleOutcome EssClient::modifyScalingRule(const ModifyScalingRuleRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyScalingRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyScalingRuleOutcome(ModifyScalingRuleResult(outcome.result()));
+	else
+		return ModifyScalingRuleOutcome(outcome.error());
+}
+
+void EssClient::modifyScalingRuleAsync(const ModifyScalingRuleRequest& request, const ModifyScalingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyScalingRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::ModifyScalingRuleOutcomeCallable EssClient::modifyScalingRuleCallable(const ModifyScalingRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyScalingRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyScalingRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::DeleteScalingRuleOutcome EssClient::deleteScalingRule(const DeleteScalingRuleRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteScalingRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteScalingRuleOutcome(DeleteScalingRuleResult(outcome.result()));
+	else
+		return DeleteScalingRuleOutcome(outcome.error());
+}
+
+void EssClient::deleteScalingRuleAsync(const DeleteScalingRuleRequest& request, const DeleteScalingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteScalingRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DeleteScalingRuleOutcomeCallable EssClient::deleteScalingRuleCallable(const DeleteScalingRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteScalingRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteScalingRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::VerifyUserOutcome EssClient::verifyUser(const VerifyUserRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return VerifyUserOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return VerifyUserOutcome(VerifyUserResult(outcome.result()));
+	else
+		return VerifyUserOutcome(outcome.error());
+}
+
+void EssClient::verifyUserAsync(const VerifyUserRequest& request, const VerifyUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, verifyUser(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::VerifyUserOutcomeCallable EssClient::verifyUserCallable(const VerifyUserRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<VerifyUserOutcome()>>(
+			[this, request]()
+			{
+			return this->verifyUser(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EssClient::ModifyAlertConfigOutcome EssClient::modifyAlertConfig(const ModifyAlertConfigRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyAlertConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyAlertConfigOutcome(ModifyAlertConfigResult(outcome.result()));
+	else
+		return ModifyAlertConfigOutcome(outcome.error());
+}
+
+void EssClient::modifyAlertConfigAsync(const ModifyAlertConfigRequest& request, const ModifyAlertConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyAlertConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::ModifyAlertConfigOutcomeCallable EssClient::modifyAlertConfigCallable(const ModifyAlertConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyAlertConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyAlertConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

ess/src/EssRequest.cc

@@ -0,0 +1,27 @@
+/*
+ * 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/EssRequest.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Ess;
+
+EssRequest::EssRequest(const std::string & action) :
+	RpcServiceRequest("ess", "2014-08-28", action)
+{ }
+
+EssRequest::~EssRequest()
+{ }

ess/src/model/AttachInstancesRequest.cc

@@ -0,0 +1,534 @@
+/*
+ * 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/AttachInstancesRequest.h>
+
+using namespace AlibabaCloud::Ess;
+using namespace AlibabaCloud::Ess::Model;
+
+AttachInstancesRequest::AttachInstancesRequest() :
+	EssRequest("AttachInstances")
+{}
+
+AttachInstancesRequest::~AttachInstancesRequest()
+{}
+
+std::string AttachInstancesRequest::getInstanceId10()const
+{
+	return instanceId10_;
+}
+
+void AttachInstancesRequest::setInstanceId10(const std::string& instanceId10)
+{
+	instanceId10_ = instanceId10;
+	setParameter("InstanceId10", instanceId10);
+}
+
+int AttachInstancesRequest::getLoadBalancerWeight6()const
+{
+	return loadBalancerWeight6_;
+}
+
+void AttachInstancesRequest::setLoadBalancerWeight6(int loadBalancerWeight6)
+{
+	loadBalancerWeight6_ = loadBalancerWeight6;
+	setParameter("LoadBalancerWeight6", std::to_string(loadBalancerWeight6));
+}
+
+int AttachInstancesRequest::getLoadBalancerWeight11()const
+{
+	return loadBalancerWeight11_;
+}
+
+void AttachInstancesRequest::setLoadBalancerWeight11(int loadBalancerWeight11)
+{
+	loadBalancerWeight11_ = loadBalancerWeight11;
+	setParameter("LoadBalancerWeight11", std::to_string(loadBalancerWeight11));
+}
+
+int AttachInstancesRequest::getLoadBalancerWeight7()const
+{
+	return loadBalancerWeight7_;
+}
+
+void AttachInstancesRequest::setLoadBalancerWeight7(int loadBalancerWeight7)
+{
+	loadBalancerWeight7_ = loadBalancerWeight7;
+	setParameter("LoadBalancerWeight7", std::to_string(loadBalancerWeight7));
+}
+
+int AttachInstancesRequest::getLoadBalancerWeight12()const
+{
+	return loadBalancerWeight12_;
+}
+
+void AttachInstancesRequest::setLoadBalancerWeight12(int loadBalancerWeight12)
+{
+	loadBalancerWeight12_ = loadBalancerWeight12;
+	setParameter("LoadBalancerWeight12", std::to_string(loadBalancerWeight12));
+}
+
+long AttachInstancesRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void AttachInstancesRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string AttachInstancesRequest::getInstanceId12()const
+{
+	return instanceId12_;
+}
+
+void AttachInstancesRequest::setInstanceId12(const std::string& instanceId12)
+{
+	instanceId12_ = instanceId12;
+	setParameter("InstanceId12", instanceId12);
+}
+
+int AttachInstancesRequest::getLoadBalancerWeight8()const
+{
+	return loadBalancerWeight8_;
+}
+
+void AttachInstancesRequest::setLoadBalancerWeight8(int loadBalancerWeight8)
+{
+	loadBalancerWeight8_ = loadBalancerWeight8;
+	setParameter("LoadBalancerWeight8", std::to_string(loadBalancerWeight8));
+}
+
+std::string AttachInstancesRequest::getInstanceId11()const
+{
+	return instanceId11_;
+}
+
+void AttachInstancesRequest::setInstanceId11(const std::string& instanceId11)
+{
+	instanceId11_ = instanceId11;
+	setParameter("InstanceId11", instanceId11);
+}
+
+int AttachInstancesRequest::getLoadBalancerWeight9()const
+{
+	return loadBalancerWeight9_;
+}
+
+void AttachInstancesRequest::setLoadBalancerWeight9(int loadBalancerWeight9)
+{
+	loadBalancerWeight9_ = loadBalancerWeight9;
+	setParameter("LoadBalancerWeight9", std::to_string(loadBalancerWeight9));
+}
+
+int AttachInstancesRequest::getLoadBalancerWeight10()const
+{
+	return loadBalancerWeight10_;
+}
+
+void AttachInstancesRequest::setLoadBalancerWeight10(int loadBalancerWeight10)
+{
+	loadBalancerWeight10_ = loadBalancerWeight10;
+	setParameter("LoadBalancerWeight10", std::to_string(loadBalancerWeight10));
+}
+
+int AttachInstancesRequest::getLoadBalancerWeight2()const
+{
+	return loadBalancerWeight2_;
+}
+
+void AttachInstancesRequest::setLoadBalancerWeight2(int loadBalancerWeight2)
+{
+	loadBalancerWeight2_ = loadBalancerWeight2;
+	setParameter("LoadBalancerWeight2", std::to_string(loadBalancerWeight2));
+}
+
+int AttachInstancesRequest::getLoadBalancerWeight15()const
+{
+	return loadBalancerWeight15_;
+}
+
+void AttachInstancesRequest::setLoadBalancerWeight15(int loadBalancerWeight15)
+{
+	loadBalancerWeight15_ = loadBalancerWeight15;
+	setParameter("LoadBalancerWeight15", std::to_string(loadBalancerWeight15));
+}
+
+int AttachInstancesRequest::getLoadBalancerWeight3()const
+{
+	return loadBalancerWeight3_;
+}
+
+void AttachInstancesRequest::setLoadBalancerWeight3(int loadBalancerWeight3)
+{
+	loadBalancerWeight3_ = loadBalancerWeight3;
+	setParameter("LoadBalancerWeight3", std::to_string(loadBalancerWeight3));
+}
+
+int AttachInstancesRequest::getLoadBalancerWeight16()const
+{
+	return loadBalancerWeight16_;
+}
+
+void AttachInstancesRequest::setLoadBalancerWeight16(int loadBalancerWeight16)
+{
+	loadBalancerWeight16_ = loadBalancerWeight16;
+	setParameter("LoadBalancerWeight16", std::to_string(loadBalancerWeight16));
+}
+
+std::string AttachInstancesRequest::getScalingGroupId()const
+{
+	return scalingGroupId_;
+}
+
+void AttachInstancesRequest::setScalingGroupId(const std::string& scalingGroupId)
+{
+	scalingGroupId_ = scalingGroupId;
+	setParameter("ScalingGroupId", scalingGroupId);
+}
+
+int AttachInstancesRequest::getLoadBalancerWeight4()const
+{
+	return loadBalancerWeight4_;
+}
+
+void AttachInstancesRequest::setLoadBalancerWeight4(int loadBalancerWeight4)
+{
+	loadBalancerWeight4_ = loadBalancerWeight4;
+	setParameter("LoadBalancerWeight4", std::to_string(loadBalancerWeight4));
+}
+
+int AttachInstancesRequest::getLoadBalancerWeight13()const
+{
+	return loadBalancerWeight13_;
+}
+
+void AttachInstancesRequest::setLoadBalancerWeight13(int loadBalancerWeight13)
+{
+	loadBalancerWeight13_ = loadBalancerWeight13;
+	setParameter("LoadBalancerWeight13", std::to_string(loadBalancerWeight13));
+}
+
+int AttachInstancesRequest::getLoadBalancerWeight5()const
+{
+	return loadBalancerWeight5_;
+}
+
+void AttachInstancesRequest::setLoadBalancerWeight5(int loadBalancerWeight5)
+{
+	loadBalancerWeight5_ = loadBalancerWeight5;
+	setParameter("LoadBalancerWeight5", std::to_string(loadBalancerWeight5));
+}
+
+int AttachInstancesRequest::getLoadBalancerWeight14()const
+{
+	return loadBalancerWeight14_;
+}
+
+void AttachInstancesRequest::setLoadBalancerWeight14(int loadBalancerWeight14)
+{
+	loadBalancerWeight14_ = loadBalancerWeight14;
+	setParameter("LoadBalancerWeight14", std::to_string(loadBalancerWeight14));
+}
+
+int AttachInstancesRequest::getLoadBalancerWeight1()const
+{
+	return loadBalancerWeight1_;
+}
+
+void AttachInstancesRequest::setLoadBalancerWeight1(int loadBalancerWeight1)
+{
+	loadBalancerWeight1_ = loadBalancerWeight1;
+	setParameter("LoadBalancerWeight1", std::to_string(loadBalancerWeight1));
+}
+
+std::string AttachInstancesRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void AttachInstancesRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string AttachInstancesRequest::getInstanceId20()const
+{
+	return instanceId20_;
+}
+
+void AttachInstancesRequest::setInstanceId20(const std::string& instanceId20)
+{
+	instanceId20_ = instanceId20;
+	setParameter("InstanceId20", instanceId20);
+}
+
+std::string AttachInstancesRequest::getInstanceId1()const
+{
+	return instanceId1_;
+}
+
+void AttachInstancesRequest::setInstanceId1(const std::string& instanceId1)
+{
+	instanceId1_ = instanceId1;
+	setParameter("InstanceId1", instanceId1);
+}
+
+int AttachInstancesRequest::getLoadBalancerWeight20()const
+{
+	return loadBalancerWeight20_;
+}
+
+void AttachInstancesRequest::setLoadBalancerWeight20(int loadBalancerWeight20)
+{
+	loadBalancerWeight20_ = loadBalancerWeight20;
+	setParameter("LoadBalancerWeight20", std::to_string(loadBalancerWeight20));
+}
+
+std::string AttachInstancesRequest::getInstanceId3()const
+{
+	return instanceId3_;
+}
+
+void AttachInstancesRequest::setInstanceId3(const std::string& instanceId3)
+{
+	instanceId3_ = instanceId3;
+	setParameter("InstanceId3", instanceId3);
+}
+
+std::string AttachInstancesRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void AttachInstancesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string AttachInstancesRequest::getInstanceId2()const
+{
+	return instanceId2_;
+}
+
+void AttachInstancesRequest::setInstanceId2(const std::string& instanceId2)
+{
+	instanceId2_ = instanceId2;
+	setParameter("InstanceId2", instanceId2);
+}
+
+std::string AttachInstancesRequest::getInstanceId5()const
+{
+	return instanceId5_;
+}
+
+void AttachInstancesRequest::setInstanceId5(const std::string& instanceId5)
+{
+	instanceId5_ = instanceId5;
+	setParameter("InstanceId5", instanceId5);
+}
+
+std::string AttachInstancesRequest::getInstanceId4()const
+{
+	return instanceId4_;
+}
+
+void AttachInstancesRequest::setInstanceId4(const std::string& instanceId4)
+{
+	instanceId4_ = instanceId4;
+	setParameter("InstanceId4", instanceId4);
+}
+
+std::string AttachInstancesRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void AttachInstancesRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string AttachInstancesRequest::getInstanceId7()const
+{
+	return instanceId7_;
+}
+
+void AttachInstancesRequest::setInstanceId7(const std::string& instanceId7)
+{
+	instanceId7_ = instanceId7;
+	setParameter("InstanceId7", instanceId7);
+}
+
+std::string AttachInstancesRequest::getInstanceId6()const
+{
+	return instanceId6_;
+}
+
+void AttachInstancesRequest::setInstanceId6(const std::string& instanceId6)
+{
+	instanceId6_ = instanceId6;
+	setParameter("InstanceId6", instanceId6);
+}
+
+std::string AttachInstancesRequest::getInstanceId9()const
+{
+	return instanceId9_;
+}
+
+void AttachInstancesRequest::setInstanceId9(const std::string& instanceId9)
+{
+	instanceId9_ = instanceId9;
+	setParameter("InstanceId9", instanceId9);
+}
+
+std::string AttachInstancesRequest::getInstanceId8()const
+{
+	return instanceId8_;
+}
+
+void AttachInstancesRequest::setInstanceId8(const std::string& instanceId8)
+{
+	instanceId8_ = instanceId8;
+	setParameter("InstanceId8", instanceId8);
+}
+
+long AttachInstancesRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void AttachInstancesRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string AttachInstancesRequest::getInstanceId18()const
+{
+	return instanceId18_;
+}
+
+void AttachInstancesRequest::setInstanceId18(const std::string& instanceId18)
+{
+	instanceId18_ = instanceId18;
+	setParameter("InstanceId18", instanceId18);
+}
+
+int AttachInstancesRequest::getLoadBalancerWeight19()const
+{
+	return loadBalancerWeight19_;
+}
+
+void AttachInstancesRequest::setLoadBalancerWeight19(int loadBalancerWeight19)
+{
+	loadBalancerWeight19_ = loadBalancerWeight19;
+	setParameter("LoadBalancerWeight19", std::to_string(loadBalancerWeight19));
+}
+
+std::string AttachInstancesRequest::getInstanceId17()const
+{
+	return instanceId17_;
+}
+
+void AttachInstancesRequest::setInstanceId17(const std::string& instanceId17)
+{
+	instanceId17_ = instanceId17;
+	setParameter("InstanceId17", instanceId17);
+}
+
+int AttachInstancesRequest::getLoadBalancerWeight17()const
+{
+	return loadBalancerWeight17_;
+}
+
+void AttachInstancesRequest::setLoadBalancerWeight17(int loadBalancerWeight17)
+{
+	loadBalancerWeight17_ = loadBalancerWeight17;
+	setParameter("LoadBalancerWeight17", std::to_string(loadBalancerWeight17));
+}
+
+std::string AttachInstancesRequest::getInstanceId19()const
+{
+	return instanceId19_;
+}
+
+void AttachInstancesRequest::setInstanceId19(const std::string& instanceId19)
+{
+	instanceId19_ = instanceId19;
+	setParameter("InstanceId19", instanceId19);
+}
+
+int AttachInstancesRequest::getLoadBalancerWeight18()const
+{
+	return loadBalancerWeight18_;
+}
+
+void AttachInstancesRequest::setLoadBalancerWeight18(int loadBalancerWeight18)
+{
+	loadBalancerWeight18_ = loadBalancerWeight18;
+	setParameter("LoadBalancerWeight18", std::to_string(loadBalancerWeight18));
+}
+
+std::string AttachInstancesRequest::getInstanceId14()const
+{
+	return instanceId14_;
+}
+
+void AttachInstancesRequest::setInstanceId14(const std::string& instanceId14)
+{
+	instanceId14_ = instanceId14;
+	setParameter("InstanceId14", instanceId14);
+}
+
+std::string AttachInstancesRequest::getInstanceId13()const
+{
+	return instanceId13_;
+}
+
+void AttachInstancesRequest::setInstanceId13(const std::string& instanceId13)
+{
+	instanceId13_ = instanceId13;
+	setParameter("InstanceId13", instanceId13);
+}
+
+std::string AttachInstancesRequest::getInstanceId16()const
+{
+	return instanceId16_;
+}
+
+void AttachInstancesRequest::setInstanceId16(const std::string& instanceId16)
+{
+	instanceId16_ = instanceId16;
+	setParameter("InstanceId16", instanceId16);
+}
+
+std::string AttachInstancesRequest::getInstanceId15()const
+{
+	return instanceId15_;
+}
+
+void AttachInstancesRequest::setInstanceId15(const std::string& instanceId15)
+{
+	instanceId15_ = instanceId15;
+	setParameter("InstanceId15", instanceId15);
+}
+

ess/src/model/AttachInstancesResult.cc

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

ess/src/model/CreateScalingConfigurationRequest.cc

@@ -0,0 +1,502 @@
+/*
+ * 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/CreateScalingConfigurationRequest.h>
+
+using namespace AlibabaCloud::Ess;
+using namespace AlibabaCloud::Ess::Model;
+
+CreateScalingConfigurationRequest::CreateScalingConfigurationRequest() :
+	EssRequest("CreateScalingConfiguration")
+{}
+
+CreateScalingConfigurationRequest::~CreateScalingConfigurationRequest()
+{}
+
+int CreateScalingConfigurationRequest::getDataDisk3Size()const
+{
+	return dataDisk3Size_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk3Size(int dataDisk3Size)
+{
+	dataDisk3Size_ = dataDisk3Size;
+	setParameter("DataDisk3Size", std::to_string(dataDisk3Size));
+}
+
+std::string CreateScalingConfigurationRequest::getImageId()const
+{
+	return imageId_;
+}
+
+void CreateScalingConfigurationRequest::setImageId(const std::string& imageId)
+{
+	imageId_ = imageId;
+	setParameter("ImageId", imageId);
+}
+
+std::string CreateScalingConfigurationRequest::getDataDisk1SnapshotId()const
+{
+	return dataDisk1SnapshotId_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk1SnapshotId(const std::string& dataDisk1SnapshotId)
+{
+	dataDisk1SnapshotId_ = dataDisk1SnapshotId;
+	setParameter("DataDisk1SnapshotId", dataDisk1SnapshotId);
+}
+
+std::string CreateScalingConfigurationRequest::getDataDisk3Category()const
+{
+	return dataDisk3Category_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk3Category(const std::string& dataDisk3Category)
+{
+	dataDisk3Category_ = dataDisk3Category;
+	setParameter("DataDisk3Category", dataDisk3Category);
+}
+
+std::string CreateScalingConfigurationRequest::getDataDisk1Device()const
+{
+	return dataDisk1Device_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk1Device(const std::string& dataDisk1Device)
+{
+	dataDisk1Device_ = dataDisk1Device;
+	setParameter("DataDisk1Device", dataDisk1Device);
+}
+
+std::string CreateScalingConfigurationRequest::getScalingGroupId()const
+{
+	return scalingGroupId_;
+}
+
+void CreateScalingConfigurationRequest::setScalingGroupId(const std::string& scalingGroupId)
+{
+	scalingGroupId_ = scalingGroupId;
+	setParameter("ScalingGroupId", scalingGroupId);
+}
+
+std::string CreateScalingConfigurationRequest::getDataDisk2Device()const
+{
+	return dataDisk2Device_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk2Device(const std::string& dataDisk2Device)
+{
+	dataDisk2Device_ = dataDisk2Device;
+	setParameter("DataDisk2Device", dataDisk2Device);
+}
+
+std::vector<std::string> CreateScalingConfigurationRequest::getInstanceTypes()const
+{
+	return instanceTypes_;
+}
+
+void CreateScalingConfigurationRequest::setInstanceTypes(const std::vector<std::string>& instanceTypes)
+{
+	instanceTypes_ = instanceTypes;
+	for(int i = 0; i!= instanceTypes.size(); i++)
+		setParameter("InstanceTypes."+ std::to_string(i), instanceTypes.at(i));
+}
+
+std::string CreateScalingConfigurationRequest::getIoOptimized()const
+{
+	return ioOptimized_;
+}
+
+void CreateScalingConfigurationRequest::setIoOptimized(const std::string& ioOptimized)
+{
+	ioOptimized_ = ioOptimized;
+	setParameter("IoOptimized", ioOptimized);
+}
+
+std::string CreateScalingConfigurationRequest::getSecurityGroupId()const
+{
+	return securityGroupId_;
+}
+
+void CreateScalingConfigurationRequest::setSecurityGroupId(const std::string& securityGroupId)
+{
+	securityGroupId_ = securityGroupId;
+	setParameter("SecurityGroupId", securityGroupId);
+}
+
+int CreateScalingConfigurationRequest::getInternetMaxBandwidthOut()const
+{
+	return internetMaxBandwidthOut_;
+}
+
+void CreateScalingConfigurationRequest::setInternetMaxBandwidthOut(int internetMaxBandwidthOut)
+{
+	internetMaxBandwidthOut_ = internetMaxBandwidthOut;
+	setParameter("InternetMaxBandwidthOut", std::to_string(internetMaxBandwidthOut));
+}
+
+std::string CreateScalingConfigurationRequest::getSecurityEnhancementStrategy()const
+{
+	return securityEnhancementStrategy_;
+}
+
+void CreateScalingConfigurationRequest::setSecurityEnhancementStrategy(const std::string& securityEnhancementStrategy)
+{
+	securityEnhancementStrategy_ = securityEnhancementStrategy;
+	setParameter("SecurityEnhancementStrategy", securityEnhancementStrategy);
+}
+
+std::string CreateScalingConfigurationRequest::getKeyPairName()const
+{
+	return keyPairName_;
+}
+
+void CreateScalingConfigurationRequest::setKeyPairName(const std::string& keyPairName)
+{
+	keyPairName_ = keyPairName;
+	setParameter("KeyPairName", keyPairName);
+}
+
+std::string CreateScalingConfigurationRequest::getSystemDiskCategory()const
+{
+	return systemDiskCategory_;
+}
+
+void CreateScalingConfigurationRequest::setSystemDiskCategory(const std::string& systemDiskCategory)
+{
+	systemDiskCategory_ = systemDiskCategory;
+	setParameter("SystemDiskCategory", systemDiskCategory);
+}
+
+std::string CreateScalingConfigurationRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CreateScalingConfigurationRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string CreateScalingConfigurationRequest::getUserData()const
+{
+	return userData_;
+}
+
+void CreateScalingConfigurationRequest::setUserData(const std::string& userData)
+{
+	userData_ = userData;
+	setParameter("UserData", userData);
+}
+
+std::string CreateScalingConfigurationRequest::getDataDisk4Category()const
+{
+	return dataDisk4Category_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk4Category(const std::string& dataDisk4Category)
+{
+	dataDisk4Category_ = dataDisk4Category;
+	setParameter("DataDisk4Category", dataDisk4Category);
+}
+
+std::string CreateScalingConfigurationRequest::getDataDisk2SnapshotId()const
+{
+	return dataDisk2SnapshotId_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk2SnapshotId(const std::string& dataDisk2SnapshotId)
+{
+	dataDisk2SnapshotId_ = dataDisk2SnapshotId;
+	setParameter("DataDisk2SnapshotId", dataDisk2SnapshotId);
+}
+
+int CreateScalingConfigurationRequest::getDataDisk4Size()const
+{
+	return dataDisk4Size_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk4Size(int dataDisk4Size)
+{
+	dataDisk4Size_ = dataDisk4Size;
+	setParameter("DataDisk4Size", std::to_string(dataDisk4Size));
+}
+
+std::string CreateScalingConfigurationRequest::getInstanceType()const
+{
+	return instanceType_;
+}
+
+void CreateScalingConfigurationRequest::setInstanceType(const std::string& instanceType)
+{
+	instanceType_ = instanceType;
+	setParameter("InstanceType", instanceType);
+}
+
+std::string CreateScalingConfigurationRequest::getDataDisk2Category()const
+{
+	return dataDisk2Category_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk2Category(const std::string& dataDisk2Category)
+{
+	dataDisk2Category_ = dataDisk2Category;
+	setParameter("DataDisk2Category", dataDisk2Category);
+}
+
+int CreateScalingConfigurationRequest::getDataDisk1Size()const
+{
+	return dataDisk1Size_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk1Size(int dataDisk1Size)
+{
+	dataDisk1Size_ = dataDisk1Size;
+	setParameter("DataDisk1Size", std::to_string(dataDisk1Size));
+}
+
+std::string CreateScalingConfigurationRequest::getDataDisk3SnapshotId()const
+{
+	return dataDisk3SnapshotId_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk3SnapshotId(const std::string& dataDisk3SnapshotId)
+{
+	dataDisk3SnapshotId_ = dataDisk3SnapshotId;
+	setParameter("DataDisk3SnapshotId", dataDisk3SnapshotId);
+}
+
+std::string CreateScalingConfigurationRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateScalingConfigurationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateScalingConfigurationRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateScalingConfigurationRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+int CreateScalingConfigurationRequest::getDataDisk2Size()const
+{
+	return dataDisk2Size_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk2Size(int dataDisk2Size)
+{
+	dataDisk2Size_ = dataDisk2Size;
+	setParameter("DataDisk2Size", std::to_string(dataDisk2Size));
+}
+
+std::string CreateScalingConfigurationRequest::getRamRoleName()const
+{
+	return ramRoleName_;
+}
+
+void CreateScalingConfigurationRequest::setRamRoleName(const std::string& ramRoleName)
+{
+	ramRoleName_ = ramRoleName;
+	setParameter("RamRoleName", ramRoleName);
+}
+
+long CreateScalingConfigurationRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateScalingConfigurationRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateScalingConfigurationRequest::getScalingConfigurationName()const
+{
+	return scalingConfigurationName_;
+}
+
+void CreateScalingConfigurationRequest::setScalingConfigurationName(const std::string& scalingConfigurationName)
+{
+	scalingConfigurationName_ = scalingConfigurationName;
+	setParameter("ScalingConfigurationName", scalingConfigurationName);
+}
+
+std::string CreateScalingConfigurationRequest::getTags()const
+{
+	return tags_;
+}
+
+void CreateScalingConfigurationRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+
+std::string CreateScalingConfigurationRequest::getDataDisk2DeleteWithInstance()const
+{
+	return dataDisk2DeleteWithInstance_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk2DeleteWithInstance(const std::string& dataDisk2DeleteWithInstance)
+{
+	dataDisk2DeleteWithInstance_ = dataDisk2DeleteWithInstance;
+	setParameter("DataDisk2DeleteWithInstance", dataDisk2DeleteWithInstance);
+}
+
+std::string CreateScalingConfigurationRequest::getDataDisk1Category()const
+{
+	return dataDisk1Category_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk1Category(const std::string& dataDisk1Category)
+{
+	dataDisk1Category_ = dataDisk1Category;
+	setParameter("DataDisk1Category", dataDisk1Category);
+}
+
+std::string CreateScalingConfigurationRequest::getDataDisk3DeleteWithInstance()const
+{
+	return dataDisk3DeleteWithInstance_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk3DeleteWithInstance(const std::string& dataDisk3DeleteWithInstance)
+{
+	dataDisk3DeleteWithInstance_ = dataDisk3DeleteWithInstance;
+	setParameter("DataDisk3DeleteWithInstance", dataDisk3DeleteWithInstance);
+}
+
+int CreateScalingConfigurationRequest::getLoadBalancerWeight()const
+{
+	return loadBalancerWeight_;
+}
+
+void CreateScalingConfigurationRequest::setLoadBalancerWeight(int loadBalancerWeight)
+{
+	loadBalancerWeight_ = loadBalancerWeight;
+	setParameter("LoadBalancerWeight", std::to_string(loadBalancerWeight));
+}
+
+std::string CreateScalingConfigurationRequest::getInstanceName()const
+{
+	return instanceName_;
+}
+
+void CreateScalingConfigurationRequest::setInstanceName(const std::string& instanceName)
+{
+	instanceName_ = instanceName;
+	setParameter("InstanceName", instanceName);
+}
+
+int CreateScalingConfigurationRequest::getSystemDiskSize()const
+{
+	return systemDiskSize_;
+}
+
+void CreateScalingConfigurationRequest::setSystemDiskSize(int systemDiskSize)
+{
+	systemDiskSize_ = systemDiskSize;
+	setParameter("SystemDiskSize", std::to_string(systemDiskSize));
+}
+
+std::string CreateScalingConfigurationRequest::getDataDisk4SnapshotId()const
+{
+	return dataDisk4SnapshotId_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk4SnapshotId(const std::string& dataDisk4SnapshotId)
+{
+	dataDisk4SnapshotId_ = dataDisk4SnapshotId;
+	setParameter("DataDisk4SnapshotId", dataDisk4SnapshotId);
+}
+
+std::string CreateScalingConfigurationRequest::getDataDisk4Device()const
+{
+	return dataDisk4Device_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk4Device(const std::string& dataDisk4Device)
+{
+	dataDisk4Device_ = dataDisk4Device;
+	setParameter("DataDisk4Device", dataDisk4Device);
+}
+
+std::string CreateScalingConfigurationRequest::getInternetChargeType()const
+{
+	return internetChargeType_;
+}
+
+void CreateScalingConfigurationRequest::setInternetChargeType(const std::string& internetChargeType)
+{
+	internetChargeType_ = internetChargeType;
+	setParameter("InternetChargeType", internetChargeType);
+}
+
+std::string CreateScalingConfigurationRequest::getDataDisk3Device()const
+{
+	return dataDisk3Device_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk3Device(const std::string& dataDisk3Device)
+{
+	dataDisk3Device_ = dataDisk3Device;
+	setParameter("DataDisk3Device", dataDisk3Device);
+}
+
+std::string CreateScalingConfigurationRequest::getDataDisk4DeleteWithInstance()const
+{
+	return dataDisk4DeleteWithInstance_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk4DeleteWithInstance(const std::string& dataDisk4DeleteWithInstance)
+{
+	dataDisk4DeleteWithInstance_ = dataDisk4DeleteWithInstance;
+	setParameter("DataDisk4DeleteWithInstance", dataDisk4DeleteWithInstance);
+}
+
+int CreateScalingConfigurationRequest::getInternetMaxBandwidthIn()const
+{
+	return internetMaxBandwidthIn_;
+}
+
+void CreateScalingConfigurationRequest::setInternetMaxBandwidthIn(int internetMaxBandwidthIn)
+{
+	internetMaxBandwidthIn_ = internetMaxBandwidthIn;
+	setParameter("InternetMaxBandwidthIn", std::to_string(internetMaxBandwidthIn));
+}
+
+std::string CreateScalingConfigurationRequest::getDataDisk1DeleteWithInstance()const
+{
+	return dataDisk1DeleteWithInstance_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk1DeleteWithInstance(const std::string& dataDisk1DeleteWithInstance)
+{
+	dataDisk1DeleteWithInstance_ = dataDisk1DeleteWithInstance;
+	setParameter("DataDisk1DeleteWithInstance", dataDisk1DeleteWithInstance);
+}
+

ess/src/model/CreateScalingConfigurationResult.cc

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

ess/src/model/CreateScalingGroupRequest.cc

@@ -0,0 +1,194 @@
+/*
+ * 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/CreateScalingGroupRequest.h>
+
+using namespace AlibabaCloud::Ess;
+using namespace AlibabaCloud::Ess::Model;
+
+CreateScalingGroupRequest::CreateScalingGroupRequest() :
+	EssRequest("CreateScalingGroup")
+{}
+
+CreateScalingGroupRequest::~CreateScalingGroupRequest()
+{}
+
+std::string CreateScalingGroupRequest::getDBInstanceIds()const
+{
+	return dBInstanceIds_;
+}
+
+void CreateScalingGroupRequest::setDBInstanceIds(const std::string& dBInstanceIds)
+{
+	dBInstanceIds_ = dBInstanceIds;
+	setParameter("DBInstanceIds", dBInstanceIds);
+}
+
+std::string CreateScalingGroupRequest::getLoadBalancerIds()const
+{
+	return loadBalancerIds_;
+}
+
+void CreateScalingGroupRequest::setLoadBalancerIds(const std::string& loadBalancerIds)
+{
+	loadBalancerIds_ = loadBalancerIds;
+	setParameter("LoadBalancerIds", loadBalancerIds);
+}
+
+std::string CreateScalingGroupRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateScalingGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateScalingGroupRequest::getScalingGroupName()const
+{
+	return scalingGroupName_;
+}
+
+void CreateScalingGroupRequest::setScalingGroupName(const std::string& scalingGroupName)
+{
+	scalingGroupName_ = scalingGroupName;
+	setParameter("ScalingGroupName", scalingGroupName);
+}
+
+std::vector<std::string> CreateScalingGroupRequest::getVSwitchIds()const
+{
+	return vSwitchIds_;
+}
+
+void CreateScalingGroupRequest::setVSwitchIds(const std::vector<std::string>& vSwitchIds)
+{
+	vSwitchIds_ = vSwitchIds;
+	for(int i = 0; i!= vSwitchIds.size(); i++)
+		setParameter("VSwitchIds."+ std::to_string(i), vSwitchIds.at(i));
+}
+
+std::string CreateScalingGroupRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateScalingGroupRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+int CreateScalingGroupRequest::getMinSize()const
+{
+	return minSize_;
+}
+
+void CreateScalingGroupRequest::setMinSize(int minSize)
+{
+	minSize_ = minSize;
+	setParameter("MinSize", std::to_string(minSize));
+}
+
+long CreateScalingGroupRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateScalingGroupRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateScalingGroupRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CreateScalingGroupRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string CreateScalingGroupRequest::getVSwitchId()const
+{
+	return vSwitchId_;
+}
+
+void CreateScalingGroupRequest::setVSwitchId(const std::string& vSwitchId)
+{
+	vSwitchId_ = vSwitchId;
+	setParameter("VSwitchId", vSwitchId);
+}
+
+std::string CreateScalingGroupRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateScalingGroupRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+int CreateScalingGroupRequest::getMaxSize()const
+{
+	return maxSize_;
+}
+
+void CreateScalingGroupRequest::setMaxSize(int maxSize)
+{
+	maxSize_ = maxSize;
+	setParameter("MaxSize", std::to_string(maxSize));
+}
+
+int CreateScalingGroupRequest::getDefaultCooldown()const
+{
+	return defaultCooldown_;
+}
+
+void CreateScalingGroupRequest::setDefaultCooldown(int defaultCooldown)
+{
+	defaultCooldown_ = defaultCooldown;
+	setParameter("DefaultCooldown", std::to_string(defaultCooldown));
+}
+
+std::string CreateScalingGroupRequest::getRemovalPolicy1()const
+{
+	return removalPolicy1_;
+}
+
+void CreateScalingGroupRequest::setRemovalPolicy1(const std::string& removalPolicy1)
+{
+	removalPolicy1_ = removalPolicy1;
+	setParameter("RemovalPolicy1", removalPolicy1);
+}
+
+std::string CreateScalingGroupRequest::getRemovalPolicy2()const
+{
+	return removalPolicy2_;
+}
+
+void CreateScalingGroupRequest::setRemovalPolicy2(const std::string& removalPolicy2)
+{
+	removalPolicy2_ = removalPolicy2;
+	setParameter("RemovalPolicy2", removalPolicy2);
+}
+

ess/src/model/CreateScalingGroupResult.cc

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

ess/src/model/CreateScalingRuleRequest.cc

@@ -0,0 +1,127 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ess/model/CreateScalingRuleRequest.h>
+
+using namespace AlibabaCloud::Ess;
+using namespace AlibabaCloud::Ess::Model;
+
+CreateScalingRuleRequest::CreateScalingRuleRequest() :
+	EssRequest("CreateScalingRule")
+{}
+
+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_;
+}
+
+void CreateScalingRuleRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+int CreateScalingRuleRequest::getAdjustmentValue()const
+{
+	return adjustmentValue_;
+}
+
+void CreateScalingRuleRequest::setAdjustmentValue(int adjustmentValue)
+{
+	adjustmentValue_ = adjustmentValue;
+	setParameter("AdjustmentValue", std::to_string(adjustmentValue));
+}
+
+std::string CreateScalingRuleRequest::getScalingGroupId()const
+{
+	return scalingGroupId_;
+}
+
+void CreateScalingRuleRequest::setScalingGroupId(const std::string& scalingGroupId)
+{
+	scalingGroupId_ = scalingGroupId;
+	setParameter("ScalingGroupId", scalingGroupId);
+}
+
+std::string CreateScalingRuleRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateScalingRuleRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+int CreateScalingRuleRequest::getCooldown()const
+{
+	return cooldown_;
+}
+
+void CreateScalingRuleRequest::setCooldown(int cooldown)
+{
+	cooldown_ = cooldown;
+	setParameter("Cooldown", std::to_string(cooldown));
+}
+
+std::string CreateScalingRuleRequest::getAdjustmentType()const
+{
+	return adjustmentType_;
+}
+
+void CreateScalingRuleRequest::setAdjustmentType(const std::string& adjustmentType)
+{
+	adjustmentType_ = adjustmentType;
+	setParameter("AdjustmentType", adjustmentType);
+}
+
+long CreateScalingRuleRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateScalingRuleRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateScalingRuleRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CreateScalingRuleRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

ess/src/model/CreateScalingRuleResult.cc

@@ -0,0 +1,69 @@
+/*
+ * 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/CreateScalingRuleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ess;
+using namespace AlibabaCloud::Ess::Model;
+
+CreateScalingRuleResult::CreateScalingRuleResult() :
+	ServiceResult()
+{}
+
+CreateScalingRuleResult::CreateScalingRuleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateScalingRuleResult::~CreateScalingRuleResult()
+{}
+
+void CreateScalingRuleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	if(!value["ScalingRuleId"].isNull())
+		scalingRuleId_ = value["ScalingRuleId"].asString();
+	if(!value["ScalingRuleAri"].isNull())
+		scalingRuleAri_ = value["ScalingRuleAri"].asString();
+
+}
+
+std::string CreateScalingRuleResult::getScalingRuleAri()const
+{
+	return scalingRuleAri_;
+}
+
+void CreateScalingRuleResult::setScalingRuleAri(const std::string& scalingRuleAri)
+{
+	scalingRuleAri_ = scalingRuleAri;
+}
+
+std::string CreateScalingRuleResult::getScalingRuleId()const
+{
+	return scalingRuleId_;
+}
+
+void CreateScalingRuleResult::setScalingRuleId(const std::string& scalingRuleId)
+{
+	scalingRuleId_ = scalingRuleId;
+}
+

ess/src/model/CreateScheduledTaskRequest.cc

@@ -0,0 +1,182 @@
+/*
+ * 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/CreateScheduledTaskRequest.h>
+
+using namespace AlibabaCloud::Ess;
+using namespace AlibabaCloud::Ess::Model;
+
+CreateScheduledTaskRequest::CreateScheduledTaskRequest() :
+	EssRequest("CreateScheduledTask")
+{}
+
+CreateScheduledTaskRequest::~CreateScheduledTaskRequest()
+{}
+
+std::string CreateScheduledTaskRequest::getLaunchTime()const
+{
+	return launchTime_;
+}
+
+void CreateScheduledTaskRequest::setLaunchTime(const std::string& launchTime)
+{
+	launchTime_ = launchTime;
+	setParameter("LaunchTime", launchTime);
+}
+
+std::string CreateScheduledTaskRequest::getScheduledAction()const
+{
+	return scheduledAction_;
+}
+
+void CreateScheduledTaskRequest::setScheduledAction(const std::string& scheduledAction)
+{
+	scheduledAction_ = scheduledAction;
+	setParameter("ScheduledAction", scheduledAction);
+}
+
+std::string CreateScheduledTaskRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateScheduledTaskRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateScheduledTaskRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateScheduledTaskRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string CreateScheduledTaskRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateScheduledTaskRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+long CreateScheduledTaskRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateScheduledTaskRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateScheduledTaskRequest::getRecurrenceValue()const
+{
+	return recurrenceValue_;
+}
+
+void CreateScheduledTaskRequest::setRecurrenceValue(const std::string& recurrenceValue)
+{
+	recurrenceValue_ = recurrenceValue;
+	setParameter("RecurrenceValue", recurrenceValue);
+}
+
+int CreateScheduledTaskRequest::getLaunchExpirationTime()const
+{
+	return launchExpirationTime_;
+}
+
+void CreateScheduledTaskRequest::setLaunchExpirationTime(int launchExpirationTime)
+{
+	launchExpirationTime_ = launchExpirationTime;
+	setParameter("LaunchExpirationTime", std::to_string(launchExpirationTime));
+}
+
+std::string CreateScheduledTaskRequest::getRecurrenceEndTime()const
+{
+	return recurrenceEndTime_;
+}
+
+void CreateScheduledTaskRequest::setRecurrenceEndTime(const std::string& recurrenceEndTime)
+{
+	recurrenceEndTime_ = recurrenceEndTime;
+	setParameter("RecurrenceEndTime", recurrenceEndTime);
+}
+
+std::string CreateScheduledTaskRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CreateScheduledTaskRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string CreateScheduledTaskRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateScheduledTaskRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreateScheduledTaskRequest::getScheduledTaskName()const
+{
+	return scheduledTaskName_;
+}
+
+void CreateScheduledTaskRequest::setScheduledTaskName(const std::string& scheduledTaskName)
+{
+	scheduledTaskName_ = scheduledTaskName;
+	setParameter("ScheduledTaskName", scheduledTaskName);
+}
+
+bool CreateScheduledTaskRequest::getTaskEnabled()const
+{
+	return taskEnabled_;
+}
+
+void CreateScheduledTaskRequest::setTaskEnabled(bool taskEnabled)
+{
+	taskEnabled_ = taskEnabled;
+	setParameter("TaskEnabled", std::to_string(taskEnabled));
+}
+
+std::string CreateScheduledTaskRequest::getRecurrenceType()const
+{
+	return recurrenceType_;
+}
+
+void CreateScheduledTaskRequest::setRecurrenceType(const std::string& recurrenceType)
+{
+	recurrenceType_ = recurrenceType;
+	setParameter("RecurrenceType", recurrenceType);
+}
+

ess/src/model/CreateScheduledTaskResult.cc

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

ess/src/model/DeactivateScalingConfigurationRequest.cc

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

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

ess/src/model/DeleteScalingConfigurationRequest.cc

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

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

ess/src/model/DeleteScalingGroupRequest.cc

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

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

ess/src/model/DeleteScalingRuleRequest.cc

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

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

ess/src/model/DeleteScheduledTaskRequest.cc

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

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

ess/src/model/DescribeAccountAttributesRequest.cc

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

ess/src/model/DescribeAccountAttributesResult.cc

@@ -0,0 +1,153 @@
+/*
+ * 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_;
+}
+
+void DescribeAccountAttributesResult::setMaxNumberOfScalingRules(int maxNumberOfScalingRules)
+{
+	maxNumberOfScalingRules_ = maxNumberOfScalingRules;
+}
+
+int DescribeAccountAttributesResult::getMaxNumberOfScalingInstances()const
+{
+	return maxNumberOfScalingInstances_;
+}
+
+void DescribeAccountAttributesResult::setMaxNumberOfScalingInstances(int maxNumberOfScalingInstances)
+{
+	maxNumberOfScalingInstances_ = maxNumberOfScalingInstances;
+}
+
+int DescribeAccountAttributesResult::getMaxNumberOfScheduledTasks()const
+{
+	return maxNumberOfScheduledTasks_;
+}
+
+void DescribeAccountAttributesResult::setMaxNumberOfScheduledTasks(int maxNumberOfScheduledTasks)
+{
+	maxNumberOfScheduledTasks_ = maxNumberOfScheduledTasks;
+}
+
+int DescribeAccountAttributesResult::getMaxNumberOfLoadBalancers()const
+{
+	return maxNumberOfLoadBalancers_;
+}
+
+void DescribeAccountAttributesResult::setMaxNumberOfLoadBalancers(int maxNumberOfLoadBalancers)
+{
+	maxNumberOfLoadBalancers_ = maxNumberOfLoadBalancers;
+}
+
+int DescribeAccountAttributesResult::getMaxNumberOfMinSize()const
+{
+	return maxNumberOfMinSize_;
+}
+
+void DescribeAccountAttributesResult::setMaxNumberOfMinSize(int maxNumberOfMinSize)
+{
+	maxNumberOfMinSize_ = maxNumberOfMinSize;
+}
+
+int DescribeAccountAttributesResult::getMaxNumberOfScalingGroups()const
+{
+	return maxNumberOfScalingGroups_;
+}
+
+void DescribeAccountAttributesResult::setMaxNumberOfScalingGroups(int maxNumberOfScalingGroups)
+{
+	maxNumberOfScalingGroups_ = maxNumberOfScalingGroups;
+}
+
+int DescribeAccountAttributesResult::getMaxNumberOfScalingConfigurations()const
+{
+	return maxNumberOfScalingConfigurations_;
+}
+
+void DescribeAccountAttributesResult::setMaxNumberOfScalingConfigurations(int maxNumberOfScalingConfigurations)
+{
+	maxNumberOfScalingConfigurations_ = maxNumberOfScalingConfigurations;
+}
+
+int DescribeAccountAttributesResult::getMaxNumberOfDBInstances()const
+{
+	return maxNumberOfDBInstances_;
+}
+
+void DescribeAccountAttributesResult::setMaxNumberOfDBInstances(int maxNumberOfDBInstances)
+{
+	maxNumberOfDBInstances_ = maxNumberOfDBInstances;
+}
+
+int DescribeAccountAttributesResult::getMaxNumberOfMaxSize()const
+{
+	return maxNumberOfMaxSize_;
+}
+
+void DescribeAccountAttributesResult::setMaxNumberOfMaxSize(int maxNumberOfMaxSize)
+{
+	maxNumberOfMaxSize_ = maxNumberOfMaxSize;
+}
+

ess/src/model/DescribeAlertConfigRequest.cc

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

ess/src/model/DescribeAlertConfigResult.cc

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

ess/src/model/DescribeCapacityHistoryRequest.cc

@@ -0,0 +1,116 @@
+/*
+ * 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/DescribeCapacityHistoryRequest.h>
+
+using namespace AlibabaCloud::Ess;
+using namespace AlibabaCloud::Ess::Model;
+
+DescribeCapacityHistoryRequest::DescribeCapacityHistoryRequest() :
+	EssRequest("DescribeCapacityHistory")
+{}
+
+DescribeCapacityHistoryRequest::~DescribeCapacityHistoryRequest()
+{}
+
+std::string DescribeCapacityHistoryRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeCapacityHistoryRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeCapacityHistoryRequest::getScalingGroupId()const
+{
+	return scalingGroupId_;
+}
+
+void DescribeCapacityHistoryRequest::setScalingGroupId(const std::string& scalingGroupId)
+{
+	scalingGroupId_ = scalingGroupId;
+	setParameter("ScalingGroupId", scalingGroupId);
+}
+
+int DescribeCapacityHistoryRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeCapacityHistoryRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string DescribeCapacityHistoryRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeCapacityHistoryRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeCapacityHistoryRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeCapacityHistoryRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+long DescribeCapacityHistoryRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeCapacityHistoryRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+int DescribeCapacityHistoryRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeCapacityHistoryRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DescribeCapacityHistoryRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeCapacityHistoryRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

ess/src/model/DescribeCapacityHistoryResult.cc

@@ -0,0 +1,97 @@
+/*
+ * 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/DescribeCapacityHistoryResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ess;
+using namespace AlibabaCloud::Ess::Model;
+
+DescribeCapacityHistoryResult::DescribeCapacityHistoryResult() :
+	ServiceResult()
+{}
+
+DescribeCapacityHistoryResult::DescribeCapacityHistoryResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeCapacityHistoryResult::~DescribeCapacityHistoryResult()
+{}
+
+void DescribeCapacityHistoryResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allCapacityHistoryItems = value["CapacityHistoryItems"]["CapacityHistoryModel"];
+	for (auto value : allCapacityHistoryItems)
+	{
+		CapacityHistoryModel capacityHistoryModelObject;
+		if(!value["ScalingGroupId"].isNull())
+			capacityHistoryModelObject.scalingGroupId = value["ScalingGroupId"].asString();
+		if(!value["TotalCapacity"].isNull())
+			capacityHistoryModelObject.totalCapacity = std::stoi(value["TotalCapacity"].asString());
+		if(!value["AttachedCapacity"].isNull())
+			capacityHistoryModelObject.attachedCapacity = std::stoi(value["AttachedCapacity"].asString());
+		if(!value["AutoCreatedCapacity"].isNull())
+			capacityHistoryModelObject.autoCreatedCapacity = std::stoi(value["AutoCreatedCapacity"].asString());
+		if(!value["Timestamp"].isNull())
+			capacityHistoryModelObject.timestamp = value["Timestamp"].asString();
+		capacityHistoryItems_.push_back(capacityHistoryModelObject);
+	}
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+
+}
+
+int DescribeCapacityHistoryResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+void DescribeCapacityHistoryResult::setTotalCount(int totalCount)
+{
+	totalCount_ = totalCount;
+}
+
+int DescribeCapacityHistoryResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeCapacityHistoryResult::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+}
+
+int DescribeCapacityHistoryResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeCapacityHistoryResult::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+}
+

ess/src/model/DescribeLimitationRequest.cc

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