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

Signed-off-by: yixiong.jxy <yixiong.jxy@alibaba-inc.com>

CHANGELOG

@@ -1,3 +1,7 @@
+2018-08-16 Version: 1.22.5
+1, ModifyScalingConfiguration add imageName.
+2, CreateScalingConfiguration add imageName.
+
 2018-08-15 Version: 1.22.4
 1, Fix bug in GetMaterials API.
 2, GetVerifyToken added a new param VerifyConfigs

VERSION

@@ -1 +1 @@
-1.22.4
+1.22.5

ess/CMakeLists.txt

@@ -57,12 +57,20 @@ set(ess_public_header_model
 	include/alibabacloud/ess/model/DeleteNotificationConfigurationResult.h
 	include/alibabacloud/ess/model/DescribeLifecycleHooksRequest.h
 	include/alibabacloud/ess/model/DescribeLifecycleHooksResult.h
+	include/alibabacloud/ess/model/ModifyAlarmRequest.h
+	include/alibabacloud/ess/model/ModifyAlarmResult.h
 	include/alibabacloud/ess/model/DescribeAccountAttributesRequest.h
 	include/alibabacloud/ess/model/DescribeAccountAttributesResult.h
+	include/alibabacloud/ess/model/DeleteAlarmRequest.h
+	include/alibabacloud/ess/model/DeleteAlarmResult.h
 	include/alibabacloud/ess/model/DescribeScalingActivityDetailRequest.h
 	include/alibabacloud/ess/model/DescribeScalingActivityDetailResult.h
+	include/alibabacloud/ess/model/DisableAlarmRequest.h
+	include/alibabacloud/ess/model/DisableAlarmResult.h
 	include/alibabacloud/ess/model/VerifyUserRequest.h
 	include/alibabacloud/ess/model/VerifyUserResult.h
+	include/alibabacloud/ess/model/DescribeAlarmsRequest.h
+	include/alibabacloud/ess/model/DescribeAlarmsResult.h
 	include/alibabacloud/ess/model/AttachInstancesRequest.h
 	include/alibabacloud/ess/model/AttachInstancesResult.h
 	include/alibabacloud/ess/model/DescribeScalingGroupsRequest.h
@@ -79,6 +87,8 @@ set(ess_public_header_model
 	include/alibabacloud/ess/model/ModifyLifecycleHookResult.h
 	include/alibabacloud/ess/model/DescribeScalingRulesRequest.h
 	include/alibabacloud/ess/model/DescribeScalingRulesResult.h
+	include/alibabacloud/ess/model/CreateAlarmRequest.h
+	include/alibabacloud/ess/model/CreateAlarmResult.h
 	include/alibabacloud/ess/model/EnableScalingGroupRequest.h
 	include/alibabacloud/ess/model/EnableScalingGroupResult.h
 	include/alibabacloud/ess/model/DeactivateScalingConfigurationRequest.h
@@ -125,6 +135,8 @@ set(ess_public_header_model
 	include/alibabacloud/ess/model/AttachDBInstancesResult.h
 	include/alibabacloud/ess/model/CreateLifecycleHookRequest.h
 	include/alibabacloud/ess/model/CreateLifecycleHookResult.h
+	include/alibabacloud/ess/model/EnableAlarmRequest.h
+	include/alibabacloud/ess/model/EnableAlarmResult.h
 	include/alibabacloud/ess/model/ModifyAlertConfigRequest.h
 	include/alibabacloud/ess/model/ModifyAlertConfigResult.h )
 
@@ -166,12 +178,20 @@ set(ess_src
 	src/model/DeleteNotificationConfigurationResult.cc
 	src/model/DescribeLifecycleHooksRequest.cc
 	src/model/DescribeLifecycleHooksResult.cc
+	src/model/ModifyAlarmRequest.cc
+	src/model/ModifyAlarmResult.cc
 	src/model/DescribeAccountAttributesRequest.cc
 	src/model/DescribeAccountAttributesResult.cc
+	src/model/DeleteAlarmRequest.cc
+	src/model/DeleteAlarmResult.cc
 	src/model/DescribeScalingActivityDetailRequest.cc
 	src/model/DescribeScalingActivityDetailResult.cc
+	src/model/DisableAlarmRequest.cc
+	src/model/DisableAlarmResult.cc
 	src/model/VerifyUserRequest.cc
 	src/model/VerifyUserResult.cc
+	src/model/DescribeAlarmsRequest.cc
+	src/model/DescribeAlarmsResult.cc
 	src/model/AttachInstancesRequest.cc
 	src/model/AttachInstancesResult.cc
 	src/model/DescribeScalingGroupsRequest.cc
@@ -188,6 +208,8 @@ set(ess_src
 	src/model/ModifyLifecycleHookResult.cc
 	src/model/DescribeScalingRulesRequest.cc
 	src/model/DescribeScalingRulesResult.cc
+	src/model/CreateAlarmRequest.cc
+	src/model/CreateAlarmResult.cc
 	src/model/EnableScalingGroupRequest.cc
 	src/model/EnableScalingGroupResult.cc
 	src/model/DeactivateScalingConfigurationRequest.cc
@@ -234,6 +256,8 @@ set(ess_src
 	src/model/AttachDBInstancesResult.cc
 	src/model/CreateLifecycleHookRequest.cc
 	src/model/CreateLifecycleHookResult.cc
+	src/model/EnableAlarmRequest.cc
+	src/model/EnableAlarmResult.cc
 	src/model/ModifyAlertConfigRequest.cc
 	src/model/ModifyAlertConfigResult.cc )
 

ess/include/alibabacloud/ess/EssClient.h

@@ -58,12 +58,20 @@
 #include "model/DeleteNotificationConfigurationResult.h"
 #include "model/DescribeLifecycleHooksRequest.h"
 #include "model/DescribeLifecycleHooksResult.h"
+#include "model/ModifyAlarmRequest.h"
+#include "model/ModifyAlarmResult.h"
 #include "model/DescribeAccountAttributesRequest.h"
 #include "model/DescribeAccountAttributesResult.h"
+#include "model/DeleteAlarmRequest.h"
+#include "model/DeleteAlarmResult.h"
 #include "model/DescribeScalingActivityDetailRequest.h"
 #include "model/DescribeScalingActivityDetailResult.h"
+#include "model/DisableAlarmRequest.h"
+#include "model/DisableAlarmResult.h"
 #include "model/VerifyUserRequest.h"
 #include "model/VerifyUserResult.h"
+#include "model/DescribeAlarmsRequest.h"
+#include "model/DescribeAlarmsResult.h"
 #include "model/AttachInstancesRequest.h"
 #include "model/AttachInstancesResult.h"
 #include "model/DescribeScalingGroupsRequest.h"
@@ -80,6 +88,8 @@
 #include "model/ModifyLifecycleHookResult.h"
 #include "model/DescribeScalingRulesRequest.h"
 #include "model/DescribeScalingRulesResult.h"
+#include "model/CreateAlarmRequest.h"
+#include "model/CreateAlarmResult.h"
 #include "model/EnableScalingGroupRequest.h"
 #include "model/EnableScalingGroupResult.h"
 #include "model/DeactivateScalingConfigurationRequest.h"
@@ -126,6 +136,8 @@
 #include "model/AttachDBInstancesResult.h"
 #include "model/CreateLifecycleHookRequest.h"
 #include "model/CreateLifecycleHookResult.h"
+#include "model/EnableAlarmRequest.h"
+#include "model/EnableAlarmResult.h"
 #include "model/ModifyAlertConfigRequest.h"
 #include "model/ModifyAlertConfigResult.h"
 
@@ -191,15 +203,27 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLifecycleHooksResult> DescribeLifecycleHooksOutcome;
 			typedef std::future<DescribeLifecycleHooksOutcome> DescribeLifecycleHooksOutcomeCallable;
 			typedef std::function<void(const EssClient*, const Model::DescribeLifecycleHooksRequest&, const DescribeLifecycleHooksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLifecycleHooksAsyncHandler;
+			typedef Outcome<Error, Model::ModifyAlarmResult> ModifyAlarmOutcome;
+			typedef std::future<ModifyAlarmOutcome> ModifyAlarmOutcomeCallable;
+			typedef std::function<void(const EssClient*, const Model::ModifyAlarmRequest&, const ModifyAlarmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAlarmAsyncHandler;
 			typedef Outcome<Error, Model::DescribeAccountAttributesResult> DescribeAccountAttributesOutcome;
 			typedef std::future<DescribeAccountAttributesOutcome> DescribeAccountAttributesOutcomeCallable;
 			typedef std::function<void(const EssClient*, const Model::DescribeAccountAttributesRequest&, const DescribeAccountAttributesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccountAttributesAsyncHandler;
+			typedef Outcome<Error, Model::DeleteAlarmResult> DeleteAlarmOutcome;
+			typedef std::future<DeleteAlarmOutcome> DeleteAlarmOutcomeCallable;
+			typedef std::function<void(const EssClient*, const Model::DeleteAlarmRequest&, const DeleteAlarmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAlarmAsyncHandler;
 			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::DisableAlarmResult> DisableAlarmOutcome;
+			typedef std::future<DisableAlarmOutcome> DisableAlarmOutcomeCallable;
+			typedef std::function<void(const EssClient*, const Model::DisableAlarmRequest&, const DisableAlarmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableAlarmAsyncHandler;
 			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::DescribeAlarmsResult> DescribeAlarmsOutcome;
+			typedef std::future<DescribeAlarmsOutcome> DescribeAlarmsOutcomeCallable;
+			typedef std::function<void(const EssClient*, const Model::DescribeAlarmsRequest&, const DescribeAlarmsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAlarmsAsyncHandler;
 			typedef Outcome<Error, Model::AttachInstancesResult> AttachInstancesOutcome;
 			typedef std::future<AttachInstancesOutcome> AttachInstancesOutcomeCallable;
 			typedef std::function<void(const EssClient*, const Model::AttachInstancesRequest&, const AttachInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachInstancesAsyncHandler;
@@ -224,6 +248,9 @@ namespace AlibabaCloud
 			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::CreateAlarmResult> CreateAlarmOutcome;
+			typedef std::future<CreateAlarmOutcome> CreateAlarmOutcomeCallable;
+			typedef std::function<void(const EssClient*, const Model::CreateAlarmRequest&, const CreateAlarmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAlarmAsyncHandler;
 			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;
@@ -293,6 +320,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateLifecycleHookResult> CreateLifecycleHookOutcome;
 			typedef std::future<CreateLifecycleHookOutcome> CreateLifecycleHookOutcomeCallable;
 			typedef std::function<void(const EssClient*, const Model::CreateLifecycleHookRequest&, const CreateLifecycleHookOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLifecycleHookAsyncHandler;
+			typedef Outcome<Error, Model::EnableAlarmResult> EnableAlarmOutcome;
+			typedef std::future<EnableAlarmOutcome> EnableAlarmOutcomeCallable;
+			typedef std::function<void(const EssClient*, const Model::EnableAlarmRequest&, const EnableAlarmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableAlarmAsyncHandler;
 			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;
@@ -355,15 +385,27 @@ namespace AlibabaCloud
 			DescribeLifecycleHooksOutcome describeLifecycleHooks(const Model::DescribeLifecycleHooksRequest &request)const;
 			void describeLifecycleHooksAsync(const Model::DescribeLifecycleHooksRequest& request, const DescribeLifecycleHooksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLifecycleHooksOutcomeCallable describeLifecycleHooksCallable(const Model::DescribeLifecycleHooksRequest& request) const;
+			ModifyAlarmOutcome modifyAlarm(const Model::ModifyAlarmRequest &request)const;
+			void modifyAlarmAsync(const Model::ModifyAlarmRequest& request, const ModifyAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyAlarmOutcomeCallable modifyAlarmCallable(const Model::ModifyAlarmRequest& request) const;
 			DescribeAccountAttributesOutcome describeAccountAttributes(const Model::DescribeAccountAttributesRequest &request)const;
 			void describeAccountAttributesAsync(const Model::DescribeAccountAttributesRequest& request, const DescribeAccountAttributesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeAccountAttributesOutcomeCallable describeAccountAttributesCallable(const Model::DescribeAccountAttributesRequest& request) const;
+			DeleteAlarmOutcome deleteAlarm(const Model::DeleteAlarmRequest &request)const;
+			void deleteAlarmAsync(const Model::DeleteAlarmRequest& request, const DeleteAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteAlarmOutcomeCallable deleteAlarmCallable(const Model::DeleteAlarmRequest& request) const;
 			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;
+			DisableAlarmOutcome disableAlarm(const Model::DisableAlarmRequest &request)const;
+			void disableAlarmAsync(const Model::DisableAlarmRequest& request, const DisableAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DisableAlarmOutcomeCallable disableAlarmCallable(const Model::DisableAlarmRequest& 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;
+			DescribeAlarmsOutcome describeAlarms(const Model::DescribeAlarmsRequest &request)const;
+			void describeAlarmsAsync(const Model::DescribeAlarmsRequest& request, const DescribeAlarmsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeAlarmsOutcomeCallable describeAlarmsCallable(const Model::DescribeAlarmsRequest& request) const;
 			AttachInstancesOutcome attachInstances(const Model::AttachInstancesRequest &request)const;
 			void attachInstancesAsync(const Model::AttachInstancesRequest& request, const AttachInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AttachInstancesOutcomeCallable attachInstancesCallable(const Model::AttachInstancesRequest& request) const;
@@ -388,6 +430,9 @@ namespace AlibabaCloud
 			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;
+			CreateAlarmOutcome createAlarm(const Model::CreateAlarmRequest &request)const;
+			void createAlarmAsync(const Model::CreateAlarmRequest& request, const CreateAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateAlarmOutcomeCallable createAlarmCallable(const Model::CreateAlarmRequest& 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;
@@ -457,6 +502,9 @@ namespace AlibabaCloud
 			CreateLifecycleHookOutcome createLifecycleHook(const Model::CreateLifecycleHookRequest &request)const;
 			void createLifecycleHookAsync(const Model::CreateLifecycleHookRequest& request, const CreateLifecycleHookAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateLifecycleHookOutcomeCallable createLifecycleHookCallable(const Model::CreateLifecycleHookRequest& request) const;
+			EnableAlarmOutcome enableAlarm(const Model::EnableAlarmRequest &request)const;
+			void enableAlarmAsync(const Model::EnableAlarmRequest& request, const EnableAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EnableAlarmOutcomeCallable enableAlarmCallable(const Model::EnableAlarmRequest& 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;

ess/include/alibabacloud/ess/model/CreateAlarmRequest.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_CREATEALARMREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_CREATEALARMREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ess/EssExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT CreateAlarmRequest : public RpcServiceRequest
+			{
+				struct Dimension
+				{
+					std::string dimensionValue;
+					std::string dimensionKey;
+				};
+
+			public:
+				CreateAlarmRequest();
+				~CreateAlarmRequest();
+
+				std::string getMetricType()const;
+				void setMetricType(const std::string& metricType);
+				int getPeriod()const;
+				void setPeriod(int period);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				std::string getGroupId()const;
+				void setGroupId(const std::string& groupId);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::vector<std::string> getAlarmAction()const;
+				void setAlarmAction(const std::vector<std::string>& alarmAction);
+				float getThreshold()const;
+				void setThreshold(float threshold);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getComparisionOperator()const;
+				void setComparisionOperator(const std::string& comparisionOperator);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getName()const;
+				void setName(const std::string& name);
+				int getEvaluationCount()const;
+				void setEvaluationCount(int evaluationCount);
+				std::string getMetricName()const;
+				void setMetricName(const std::string& metricName);
+				std::vector<Dimension> getDimension()const;
+				void setDimension(const std::vector<Dimension>& dimension);
+				std::string getStatistics()const;
+				void setStatistics(const std::string& statistics);
+
+            private:
+				std::string metricType_;
+				int period_;
+				std::string resourceOwnerAccount_;
+				std::string scalingGroupId_;
+				std::string groupId_;
+				std::string description_;
+				std::vector<std::string> alarmAction_;
+				float threshold_;
+				long ownerId_;
+				std::string accessKeyId_;
+				std::string comparisionOperator_;
+				std::string regionId_;
+				std::string name_;
+				int evaluationCount_;
+				std::string metricName_;
+				std::vector<Dimension> dimension_;
+				std::string statistics_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_CREATEALARMREQUEST_H_

ess/include/alibabacloud/ess/model/CreateAlarmResult.h

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

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

@@ -32,12 +32,12 @@ namespace AlibabaCloud
 			{
 				struct LifecycleHook
 				{
-					std::string lifecycleHookName;
-					std::string lifecycleTransition;
 					std::string defaultResult;
+					std::string lifecycleHookName;
 					int heartbeatTimeout;
-					std::string notificationMetadata;
 					std::string notificationArn;
+					std::string notificationMetadata;
+					std::string lifecycleTransition;
 				};
 
 			public:

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

@@ -35,25 +35,23 @@ namespace AlibabaCloud
 					std::string instanceType;
 					float priceLimit;
 				};
+				struct DataDisk
+				{
+					std::string snapshotId;
+					int size;
+					std::string category;
+					std::string device;
+					bool deleteWithInstance;
+				};
 
 			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;
@@ -74,75 +72,44 @@ namespace AlibabaCloud
 				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 getHostName()const;
 				void setHostName(const std::string& hostName);
-				std::string getDataDisk2SnapshotId()const;
-				void setDataDisk2SnapshotId(const std::string& dataDisk2SnapshotId);
 				bool getPasswordInherit()const;
 				void setPasswordInherit(bool passwordInherit);
-				int getDataDisk4Size()const;
-				void setDataDisk4Size(int dataDisk4Size);
+				std::string getImageName()const;
+				void setImageName(const std::string& imageName);
 				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::vector<DataDisk> getDataDisk()const;
+				void setDataDisk(const std::vector<DataDisk>& dataDisk);
 				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 getSpotStrategy()const;
 				void setSpotStrategy(const std::string& spotStrategy);
-				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_;
@@ -153,36 +120,23 @@ namespace AlibabaCloud
 				std::string systemDiskCategory_;
 				std::string accessKeyId_;
 				std::string userData_;
-				std::string dataDisk4Category_;
 				std::string hostName_;
-				std::string dataDisk2SnapshotId_;
 				bool passwordInherit_;
-				int dataDisk4Size_;
+				std::string imageName_;
 				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::vector<DataDisk> dataDisk_;
 				std::string scalingConfigurationName_;
 				std::string tags_;
-				std::string dataDisk2DeleteWithInstance_;
 				std::string spotStrategy_;
-				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_;
 
 			};
 		}

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

@@ -32,12 +32,12 @@ namespace AlibabaCloud
 			{
 				struct LifecycleHook
 				{
-					std::string lifecycleHookName;
-					std::string lifecycleTransition;
 					std::string defaultResult;
+					std::string lifecycleHookName;
 					int heartbeatTimeout;
-					std::string notificationMetadata;
 					std::string notificationArn;
+					std::string notificationMetadata;
+					std::string lifecycleTransition;
 				};
 
 			public:

ess/include/alibabacloud/ess/model/DeleteAlarmRequest.h

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

ess/include/alibabacloud/ess/model/DeleteAlarmResult.h

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

ess/include/alibabacloud/ess/model/DescribeAlarmsRequest.h

@@ -0,0 +1,78 @@
+/*
+ * 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_DESCRIBEALARMSREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBEALARMSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ess/EssExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT DescribeAlarmsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeAlarmsRequest();
+				~DescribeAlarmsRequest();
+
+				bool getIsEnable()const;
+				void setIsEnable(bool isEnable);
+				std::string getMetricType()const;
+				void setMetricType(const std::string& metricType);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getScalingGroupId()const;
+				void setScalingGroupId(const std::string& scalingGroupId);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getState()const;
+				void setState(const std::string& state);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAlarmTaskId()const;
+				void setAlarmTaskId(const std::string& alarmTaskId);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				bool isEnable_;
+				std::string metricType_;
+				std::string resourceOwnerAccount_;
+				std::string regionId_;
+				std::string scalingGroupId_;
+				int pageSize_;
+				std::string state_;
+				long ownerId_;
+				std::string alarmTaskId_;
+				int pageNumber_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEALARMSREQUEST_H_

ess/include/alibabacloud/ess/model/DescribeAlarmsResult.h

@@ -0,0 +1,75 @@
+/*
+ * 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_DESCRIBEALARMSRESULT_H_
+#define ALIBABACLOUD_ESS_MODEL_DESCRIBEALARMSRESULT_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 DescribeAlarmsResult : public ServiceResult
+			{
+			public:
+				struct Alarm
+				{
+					std::string comparisonOperator;
+					std::string description;
+					std::string scalingGroupId;
+					std::string metricType;
+					std::string dimensions;
+					int period;
+					int evaluationCount;
+					std::string statistics;
+					std::string name;
+					std::vector<std::string> alarmActions;
+					std::string metricName;
+					std::string state;
+					bool enable;
+					std::string alarmTaskId;
+					float threshold;
+				};
+
+
+				DescribeAlarmsResult();
+				explicit DescribeAlarmsResult(const std::string &payload);
+				~DescribeAlarmsResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<Alarm> getAlarmList()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<Alarm> alarmList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_DESCRIBEALARMSRESULT_H_

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

@@ -40,6 +40,7 @@ namespace AlibabaCloud
 						std::string category;
 						int size;
 						std::string device;
+						bool deleteWithInstance;
 					};
 					struct Tag
 					{
@@ -74,6 +75,7 @@ namespace AlibabaCloud
 					std::string systemDiskCategory;
 					std::string instanceName;
 					std::string deploymentSetId;
+					std::string imageName;
 					int internetMaxBandwidthOut;
 					int internetMaxBandwidthIn;
 					std::string creationTime;

ess/include/alibabacloud/ess/model/DisableAlarmRequest.h

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

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

ess/include/alibabacloud/ess/model/EnableAlarmRequest.h

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

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

ess/include/alibabacloud/ess/model/ModifyAlarmRequest.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_MODIFYALARMREQUEST_H_
+#define ALIBABACLOUD_ESS_MODEL_MODIFYALARMREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ess/EssExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ESS_EXPORT ModifyAlarmRequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifyAlarmRequest();
+				~ModifyAlarmRequest();
+
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::vector<std::string> getAlarmAction()const;
+				void setAlarmAction(const std::vector<std::string>& alarmAction);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAlarmTaskId()const;
+				void setAlarmTaskId(const std::string& alarmTaskId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string resourceOwnerAccount_;
+				std::string regionId_;
+				std::string name_;
+				std::string description_;
+				std::vector<std::string> alarmAction_;
+				long ownerId_;
+				std::string alarmTaskId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ESS_MODEL_MODIFYALARMREQUEST_H_

ess/include/alibabacloud/ess/model/ModifyAlarmResult.h

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

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

@@ -30,6 +30,19 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_ESS_EXPORT ModifyScalingConfigurationRequest : public RpcServiceRequest
 			{
+				struct SpotPriceLimit
+				{
+					std::string instanceType;
+					float priceLimit;
+				};
+				struct DataDisk
+				{
+					std::string snapshotId;
+					int size;
+					std::string category;
+					std::string device;
+					bool deleteWithInstance;
+				};
 
 			public:
 				ModifyScalingConfigurationRequest();
@@ -37,40 +50,50 @@ namespace AlibabaCloud
 
 				std::string getImageId()const;
 				void setImageId(const std::string& imageId);
-				std::string getResourceOwnerAccount()const;
-				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
-				std::string getOwnerAccount()const;
-				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getIoOptimized()const;
+				void setIoOptimized(const std::string& ioOptimized);
 				std::vector<std::string> getInstanceTypes()const;
 				void setInstanceTypes(const std::vector<std::string>& instanceTypes);
 				int getInternetMaxBandwidthOut()const;
 				void setInternetMaxBandwidthOut(int internetMaxBandwidthOut);
-				std::string getRamRoleName()const;
-				void setRamRoleName(const std::string& ramRoleName);
 				std::string getKeyPairName()const;
 				void setKeyPairName(const std::string& keyPairName);
-				long getOwnerId()const;
-				void setOwnerId(long ownerId);
+				std::vector<SpotPriceLimit> getSpotPriceLimit()const;
+				void setSpotPriceLimit(const std::vector<SpotPriceLimit>& spotPriceLimit);
 				std::string getSystemDiskCategory()const;
 				void setSystemDiskCategory(const std::string& systemDiskCategory);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getUserData()const;
+				void setUserData(const std::string& userData);
+				std::string getHostName()const;
+				void setHostName(const std::string& hostName);
+				bool getPasswordInherit()const;
+				void setPasswordInherit(bool passwordInherit);
+				std::string getImageName()const;
+				void setImageName(const std::string& imageName);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getRamRoleName()const;
+				void setRamRoleName(const std::string& ramRoleName);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::vector<DataDisk> getDataDisk()const;
+				void setDataDisk(const std::vector<DataDisk>& dataDisk);
 				std::string getScalingConfigurationName()const;
 				void setScalingConfigurationName(const std::string& scalingConfigurationName);
 				std::string getTags()const;
 				void setTags(const std::string& tags);
 				std::string getScalingConfigurationId()const;
 				void setScalingConfigurationId(const std::string& scalingConfigurationId);
-				std::string getUserData()const;
-				void setUserData(const std::string& userData);
-				std::string getHostName()const;
-				void setHostName(const std::string& hostName);
+				std::string getSpotStrategy()const;
+				void setSpotStrategy(const std::string& spotStrategy);
 				std::string getInstanceName()const;
 				void setInstanceName(const std::string& instanceName);
 				int getLoadBalancerWeight()const;
 				void setLoadBalancerWeight(int loadBalancerWeight);
-				bool getPasswordInherit()const;
-				void setPasswordInherit(bool passwordInherit);
 				int getSystemDiskSize()const;
 				void setSystemDiskSize(int systemDiskSize);
 				std::string getInternetChargeType()const;
@@ -78,23 +101,28 @@ namespace AlibabaCloud
 
             private:
 				std::string imageId_;
-				std::string resourceOwnerAccount_;
-				std::string ownerAccount_;
+				std::string ioOptimized_;
 				std::vector<std::string> instanceTypes_;
 				int internetMaxBandwidthOut_;
-				std::string ramRoleName_;
 				std::string keyPairName_;
-				long ownerId_;
+				std::vector<SpotPriceLimit> spotPriceLimit_;
 				std::string systemDiskCategory_;
 				std::string accessKeyId_;
+				std::string userData_;
+				std::string hostName_;
+				bool passwordInherit_;
+				std::string imageName_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				std::string ramRoleName_;
+				long ownerId_;
+				std::vector<DataDisk> dataDisk_;
 				std::string scalingConfigurationName_;
 				std::string tags_;
 				std::string scalingConfigurationId_;
-				std::string userData_;
-				std::string hostName_;
+				std::string spotStrategy_;
 				std::string instanceName_;
 				int loadBalancerWeight_;
-				bool passwordInherit_;
 				int systemDiskSize_;
 				std::string internetChargeType_;
 

ess/src/EssClient.cc

@@ -699,6 +699,42 @@ EssClient::DescribeLifecycleHooksOutcomeCallable EssClient::describeLifecycleHoo
 	return task->get_future();
 }
 
+EssClient::ModifyAlarmOutcome EssClient::modifyAlarm(const ModifyAlarmRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyAlarmOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyAlarmOutcome(ModifyAlarmResult(outcome.result()));
+	else
+		return ModifyAlarmOutcome(outcome.error());
+}
+
+void EssClient::modifyAlarmAsync(const ModifyAlarmRequest& request, const ModifyAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyAlarm(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::ModifyAlarmOutcomeCallable EssClient::modifyAlarmCallable(const ModifyAlarmRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyAlarmOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyAlarm(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::DescribeAccountAttributesOutcome EssClient::describeAccountAttributes(const DescribeAccountAttributesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -735,6 +771,42 @@ EssClient::DescribeAccountAttributesOutcomeCallable EssClient::describeAccountAt
 	return task->get_future();
 }
 
+EssClient::DeleteAlarmOutcome EssClient::deleteAlarm(const DeleteAlarmRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteAlarmOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteAlarmOutcome(DeleteAlarmResult(outcome.result()));
+	else
+		return DeleteAlarmOutcome(outcome.error());
+}
+
+void EssClient::deleteAlarmAsync(const DeleteAlarmRequest& request, const DeleteAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteAlarm(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DeleteAlarmOutcomeCallable EssClient::deleteAlarmCallable(const DeleteAlarmRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteAlarmOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteAlarm(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::DescribeScalingActivityDetailOutcome EssClient::describeScalingActivityDetail(const DescribeScalingActivityDetailRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -771,6 +843,42 @@ EssClient::DescribeScalingActivityDetailOutcomeCallable EssClient::describeScali
 	return task->get_future();
 }
 
+EssClient::DisableAlarmOutcome EssClient::disableAlarm(const DisableAlarmRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DisableAlarmOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DisableAlarmOutcome(DisableAlarmResult(outcome.result()));
+	else
+		return DisableAlarmOutcome(outcome.error());
+}
+
+void EssClient::disableAlarmAsync(const DisableAlarmRequest& request, const DisableAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, disableAlarm(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DisableAlarmOutcomeCallable EssClient::disableAlarmCallable(const DisableAlarmRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DisableAlarmOutcome()>>(
+			[this, request]()
+			{
+			return this->disableAlarm(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::VerifyUserOutcome EssClient::verifyUser(const VerifyUserRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -807,6 +915,42 @@ EssClient::VerifyUserOutcomeCallable EssClient::verifyUserCallable(const VerifyU
 	return task->get_future();
 }
 
+EssClient::DescribeAlarmsOutcome EssClient::describeAlarms(const DescribeAlarmsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeAlarmsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeAlarmsOutcome(DescribeAlarmsResult(outcome.result()));
+	else
+		return DescribeAlarmsOutcome(outcome.error());
+}
+
+void EssClient::describeAlarmsAsync(const DescribeAlarmsRequest& request, const DescribeAlarmsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeAlarms(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::DescribeAlarmsOutcomeCallable EssClient::describeAlarmsCallable(const DescribeAlarmsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeAlarmsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeAlarms(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::AttachInstancesOutcome EssClient::attachInstances(const AttachInstancesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1095,6 +1239,42 @@ EssClient::DescribeScalingRulesOutcomeCallable EssClient::describeScalingRulesCa
 	return task->get_future();
 }
 
+EssClient::CreateAlarmOutcome EssClient::createAlarm(const CreateAlarmRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateAlarmOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateAlarmOutcome(CreateAlarmResult(outcome.result()));
+	else
+		return CreateAlarmOutcome(outcome.error());
+}
+
+void EssClient::createAlarmAsync(const CreateAlarmRequest& request, const CreateAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createAlarm(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::CreateAlarmOutcomeCallable EssClient::createAlarmCallable(const CreateAlarmRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateAlarmOutcome()>>(
+			[this, request]()
+			{
+			return this->createAlarm(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::EnableScalingGroupOutcome EssClient::enableScalingGroup(const EnableScalingGroupRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1923,6 +2103,42 @@ EssClient::CreateLifecycleHookOutcomeCallable EssClient::createLifecycleHookCall
 	return task->get_future();
 }
 
+EssClient::EnableAlarmOutcome EssClient::enableAlarm(const EnableAlarmRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EnableAlarmOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EnableAlarmOutcome(EnableAlarmResult(outcome.result()));
+	else
+		return EnableAlarmOutcome(outcome.error());
+}
+
+void EssClient::enableAlarmAsync(const EnableAlarmRequest& request, const EnableAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, enableAlarm(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EssClient::EnableAlarmOutcomeCallable EssClient::enableAlarmCallable(const EnableAlarmRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EnableAlarmOutcome()>>(
+			[this, request]()
+			{
+			return this->enableAlarm(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EssClient::ModifyAlertConfigOutcome EssClient::modifyAlertConfig(const ModifyAlertConfigRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

ess/src/model/CreateAlarmRequest.cc

@@ -0,0 +1,221 @@
+/*
+ * 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/CreateAlarmRequest.h>
+
+using AlibabaCloud::Ess::Model::CreateAlarmRequest;
+
+CreateAlarmRequest::CreateAlarmRequest() :
+	RpcServiceRequest("ess", "2014-08-28", "CreateAlarm")
+{}
+
+CreateAlarmRequest::~CreateAlarmRequest()
+{}
+
+std::string CreateAlarmRequest::getMetricType()const
+{
+	return metricType_;
+}
+
+void CreateAlarmRequest::setMetricType(const std::string& metricType)
+{
+	metricType_ = metricType;
+	setParameter("MetricType", metricType);
+}
+
+int CreateAlarmRequest::getPeriod()const
+{
+	return period_;
+}
+
+void CreateAlarmRequest::setPeriod(int period)
+{
+	period_ = period;
+	setParameter("Period", std::to_string(period));
+}
+
+std::string CreateAlarmRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateAlarmRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateAlarmRequest::getScalingGroupId()const
+{
+	return scalingGroupId_;
+}
+
+void CreateAlarmRequest::setScalingGroupId(const std::string& scalingGroupId)
+{
+	scalingGroupId_ = scalingGroupId;
+	setParameter("ScalingGroupId", scalingGroupId);
+}
+
+std::string CreateAlarmRequest::getGroupId()const
+{
+	return groupId_;
+}
+
+void CreateAlarmRequest::setGroupId(const std::string& groupId)
+{
+	groupId_ = groupId;
+	setParameter("GroupId", groupId);
+}
+
+std::string CreateAlarmRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateAlarmRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+std::vector<std::string> CreateAlarmRequest::getAlarmAction()const
+{
+	return alarmAction_;
+}
+
+void CreateAlarmRequest::setAlarmAction(const std::vector<std::string>& alarmAction)
+{
+	alarmAction_ = alarmAction;
+	for(int i = 0; i!= alarmAction.size(); i++)
+		setParameter("AlarmAction."+ std::to_string(i), alarmAction.at(i));
+}
+
+float CreateAlarmRequest::getThreshold()const
+{
+	return threshold_;
+}
+
+void CreateAlarmRequest::setThreshold(float threshold)
+{
+	threshold_ = threshold;
+	setParameter("Threshold", std::to_string(threshold));
+}
+
+long CreateAlarmRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateAlarmRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateAlarmRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CreateAlarmRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string CreateAlarmRequest::getComparisionOperator()const
+{
+	return comparisionOperator_;
+}
+
+void CreateAlarmRequest::setComparisionOperator(const std::string& comparisionOperator)
+{
+	comparisionOperator_ = comparisionOperator;
+	setParameter("ComparisionOperator", comparisionOperator);
+}
+
+std::string CreateAlarmRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateAlarmRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreateAlarmRequest::getName()const
+{
+	return name_;
+}
+
+void CreateAlarmRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+int CreateAlarmRequest::getEvaluationCount()const
+{
+	return evaluationCount_;
+}
+
+void CreateAlarmRequest::setEvaluationCount(int evaluationCount)
+{
+	evaluationCount_ = evaluationCount;
+	setParameter("EvaluationCount", std::to_string(evaluationCount));
+}
+
+std::string CreateAlarmRequest::getMetricName()const
+{
+	return metricName_;
+}
+
+void CreateAlarmRequest::setMetricName(const std::string& metricName)
+{
+	metricName_ = metricName;
+	setParameter("MetricName", metricName);
+}
+
+std::vector<CreateAlarmRequest::Dimension> CreateAlarmRequest::getDimension()const
+{
+	return dimension_;
+}
+
+void CreateAlarmRequest::setDimension(const std::vector<Dimension>& dimension)
+{
+	dimension_ = dimension;
+	int i = 0;
+	for(int i = 0; i!= dimension.size(); i++)	{
+		auto obj = dimension.at(i);
+		std::string str ="Dimension."+ std::to_string(i);
+		setParameter(str + ".DimensionValue", obj.dimensionValue);
+		setParameter(str + ".DimensionKey", obj.dimensionKey);
+	}
+}
+
+std::string CreateAlarmRequest::getStatistics()const
+{
+	return statistics_;
+}
+
+void CreateAlarmRequest::setStatistics(const std::string& statistics)
+{
+	statistics_ = statistics;
+	setParameter("Statistics", statistics);
+}
+

ess/src/model/CreateAlarmResult.cc

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

ess/src/model/CreateLifecycleHookRequest.cc

@@ -158,12 +158,12 @@ void CreateLifecycleHookRequest::setLifecycleHook(const std::vector<LifecycleHoo
 	for(int i = 0; i!= lifecycleHook.size(); i++)	{
 		auto obj = lifecycleHook.at(i);
 		std::string str ="LifecycleHook."+ std::to_string(i);
-		setParameter(str + ".LifecycleHookName", obj.lifecycleHookName);
-		setParameter(str + ".LifecycleTransition", obj.lifecycleTransition);
 		setParameter(str + ".DefaultResult", obj.defaultResult);
+		setParameter(str + ".LifecycleHookName", obj.lifecycleHookName);
 		setParameter(str + ".HeartbeatTimeout", std::to_string(obj.heartbeatTimeout));
-		setParameter(str + ".NotificationMetadata", obj.notificationMetadata);
 		setParameter(str + ".NotificationArn", obj.notificationArn);
+		setParameter(str + ".NotificationMetadata", obj.notificationMetadata);
+		setParameter(str + ".LifecycleTransition", obj.lifecycleTransition);
 	}
 }
 

ess/src/model/CreateScalingConfigurationRequest.cc

@@ -25,17 +25,6 @@ CreateScalingConfigurationRequest::CreateScalingConfigurationRequest() :
 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_;
@@ -47,39 +36,6 @@ void CreateScalingConfigurationRequest::setImageId(const std::string& 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_;
@@ -91,17 +47,6 @@ void CreateScalingConfigurationRequest::setScalingGroupId(const std::string& sca
 	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_;
@@ -219,17 +164,6 @@ void CreateScalingConfigurationRequest::setUserData(const std::string& 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::getHostName()const
 {
 	return hostName_;
@@ -241,17 +175,6 @@ void CreateScalingConfigurationRequest::setHostName(const std::string& hostName)
 	setParameter("HostName", hostName);
 }
 
-std::string CreateScalingConfigurationRequest::getDataDisk2SnapshotId()const
-{
-	return dataDisk2SnapshotId_;
-}
-
-void CreateScalingConfigurationRequest::setDataDisk2SnapshotId(const std::string& dataDisk2SnapshotId)
-{
-	dataDisk2SnapshotId_ = dataDisk2SnapshotId;
-	setParameter("DataDisk2SnapshotId", dataDisk2SnapshotId);
-}
-
 bool CreateScalingConfigurationRequest::getPasswordInherit()const
 {
 	return passwordInherit_;
@@ -263,15 +186,15 @@ void CreateScalingConfigurationRequest::setPasswordInherit(bool passwordInherit)
 	setParameter("PasswordInherit", std::to_string(passwordInherit));
 }
 
-int CreateScalingConfigurationRequest::getDataDisk4Size()const
+std::string CreateScalingConfigurationRequest::getImageName()const
 {
-	return dataDisk4Size_;
+	return imageName_;
 }
 
-void CreateScalingConfigurationRequest::setDataDisk4Size(int dataDisk4Size)
+void CreateScalingConfigurationRequest::setImageName(const std::string& imageName)
 {
-	dataDisk4Size_ = dataDisk4Size;
-	setParameter("DataDisk4Size", std::to_string(dataDisk4Size));
+	imageName_ = imageName;
+	setParameter("ImageName", imageName);
 }
 
 std::string CreateScalingConfigurationRequest::getInstanceType()const
@@ -285,39 +208,6 @@ void CreateScalingConfigurationRequest::setInstanceType(const std::string& insta
 	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_;
@@ -340,17 +230,6 @@ void CreateScalingConfigurationRequest::setOwnerAccount(const std::string& owner
 	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_;
@@ -373,6 +252,26 @@ void CreateScalingConfigurationRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
+std::vector<CreateScalingConfigurationRequest::DataDisk> CreateScalingConfigurationRequest::getDataDisk()const
+{
+	return dataDisk_;
+}
+
+void CreateScalingConfigurationRequest::setDataDisk(const std::vector<DataDisk>& dataDisk)
+{
+	dataDisk_ = dataDisk;
+	int i = 0;
+	for(int i = 0; i!= dataDisk.size(); i++)	{
+		auto obj = dataDisk.at(i);
+		std::string str ="DataDisk."+ std::to_string(i);
+		setParameter(str + ".SnapshotId", obj.snapshotId);
+		setParameter(str + ".Size", std::to_string(obj.size));
+		setParameter(str + ".Category", obj.category);
+		setParameter(str + ".Device", obj.device);
+		setParameter(str + ".DeleteWithInstance", std::to_string(obj.deleteWithInstance));
+	}
+}
+
 std::string CreateScalingConfigurationRequest::getScalingConfigurationName()const
 {
 	return scalingConfigurationName_;
@@ -395,17 +294,6 @@ void CreateScalingConfigurationRequest::setTags(const std::string& 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::getSpotStrategy()const
 {
 	return spotStrategy_;
@@ -417,28 +305,6 @@ void CreateScalingConfigurationRequest::setSpotStrategy(const std::string& spotS
 	setParameter("SpotStrategy", spotStrategy);
 }
 
-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_;
@@ -472,28 +338,6 @@ void CreateScalingConfigurationRequest::setSystemDiskSize(int 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_;
@@ -505,28 +349,6 @@ void CreateScalingConfigurationRequest::setInternetChargeType(const std::string&
 	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_;
@@ -538,14 +360,3 @@ void CreateScalingConfigurationRequest::setInternetMaxBandwidthIn(int internetMa
 	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/CreateScalingGroupRequest.cc

@@ -192,12 +192,12 @@ void CreateScalingGroupRequest::setLifecycleHook(const std::vector<LifecycleHook
 	for(int i = 0; i!= lifecycleHook.size(); i++)	{
 		auto obj = lifecycleHook.at(i);
 		std::string str ="LifecycleHook."+ std::to_string(i);
-		setParameter(str + ".LifecycleHookName", obj.lifecycleHookName);
-		setParameter(str + ".LifecycleTransition", obj.lifecycleTransition);
 		setParameter(str + ".DefaultResult", obj.defaultResult);
+		setParameter(str + ".LifecycleHookName", obj.lifecycleHookName);
 		setParameter(str + ".HeartbeatTimeout", std::to_string(obj.heartbeatTimeout));
-		setParameter(str + ".NotificationMetadata", obj.notificationMetadata);
 		setParameter(str + ".NotificationArn", obj.notificationArn);
+		setParameter(str + ".NotificationMetadata", obj.notificationMetadata);
+		setParameter(str + ".LifecycleTransition", obj.lifecycleTransition);
 	}
 }
 

ess/src/model/DeleteAlarmRequest.cc

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

ess/src/model/DeleteAlarmResult.cc

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

ess/src/model/DescribeAlarmsRequest.cc

@@ -0,0 +1,148 @@
+/*
+ * 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/DescribeAlarmsRequest.h>
+
+using AlibabaCloud::Ess::Model::DescribeAlarmsRequest;
+
+DescribeAlarmsRequest::DescribeAlarmsRequest() :
+	RpcServiceRequest("ess", "2014-08-28", "DescribeAlarms")
+{}
+
+DescribeAlarmsRequest::~DescribeAlarmsRequest()
+{}
+
+bool DescribeAlarmsRequest::getIsEnable()const
+{
+	return isEnable_;
+}
+
+void DescribeAlarmsRequest::setIsEnable(bool isEnable)
+{
+	isEnable_ = isEnable;
+	setParameter("IsEnable", std::to_string(isEnable));
+}
+
+std::string DescribeAlarmsRequest::getMetricType()const
+{
+	return metricType_;
+}
+
+void DescribeAlarmsRequest::setMetricType(const std::string& metricType)
+{
+	metricType_ = metricType;
+	setParameter("MetricType", metricType);
+}
+
+std::string DescribeAlarmsRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeAlarmsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeAlarmsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeAlarmsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DescribeAlarmsRequest::getScalingGroupId()const
+{
+	return scalingGroupId_;
+}
+
+void DescribeAlarmsRequest::setScalingGroupId(const std::string& scalingGroupId)
+{
+	scalingGroupId_ = scalingGroupId;
+	setParameter("ScalingGroupId", scalingGroupId);
+}
+
+int DescribeAlarmsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeAlarmsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string DescribeAlarmsRequest::getState()const
+{
+	return state_;
+}
+
+void DescribeAlarmsRequest::setState(const std::string& state)
+{
+	state_ = state;
+	setParameter("State", state);
+}
+
+long DescribeAlarmsRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeAlarmsRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeAlarmsRequest::getAlarmTaskId()const
+{
+	return alarmTaskId_;
+}
+
+void DescribeAlarmsRequest::setAlarmTaskId(const std::string& alarmTaskId)
+{
+	alarmTaskId_ = alarmTaskId;
+	setParameter("AlarmTaskId", alarmTaskId);
+}
+
+int DescribeAlarmsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeAlarmsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DescribeAlarmsRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeAlarmsRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

ess/src/model/DescribeAlarmsResult.cc

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ess/model/DescribeAlarmsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ess;
+using namespace AlibabaCloud::Ess::Model;
+
+DescribeAlarmsResult::DescribeAlarmsResult() :
+	ServiceResult()
+{}
+
+DescribeAlarmsResult::DescribeAlarmsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeAlarmsResult::~DescribeAlarmsResult()
+{}
+
+void DescribeAlarmsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allAlarmList = value["AlarmList"]["Alarm"];
+	for (auto value : allAlarmList)
+	{
+		Alarm alarmListObject;
+		if(!value["AlarmTaskId"].isNull())
+			alarmListObject.alarmTaskId = value["AlarmTaskId"].asString();
+		if(!value["Name"].isNull())
+			alarmListObject.name = value["Name"].asString();
+		if(!value["Description"].isNull())
+			alarmListObject.description = value["Description"].asString();
+		if(!value["MetricType"].isNull())
+			alarmListObject.metricType = value["MetricType"].asString();
+		if(!value["MetricName"].isNull())
+			alarmListObject.metricName = value["MetricName"].asString();
+		if(!value["Dimensions"].isNull())
+			alarmListObject.dimensions = value["Dimensions"].asString();
+		if(!value["Period"].isNull())
+			alarmListObject.period = std::stoi(value["Period"].asString());
+		if(!value["Statistics"].isNull())
+			alarmListObject.statistics = value["Statistics"].asString();
+		if(!value["ComparisonOperator"].isNull())
+			alarmListObject.comparisonOperator = value["ComparisonOperator"].asString();
+		if(!value["Threshold"].isNull())
+			alarmListObject.threshold = std::stof(value["Threshold"].asString());
+		if(!value["EvaluationCount"].isNull())
+			alarmListObject.evaluationCount = std::stoi(value["EvaluationCount"].asString());
+		if(!value["State"].isNull())
+			alarmListObject.state = value["State"].asString();
+		if(!value["ScalingGroupId"].isNull())
+			alarmListObject.scalingGroupId = value["ScalingGroupId"].asString();
+		if(!value["Enable"].isNull())
+			alarmListObject.enable = value["Enable"].asString() == "true";
+		auto allAlarmActions = value["alarmActions"]["alarmAction"];
+		for (auto value : allAlarmActions)
+			alarmListObject.alarmActions.push_back(value.asString());
+		alarmList_.push_back(alarmListObject);
+	}
+	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 DescribeAlarmsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeAlarmsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeAlarmsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeAlarmsResult::Alarm> DescribeAlarmsResult::getAlarmList()const
+{
+	return alarmList_;
+}
+

ess/src/model/DescribeScalingConfigurationsResult.cc

@@ -54,6 +54,8 @@ void DescribeScalingConfigurationsResult::parse(const std::string &payload)
 			scalingConfigurationsObject.instanceName = value["InstanceName"].asString();
 		if(!value["ImageId"].isNull())
 			scalingConfigurationsObject.imageId = value["ImageId"].asString();
+		if(!value["ImageName"].isNull())
+			scalingConfigurationsObject.imageName = value["ImageName"].asString();
 		if(!value["HostName"].isNull())
 			scalingConfigurationsObject.hostName = value["HostName"].asString();
 		if(!value["InstanceType"].isNull())
@@ -106,6 +108,8 @@ void DescribeScalingConfigurationsResult::parse(const std::string &payload)
 				dataDisksObject.snapshotId = value["SnapshotId"].asString();
 			if(!value["Device"].isNull())
 				dataDisksObject.device = value["Device"].asString();
+			if(!value["DeleteWithInstance"].isNull())
+				dataDisksObject.deleteWithInstance = value["DeleteWithInstance"].asString() == "true";
 			scalingConfigurationsObject.dataDisks.push_back(dataDisksObject);
 		}
 		auto allTags = value["Tags"]["Tag"];

ess/src/model/DisableAlarmRequest.cc

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

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

ess/src/model/EnableAlarmRequest.cc

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

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

ess/src/model/ModifyAlarmRequest.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/ModifyAlarmRequest.h>
+
+using AlibabaCloud::Ess::Model::ModifyAlarmRequest;
+
+ModifyAlarmRequest::ModifyAlarmRequest() :
+	RpcServiceRequest("ess", "2014-08-28", "ModifyAlarm")
+{}
+
+ModifyAlarmRequest::~ModifyAlarmRequest()
+{}
+
+std::string ModifyAlarmRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void ModifyAlarmRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string ModifyAlarmRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ModifyAlarmRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string ModifyAlarmRequest::getName()const
+{
+	return name_;
+}
+
+void ModifyAlarmRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+std::string ModifyAlarmRequest::getDescription()const
+{
+	return description_;
+}
+
+void ModifyAlarmRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+std::vector<std::string> ModifyAlarmRequest::getAlarmAction()const
+{
+	return alarmAction_;
+}
+
+void ModifyAlarmRequest::setAlarmAction(const std::vector<std::string>& alarmAction)
+{
+	alarmAction_ = alarmAction;
+	for(int i = 0; i!= alarmAction.size(); i++)
+		setParameter("AlarmAction."+ std::to_string(i), alarmAction.at(i));
+}
+
+long ModifyAlarmRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ModifyAlarmRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string ModifyAlarmRequest::getAlarmTaskId()const
+{
+	return alarmTaskId_;
+}
+
+void ModifyAlarmRequest::setAlarmTaskId(const std::string& alarmTaskId)
+{
+	alarmTaskId_ = alarmTaskId;
+	setParameter("AlarmTaskId", alarmTaskId);
+}
+
+std::string ModifyAlarmRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void ModifyAlarmRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

ess/src/model/ModifyAlarmResult.cc

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

ess/src/model/ModifyScalingConfigurationRequest.cc

@@ -36,26 +36,15 @@ void ModifyScalingConfigurationRequest::setImageId(const std::string& imageId)
 	setParameter("ImageId", imageId);
 }
 
-std::string ModifyScalingConfigurationRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
-}
-
-void ModifyScalingConfigurationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+std::string ModifyScalingConfigurationRequest::getIoOptimized()const
 {
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+	return ioOptimized_;
 }
 
-std::string ModifyScalingConfigurationRequest::getOwnerAccount()const
+void ModifyScalingConfigurationRequest::setIoOptimized(const std::string& ioOptimized)
 {
-	return ownerAccount_;
-}
-
-void ModifyScalingConfigurationRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+	ioOptimized_ = ioOptimized;
+	setParameter("IoOptimized", ioOptimized);
 }
 
 std::vector<std::string> ModifyScalingConfigurationRequest::getInstanceTypes()const
@@ -81,17 +70,6 @@ void ModifyScalingConfigurationRequest::setInternetMaxBandwidthOut(int internetM
 	setParameter("InternetMaxBandwidthOut", std::to_string(internetMaxBandwidthOut));
 }
 
-std::string ModifyScalingConfigurationRequest::getRamRoleName()const
-{
-	return ramRoleName_;
-}
-
-void ModifyScalingConfigurationRequest::setRamRoleName(const std::string& ramRoleName)
-{
-	ramRoleName_ = ramRoleName;
-	setParameter("RamRoleName", ramRoleName);
-}
-
 std::string ModifyScalingConfigurationRequest::getKeyPairName()const
 {
 	return keyPairName_;
@@ -103,15 +81,21 @@ void ModifyScalingConfigurationRequest::setKeyPairName(const std::string& keyPai
 	setParameter("KeyPairName", keyPairName);
 }
 
-long ModifyScalingConfigurationRequest::getOwnerId()const
+std::vector<ModifyScalingConfigurationRequest::SpotPriceLimit> ModifyScalingConfigurationRequest::getSpotPriceLimit()const
 {
-	return ownerId_;
+	return spotPriceLimit_;
 }
 
-void ModifyScalingConfigurationRequest::setOwnerId(long ownerId)
+void ModifyScalingConfigurationRequest::setSpotPriceLimit(const std::vector<SpotPriceLimit>& spotPriceLimit)
 {
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+	spotPriceLimit_ = spotPriceLimit;
+	int i = 0;
+	for(int i = 0; i!= spotPriceLimit.size(); i++)	{
+		auto obj = spotPriceLimit.at(i);
+		std::string str ="SpotPriceLimit."+ std::to_string(i);
+		setParameter(str + ".InstanceType", obj.instanceType);
+		setParameter(str + ".PriceLimit", std::to_string(obj.priceLimit));
+	}
 }
 
 std::string ModifyScalingConfigurationRequest::getSystemDiskCategory()const
@@ -136,6 +120,114 @@ void ModifyScalingConfigurationRequest::setAccessKeyId(const std::string& access
 	setParameter("AccessKeyId", accessKeyId);
 }
 
+std::string ModifyScalingConfigurationRequest::getUserData()const
+{
+	return userData_;
+}
+
+void ModifyScalingConfigurationRequest::setUserData(const std::string& userData)
+{
+	userData_ = userData;
+	setParameter("UserData", userData);
+}
+
+std::string ModifyScalingConfigurationRequest::getHostName()const
+{
+	return hostName_;
+}
+
+void ModifyScalingConfigurationRequest::setHostName(const std::string& hostName)
+{
+	hostName_ = hostName;
+	setParameter("HostName", hostName);
+}
+
+bool ModifyScalingConfigurationRequest::getPasswordInherit()const
+{
+	return passwordInherit_;
+}
+
+void ModifyScalingConfigurationRequest::setPasswordInherit(bool passwordInherit)
+{
+	passwordInherit_ = passwordInherit;
+	setParameter("PasswordInherit", std::to_string(passwordInherit));
+}
+
+std::string ModifyScalingConfigurationRequest::getImageName()const
+{
+	return imageName_;
+}
+
+void ModifyScalingConfigurationRequest::setImageName(const std::string& imageName)
+{
+	imageName_ = imageName;
+	setParameter("ImageName", imageName);
+}
+
+std::string ModifyScalingConfigurationRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void ModifyScalingConfigurationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string ModifyScalingConfigurationRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void ModifyScalingConfigurationRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string ModifyScalingConfigurationRequest::getRamRoleName()const
+{
+	return ramRoleName_;
+}
+
+void ModifyScalingConfigurationRequest::setRamRoleName(const std::string& ramRoleName)
+{
+	ramRoleName_ = ramRoleName;
+	setParameter("RamRoleName", ramRoleName);
+}
+
+long ModifyScalingConfigurationRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ModifyScalingConfigurationRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::vector<ModifyScalingConfigurationRequest::DataDisk> ModifyScalingConfigurationRequest::getDataDisk()const
+{
+	return dataDisk_;
+}
+
+void ModifyScalingConfigurationRequest::setDataDisk(const std::vector<DataDisk>& dataDisk)
+{
+	dataDisk_ = dataDisk;
+	int i = 0;
+	for(int i = 0; i!= dataDisk.size(); i++)	{
+		auto obj = dataDisk.at(i);
+		std::string str ="DataDisk."+ std::to_string(i);
+		setParameter(str + ".SnapshotId", obj.snapshotId);
+		setParameter(str + ".Size", std::to_string(obj.size));
+		setParameter(str + ".Category", obj.category);
+		setParameter(str + ".Device", obj.device);
+		setParameter(str + ".DeleteWithInstance", std::to_string(obj.deleteWithInstance));
+	}
+}
+
 std::string ModifyScalingConfigurationRequest::getScalingConfigurationName()const
 {
 	return scalingConfigurationName_;
@@ -169,26 +261,15 @@ void ModifyScalingConfigurationRequest::setScalingConfigurationId(const std::str
 	setParameter("ScalingConfigurationId", scalingConfigurationId);
 }
 
-std::string ModifyScalingConfigurationRequest::getUserData()const
+std::string ModifyScalingConfigurationRequest::getSpotStrategy()const
 {
-	return userData_;
+	return spotStrategy_;
 }
 
-void ModifyScalingConfigurationRequest::setUserData(const std::string& userData)
+void ModifyScalingConfigurationRequest::setSpotStrategy(const std::string& spotStrategy)
 {
-	userData_ = userData;
-	setParameter("UserData", userData);
-}
-
-std::string ModifyScalingConfigurationRequest::getHostName()const
-{
-	return hostName_;
-}
-
-void ModifyScalingConfigurationRequest::setHostName(const std::string& hostName)
-{
-	hostName_ = hostName;
-	setParameter("HostName", hostName);
+	spotStrategy_ = spotStrategy;
+	setParameter("SpotStrategy", spotStrategy);
 }
 
 std::string ModifyScalingConfigurationRequest::getInstanceName()const
@@ -213,17 +294,6 @@ void ModifyScalingConfigurationRequest::setLoadBalancerWeight(int loadBalancerWe
 	setParameter("LoadBalancerWeight", std::to_string(loadBalancerWeight));
 }
 
-bool ModifyScalingConfigurationRequest::getPasswordInherit()const
-{
-	return passwordInherit_;
-}
-
-void ModifyScalingConfigurationRequest::setPasswordInherit(bool passwordInherit)
-{
-	passwordInherit_ = passwordInherit;
-	setParameter("PasswordInherit", std::to_string(passwordInherit));
-}
-
 int ModifyScalingConfigurationRequest::getSystemDiskSize()const
 {
 	return systemDiskSize_;