Generated 2014-05-26 for Ecs.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-10-26 Version: patch
+- Generated 2014-05-26 for `Ecs`.
+
 2020-10-26 Version: patch
 - Generated 2016-11-01 for `live`.
 

ecs/CMakeLists.txt

@@ -81,6 +81,8 @@ set(ecs_public_header_model
 	include/alibabacloud/ecs/model/CreateAutoProvisioningGroupResult.h
 	include/alibabacloud/ecs/model/CreateAutoSnapshotPolicyRequest.h
 	include/alibabacloud/ecs/model/CreateAutoSnapshotPolicyResult.h
+	include/alibabacloud/ecs/model/CreateCapacityReservationRequest.h
+	include/alibabacloud/ecs/model/CreateCapacityReservationResult.h
 	include/alibabacloud/ecs/model/CreateCommandRequest.h
 	include/alibabacloud/ecs/model/CreateCommandResult.h
 	include/alibabacloud/ecs/model/CreateDedicatedHostClusterRequest.h
@@ -213,6 +215,10 @@ set(ecs_public_header_model
 	include/alibabacloud/ecs/model/DescribeBandwidthLimitationResult.h
 	include/alibabacloud/ecs/model/DescribeBandwidthPackagesRequest.h
 	include/alibabacloud/ecs/model/DescribeBandwidthPackagesResult.h
+	include/alibabacloud/ecs/model/DescribeCapacityReservationInstancesRequest.h
+	include/alibabacloud/ecs/model/DescribeCapacityReservationInstancesResult.h
+	include/alibabacloud/ecs/model/DescribeCapacityReservationsRequest.h
+	include/alibabacloud/ecs/model/DescribeCapacityReservationsResult.h
 	include/alibabacloud/ecs/model/DescribeClassicLinkInstancesRequest.h
 	include/alibabacloud/ecs/model/DescribeClassicLinkInstancesResult.h
 	include/alibabacloud/ecs/model/DescribeCloudAssistantStatusRequest.h
@@ -555,6 +561,8 @@ set(ecs_public_header_model
 	include/alibabacloud/ecs/model/RedeployDedicatedHostResult.h
 	include/alibabacloud/ecs/model/RedeployInstanceRequest.h
 	include/alibabacloud/ecs/model/RedeployInstanceResult.h
+	include/alibabacloud/ecs/model/ReleaseCapacityReservationRequest.h
+	include/alibabacloud/ecs/model/ReleaseCapacityReservationResult.h
 	include/alibabacloud/ecs/model/ReleaseDedicatedHostRequest.h
 	include/alibabacloud/ecs/model/ReleaseDedicatedHostResult.h
 	include/alibabacloud/ecs/model/ReleaseEipAddressRequest.h
@@ -678,6 +686,8 @@ set(ecs_src
 	src/model/CreateAutoProvisioningGroupResult.cc
 	src/model/CreateAutoSnapshotPolicyRequest.cc
 	src/model/CreateAutoSnapshotPolicyResult.cc
+	src/model/CreateCapacityReservationRequest.cc
+	src/model/CreateCapacityReservationResult.cc
 	src/model/CreateCommandRequest.cc
 	src/model/CreateCommandResult.cc
 	src/model/CreateDedicatedHostClusterRequest.cc
@@ -810,6 +820,10 @@ set(ecs_src
 	src/model/DescribeBandwidthLimitationResult.cc
 	src/model/DescribeBandwidthPackagesRequest.cc
 	src/model/DescribeBandwidthPackagesResult.cc
+	src/model/DescribeCapacityReservationInstancesRequest.cc
+	src/model/DescribeCapacityReservationInstancesResult.cc
+	src/model/DescribeCapacityReservationsRequest.cc
+	src/model/DescribeCapacityReservationsResult.cc
 	src/model/DescribeClassicLinkInstancesRequest.cc
 	src/model/DescribeClassicLinkInstancesResult.cc
 	src/model/DescribeCloudAssistantStatusRequest.cc
@@ -1152,6 +1166,8 @@ set(ecs_src
 	src/model/RedeployDedicatedHostResult.cc
 	src/model/RedeployInstanceRequest.cc
 	src/model/RedeployInstanceResult.cc
+	src/model/ReleaseCapacityReservationRequest.cc
+	src/model/ReleaseCapacityReservationResult.cc
 	src/model/ReleaseDedicatedHostRequest.cc
 	src/model/ReleaseDedicatedHostResult.cc
 	src/model/ReleaseEipAddressRequest.cc

ecs/include/alibabacloud/ecs/EcsClient.h

@@ -82,6 +82,8 @@
 #include "model/CreateAutoProvisioningGroupResult.h"
 #include "model/CreateAutoSnapshotPolicyRequest.h"
 #include "model/CreateAutoSnapshotPolicyResult.h"
+#include "model/CreateCapacityReservationRequest.h"
+#include "model/CreateCapacityReservationResult.h"
 #include "model/CreateCommandRequest.h"
 #include "model/CreateCommandResult.h"
 #include "model/CreateDedicatedHostClusterRequest.h"
@@ -214,6 +216,10 @@
 #include "model/DescribeBandwidthLimitationResult.h"
 #include "model/DescribeBandwidthPackagesRequest.h"
 #include "model/DescribeBandwidthPackagesResult.h"
+#include "model/DescribeCapacityReservationInstancesRequest.h"
+#include "model/DescribeCapacityReservationInstancesResult.h"
+#include "model/DescribeCapacityReservationsRequest.h"
+#include "model/DescribeCapacityReservationsResult.h"
 #include "model/DescribeClassicLinkInstancesRequest.h"
 #include "model/DescribeClassicLinkInstancesResult.h"
 #include "model/DescribeCloudAssistantStatusRequest.h"
@@ -556,6 +562,8 @@
 #include "model/RedeployDedicatedHostResult.h"
 #include "model/RedeployInstanceRequest.h"
 #include "model/RedeployInstanceResult.h"
+#include "model/ReleaseCapacityReservationRequest.h"
+#include "model/ReleaseCapacityReservationResult.h"
 #include "model/ReleaseDedicatedHostRequest.h"
 #include "model/ReleaseDedicatedHostResult.h"
 #include "model/ReleaseEipAddressRequest.h"
@@ -715,6 +723,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateAutoSnapshotPolicyResult> CreateAutoSnapshotPolicyOutcome;
 			typedef std::future<CreateAutoSnapshotPolicyOutcome> CreateAutoSnapshotPolicyOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::CreateAutoSnapshotPolicyRequest&, const CreateAutoSnapshotPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAutoSnapshotPolicyAsyncHandler;
+			typedef Outcome<Error, Model::CreateCapacityReservationResult> CreateCapacityReservationOutcome;
+			typedef std::future<CreateCapacityReservationOutcome> CreateCapacityReservationOutcomeCallable;
+			typedef std::function<void(const EcsClient*, const Model::CreateCapacityReservationRequest&, const CreateCapacityReservationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCapacityReservationAsyncHandler;
 			typedef Outcome<Error, Model::CreateCommandResult> CreateCommandOutcome;
 			typedef std::future<CreateCommandOutcome> CreateCommandOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::CreateCommandRequest&, const CreateCommandOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCommandAsyncHandler;
@@ -913,6 +924,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeBandwidthPackagesResult> DescribeBandwidthPackagesOutcome;
 			typedef std::future<DescribeBandwidthPackagesOutcome> DescribeBandwidthPackagesOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::DescribeBandwidthPackagesRequest&, const DescribeBandwidthPackagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBandwidthPackagesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeCapacityReservationInstancesResult> DescribeCapacityReservationInstancesOutcome;
+			typedef std::future<DescribeCapacityReservationInstancesOutcome> DescribeCapacityReservationInstancesOutcomeCallable;
+			typedef std::function<void(const EcsClient*, const Model::DescribeCapacityReservationInstancesRequest&, const DescribeCapacityReservationInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCapacityReservationInstancesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeCapacityReservationsResult> DescribeCapacityReservationsOutcome;
+			typedef std::future<DescribeCapacityReservationsOutcome> DescribeCapacityReservationsOutcomeCallable;
+			typedef std::function<void(const EcsClient*, const Model::DescribeCapacityReservationsRequest&, const DescribeCapacityReservationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCapacityReservationsAsyncHandler;
 			typedef Outcome<Error, Model::DescribeClassicLinkInstancesResult> DescribeClassicLinkInstancesOutcome;
 			typedef std::future<DescribeClassicLinkInstancesOutcome> DescribeClassicLinkInstancesOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::DescribeClassicLinkInstancesRequest&, const DescribeClassicLinkInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeClassicLinkInstancesAsyncHandler;
@@ -1426,6 +1443,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::RedeployInstanceResult> RedeployInstanceOutcome;
 			typedef std::future<RedeployInstanceOutcome> RedeployInstanceOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::RedeployInstanceRequest&, const RedeployInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RedeployInstanceAsyncHandler;
+			typedef Outcome<Error, Model::ReleaseCapacityReservationResult> ReleaseCapacityReservationOutcome;
+			typedef std::future<ReleaseCapacityReservationOutcome> ReleaseCapacityReservationOutcomeCallable;
+			typedef std::function<void(const EcsClient*, const Model::ReleaseCapacityReservationRequest&, const ReleaseCapacityReservationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReleaseCapacityReservationAsyncHandler;
 			typedef Outcome<Error, Model::ReleaseDedicatedHostResult> ReleaseDedicatedHostOutcome;
 			typedef std::future<ReleaseDedicatedHostOutcome> ReleaseDedicatedHostOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::ReleaseDedicatedHostRequest&, const ReleaseDedicatedHostOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReleaseDedicatedHostAsyncHandler;
@@ -1611,6 +1631,9 @@ namespace AlibabaCloud
 			CreateAutoSnapshotPolicyOutcome createAutoSnapshotPolicy(const Model::CreateAutoSnapshotPolicyRequest &request)const;
 			void createAutoSnapshotPolicyAsync(const Model::CreateAutoSnapshotPolicyRequest& request, const CreateAutoSnapshotPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateAutoSnapshotPolicyOutcomeCallable createAutoSnapshotPolicyCallable(const Model::CreateAutoSnapshotPolicyRequest& request) const;
+			CreateCapacityReservationOutcome createCapacityReservation(const Model::CreateCapacityReservationRequest &request)const;
+			void createCapacityReservationAsync(const Model::CreateCapacityReservationRequest& request, const CreateCapacityReservationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateCapacityReservationOutcomeCallable createCapacityReservationCallable(const Model::CreateCapacityReservationRequest& request) const;
 			CreateCommandOutcome createCommand(const Model::CreateCommandRequest &request)const;
 			void createCommandAsync(const Model::CreateCommandRequest& request, const CreateCommandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateCommandOutcomeCallable createCommandCallable(const Model::CreateCommandRequest& request) const;
@@ -1809,6 +1832,12 @@ namespace AlibabaCloud
 			DescribeBandwidthPackagesOutcome describeBandwidthPackages(const Model::DescribeBandwidthPackagesRequest &request)const;
 			void describeBandwidthPackagesAsync(const Model::DescribeBandwidthPackagesRequest& request, const DescribeBandwidthPackagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeBandwidthPackagesOutcomeCallable describeBandwidthPackagesCallable(const Model::DescribeBandwidthPackagesRequest& request) const;
+			DescribeCapacityReservationInstancesOutcome describeCapacityReservationInstances(const Model::DescribeCapacityReservationInstancesRequest &request)const;
+			void describeCapacityReservationInstancesAsync(const Model::DescribeCapacityReservationInstancesRequest& request, const DescribeCapacityReservationInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeCapacityReservationInstancesOutcomeCallable describeCapacityReservationInstancesCallable(const Model::DescribeCapacityReservationInstancesRequest& request) const;
+			DescribeCapacityReservationsOutcome describeCapacityReservations(const Model::DescribeCapacityReservationsRequest &request)const;
+			void describeCapacityReservationsAsync(const Model::DescribeCapacityReservationsRequest& request, const DescribeCapacityReservationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeCapacityReservationsOutcomeCallable describeCapacityReservationsCallable(const Model::DescribeCapacityReservationsRequest& request) const;
 			DescribeClassicLinkInstancesOutcome describeClassicLinkInstances(const Model::DescribeClassicLinkInstancesRequest &request)const;
 			void describeClassicLinkInstancesAsync(const Model::DescribeClassicLinkInstancesRequest& request, const DescribeClassicLinkInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeClassicLinkInstancesOutcomeCallable describeClassicLinkInstancesCallable(const Model::DescribeClassicLinkInstancesRequest& request) const;
@@ -2322,6 +2351,9 @@ namespace AlibabaCloud
 			RedeployInstanceOutcome redeployInstance(const Model::RedeployInstanceRequest &request)const;
 			void redeployInstanceAsync(const Model::RedeployInstanceRequest& request, const RedeployInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RedeployInstanceOutcomeCallable redeployInstanceCallable(const Model::RedeployInstanceRequest& request) const;
+			ReleaseCapacityReservationOutcome releaseCapacityReservation(const Model::ReleaseCapacityReservationRequest &request)const;
+			void releaseCapacityReservationAsync(const Model::ReleaseCapacityReservationRequest& request, const ReleaseCapacityReservationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ReleaseCapacityReservationOutcomeCallable releaseCapacityReservationCallable(const Model::ReleaseCapacityReservationRequest& request) const;
 			ReleaseDedicatedHostOutcome releaseDedicatedHost(const Model::ReleaseDedicatedHostRequest &request)const;
 			void releaseDedicatedHostAsync(const Model::ReleaseDedicatedHostRequest& request, const ReleaseDedicatedHostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ReleaseDedicatedHostOutcomeCallable releaseDedicatedHostCallable(const Model::ReleaseDedicatedHostRequest& request) const;

ecs/include/alibabacloud/ecs/model/CreateCapacityReservationRequest.h

@@ -0,0 +1,114 @@
+/*
+ * 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_ECS_MODEL_CREATECAPACITYRESERVATIONREQUEST_H_
+#define ALIBABACLOUD_ECS_MODEL_CREATECAPACITYRESERVATIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ecs/EcsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECS_EXPORT CreateCapacityReservationRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateCapacityReservationRequest();
+				~CreateCapacityReservationRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getPlatform()const;
+				void setPlatform(const std::string& platform);
+				std::string getPrivatePoolOptionsMatchCriteria()const;
+				void setPrivatePoolOptionsMatchCriteria(const std::string& privatePoolOptionsMatchCriteria);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getInstanceType()const;
+				void setInstanceType(const std::string& instanceType);
+				std::string getInstanceChargeType()const;
+				void setInstanceChargeType(const std::string& instanceChargeType);
+				int getEfficientStatus()const;
+				void setEfficientStatus(int efficientStatus);
+				int getPeriod()const;
+				void setPeriod(int period);
+				std::string getEndTimeType()const;
+				void setEndTimeType(const std::string& endTimeType);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getPrivatePoolOptionsName()const;
+				void setPrivatePoolOptionsName(const std::string& privatePoolOptionsName);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getResourceType()const;
+				void setResourceType(const std::string& resourceType);
+				std::string getPeriodUnit()const;
+				void setPeriodUnit(const std::string& periodUnit);
+				std::vector<std::string> getZoneId()const;
+				void setZoneId(const std::vector<std::string>& zoneId);
+				std::string getChargeType()const;
+				void setChargeType(const std::string& chargeType);
+				std::string getPackageType()const;
+				void setPackageType(const std::string& packageType);
+				int getInstanceAmount()const;
+				void setInstanceAmount(int instanceAmount);
+
+            private:
+				long resourceOwnerId_;
+				std::string clientToken_;
+				std::string description_;
+				std::string startTime_;
+				std::string platform_;
+				std::string privatePoolOptionsMatchCriteria_;
+				std::string regionId_;
+				std::string instanceType_;
+				std::string instanceChargeType_;
+				int efficientStatus_;
+				int period_;
+				std::string endTimeType_;
+				std::string resourceOwnerAccount_;
+				std::string privatePoolOptionsName_;
+				std::string ownerAccount_;
+				std::string endTime_;
+				long ownerId_;
+				std::string resourceType_;
+				std::string periodUnit_;
+				std::vector<std::string> zoneId_;
+				std::string chargeType_;
+				std::string packageType_;
+				int instanceAmount_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_CREATECAPACITYRESERVATIONREQUEST_H_

ecs/include/alibabacloud/ecs/model/CreateCapacityReservationResult.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_ECS_MODEL_CREATECAPACITYRESERVATIONRESULT_H_
+#define ALIBABACLOUD_ECS_MODEL_CREATECAPACITYRESERVATIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecs/EcsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECS_EXPORT CreateCapacityReservationResult : public ServiceResult
+			{
+			public:
+
+
+				CreateCapacityReservationResult();
+				explicit CreateCapacityReservationResult(const std::string &payload);
+				~CreateCapacityReservationResult();
+				std::string getPrivatePoolOptionsId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string privatePoolOptionsId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_CREATECAPACITYRESERVATIONRESULT_H_

ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationInstancesRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONINSTANCESREQUEST_H_
+#define ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONINSTANCESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ecs/EcsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECS_EXPORT DescribeCapacityReservationInstancesRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeCapacityReservationInstancesRequest();
+				~DescribeCapacityReservationInstancesRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getNextToken()const;
+				void setNextToken(const std::string& nextToken);
+				std::string getPrivatePoolOptionsId()const;
+				void setPrivatePoolOptionsId(const std::string& privatePoolOptionsId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				int getMaxResults()const;
+				void setMaxResults(int maxResults);
+				std::string getPackageType()const;
+				void setPackageType(const std::string& packageType);
+
+            private:
+				long resourceOwnerId_;
+				std::string regionId_;
+				std::string nextToken_;
+				std::string privatePoolOptionsId_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				int maxResults_;
+				std::string packageType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONINSTANCESREQUEST_H_

ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationInstancesResult.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONINSTANCESRESULT_H_
+#define ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONINSTANCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecs/EcsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECS_EXPORT DescribeCapacityReservationInstancesResult : public ServiceResult
+			{
+			public:
+				struct InstanceIdSet
+				{
+					std::string instanceId;
+				};
+
+
+				DescribeCapacityReservationInstancesResult();
+				explicit DescribeCapacityReservationInstancesResult(const std::string &payload);
+				~DescribeCapacityReservationInstancesResult();
+				std::vector<InstanceIdSet> getCapacityReservationItem()const;
+				int getTotalCount()const;
+				std::string getNextToken()const;
+				int getMaxResults()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<InstanceIdSet> capacityReservationItem_;
+				int totalCount_;
+				std::string nextToken_;
+				int maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONINSTANCESRESULT_H_

ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationsRequest.h

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONSREQUEST_H_
+#define ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ecs/EcsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECS_EXPORT DescribeCapacityReservationsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeCapacityReservationsRequest();
+				~DescribeCapacityReservationsRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getPlatform()const;
+				void setPlatform(const std::string& platform);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getNextToken()const;
+				void setNextToken(const std::string& nextToken);
+				std::string getInstanceType()const;
+				void setInstanceType(const std::string& instanceType);
+				std::string getInstanceChargeType()const;
+				void setInstanceChargeType(const std::string& instanceChargeType);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getPrivatePoolOptionsIds()const;
+				void setPrivatePoolOptionsIds(const std::string& privatePoolOptionsIds);
+				int getMaxResults()const;
+				void setMaxResults(int maxResults);
+				std::string getZoneId()const;
+				void setZoneId(const std::string& zoneId);
+				std::string getPackageType()const;
+				void setPackageType(const std::string& packageType);
+
+            private:
+				long resourceOwnerId_;
+				std::string platform_;
+				std::string regionId_;
+				std::string nextToken_;
+				std::string instanceType_;
+				std::string instanceChargeType_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string privatePoolOptionsIds_;
+				int maxResults_;
+				std::string zoneId_;
+				std::string packageType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONSREQUEST_H_

ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationsResult.h

@@ -0,0 +1,79 @@
+/*
+ * 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_ECS_MODEL_DESCRIBECAPACITYRESERVATIONSRESULT_H_
+#define ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecs/EcsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECS_EXPORT DescribeCapacityReservationsResult : public ServiceResult
+			{
+			public:
+				struct CapacityReservationItem
+				{
+					struct AllocatedResource
+					{
+						int usedAmount;
+						std::string zoneId;
+						int totalAmount;
+						std::string instanceType;
+					};
+					std::string status;
+					std::string description;
+					std::string endTime;
+					std::string endTimeType;
+					std::string platform;
+					std::string privatePoolOptionsName;
+					std::string instanceChargeType;
+					std::string startTime;
+					std::string regionId;
+					std::string privatePoolOptionsMatchCriteria;
+					std::vector<CapacityReservationItem::AllocatedResource> allocatedResources;
+					std::string privatePoolOptionsId;
+				};
+
+
+				DescribeCapacityReservationsResult();
+				explicit DescribeCapacityReservationsResult(const std::string &payload);
+				~DescribeCapacityReservationsResult();
+				int getTotalCount()const;
+				std::string getNextToken()const;
+				int getMaxResults()const;
+				std::vector<CapacityReservationItem> getCapacityReservationSet()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::string nextToken_;
+				int maxResults_;
+				std::vector<CapacityReservationItem> capacityReservationSet_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_DESCRIBECAPACITYRESERVATIONSRESULT_H_

ecs/include/alibabacloud/ecs/model/DescribeElasticityAssurancesRequest.h

@@ -37,10 +37,16 @@ namespace AlibabaCloud
 
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
+				std::string getPlatform()const;
+				void setPlatform(const std::string& platform);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
 				std::string getNextToken()const;
 				void setNextToken(const std::string& nextToken);
+				std::string getInstanceType()const;
+				void setInstanceType(const std::string& instanceType);
+				std::string getInstanceChargeType()const;
+				void setInstanceChargeType(const std::string& instanceChargeType);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getOwnerAccount()const;
@@ -51,18 +57,24 @@ namespace AlibabaCloud
 				void setPrivatePoolOptionsIds(const std::string& privatePoolOptionsIds);
 				int getMaxResults()const;
 				void setMaxResults(int maxResults);
+				std::string getZoneId()const;
+				void setZoneId(const std::string& zoneId);
 				std::string getPackageType()const;
 				void setPackageType(const std::string& packageType);
 
             private:
 				long resourceOwnerId_;
+				std::string platform_;
 				std::string regionId_;
 				std::string nextToken_;
+				std::string instanceType_;
+				std::string instanceChargeType_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
 				long ownerId_;
 				std::string privatePoolOptionsIds_;
 				int maxResults_;
+				std::string zoneId_;
 				std::string packageType_;
 
 			};

ecs/include/alibabacloud/ecs/model/ReleaseCapacityReservationRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ECS_MODEL_RELEASECAPACITYRESERVATIONREQUEST_H_
+#define ALIBABACLOUD_ECS_MODEL_RELEASECAPACITYRESERVATIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ecs/EcsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECS_EXPORT ReleaseCapacityReservationRequest : public RpcServiceRequest
+			{
+
+			public:
+				ReleaseCapacityReservationRequest();
+				~ReleaseCapacityReservationRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getPrivatePoolOptionsId()const;
+				void setPrivatePoolOptionsId(const std::string& privatePoolOptionsId);
+				bool getDryRun()const;
+				void setDryRun(bool dryRun);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long resourceOwnerId_;
+				std::string regionId_;
+				std::string privatePoolOptionsId_;
+				bool dryRun_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_RELEASECAPACITYRESERVATIONREQUEST_H_

ecs/include/alibabacloud/ecs/model/ReleaseCapacityReservationResult.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_ECS_MODEL_RELEASECAPACITYRESERVATIONRESULT_H_
+#define ALIBABACLOUD_ECS_MODEL_RELEASECAPACITYRESERVATIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecs/EcsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECS_EXPORT ReleaseCapacityReservationResult : public ServiceResult
+			{
+			public:
+
+
+				ReleaseCapacityReservationResult();
+				explicit ReleaseCapacityReservationResult(const std::string &payload);
+				~ReleaseCapacityReservationResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_RELEASECAPACITYRESERVATIONRESULT_H_

ecs/include/alibabacloud/ecs/model/RunInstancesRequest.h

@@ -226,6 +226,8 @@ namespace AlibabaCloud
 				void setDataDisk(const std::vector<DataDisk>& dataDisk);
 				long getLaunchTemplateVersion()const;
 				void setLaunchTemplateVersion(long launchTemplateVersion);
+				std::string getSchedulerOptionsManagedPrivateSpaceId()const;
+				void setSchedulerOptionsManagedPrivateSpaceId(const std::string& schedulerOptionsManagedPrivateSpaceId);
 				std::string getStorageSetId()const;
 				void setStorageSetId(const std::string& storageSetId);
 				std::string getHttpTokens()const;
@@ -311,6 +313,7 @@ namespace AlibabaCloud
 				std::string creditSpecification_;
 				std::vector<DataDisk> dataDisk_;
 				long launchTemplateVersion_;
+				std::string schedulerOptionsManagedPrivateSpaceId_;
 				std::string storageSetId_;
 				std::string httpTokens_;
 				std::string systemDiskDescription_;

ecs/src/EcsClient.cc

@@ -1131,6 +1131,42 @@ EcsClient::CreateAutoSnapshotPolicyOutcomeCallable EcsClient::createAutoSnapshot
 	return task->get_future();
 }
 
+EcsClient::CreateCapacityReservationOutcome EcsClient::createCapacityReservation(const CreateCapacityReservationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateCapacityReservationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateCapacityReservationOutcome(CreateCapacityReservationResult(outcome.result()));
+	else
+		return CreateCapacityReservationOutcome(outcome.error());
+}
+
+void EcsClient::createCapacityReservationAsync(const CreateCapacityReservationRequest& request, const CreateCapacityReservationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createCapacityReservation(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EcsClient::CreateCapacityReservationOutcomeCallable EcsClient::createCapacityReservationCallable(const CreateCapacityReservationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateCapacityReservationOutcome()>>(
+			[this, request]()
+			{
+			return this->createCapacityReservation(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EcsClient::CreateCommandOutcome EcsClient::createCommand(const CreateCommandRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3507,6 +3543,78 @@ EcsClient::DescribeBandwidthPackagesOutcomeCallable EcsClient::describeBandwidth
 	return task->get_future();
 }
 
+EcsClient::DescribeCapacityReservationInstancesOutcome EcsClient::describeCapacityReservationInstances(const DescribeCapacityReservationInstancesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeCapacityReservationInstancesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeCapacityReservationInstancesOutcome(DescribeCapacityReservationInstancesResult(outcome.result()));
+	else
+		return DescribeCapacityReservationInstancesOutcome(outcome.error());
+}
+
+void EcsClient::describeCapacityReservationInstancesAsync(const DescribeCapacityReservationInstancesRequest& request, const DescribeCapacityReservationInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeCapacityReservationInstances(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EcsClient::DescribeCapacityReservationInstancesOutcomeCallable EcsClient::describeCapacityReservationInstancesCallable(const DescribeCapacityReservationInstancesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeCapacityReservationInstancesOutcome()>>(
+			[this, request]()
+			{
+			return this->describeCapacityReservationInstances(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EcsClient::DescribeCapacityReservationsOutcome EcsClient::describeCapacityReservations(const DescribeCapacityReservationsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeCapacityReservationsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeCapacityReservationsOutcome(DescribeCapacityReservationsResult(outcome.result()));
+	else
+		return DescribeCapacityReservationsOutcome(outcome.error());
+}
+
+void EcsClient::describeCapacityReservationsAsync(const DescribeCapacityReservationsRequest& request, const DescribeCapacityReservationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeCapacityReservations(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EcsClient::DescribeCapacityReservationsOutcomeCallable EcsClient::describeCapacityReservationsCallable(const DescribeCapacityReservationsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeCapacityReservationsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeCapacityReservations(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EcsClient::DescribeClassicLinkInstancesOutcome EcsClient::describeClassicLinkInstances(const DescribeClassicLinkInstancesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -9663,6 +9771,42 @@ EcsClient::RedeployInstanceOutcomeCallable EcsClient::redeployInstanceCallable(c
 	return task->get_future();
 }
 
+EcsClient::ReleaseCapacityReservationOutcome EcsClient::releaseCapacityReservation(const ReleaseCapacityReservationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ReleaseCapacityReservationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ReleaseCapacityReservationOutcome(ReleaseCapacityReservationResult(outcome.result()));
+	else
+		return ReleaseCapacityReservationOutcome(outcome.error());
+}
+
+void EcsClient::releaseCapacityReservationAsync(const ReleaseCapacityReservationRequest& request, const ReleaseCapacityReservationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, releaseCapacityReservation(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EcsClient::ReleaseCapacityReservationOutcomeCallable EcsClient::releaseCapacityReservationCallable(const ReleaseCapacityReservationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ReleaseCapacityReservationOutcome()>>(
+			[this, request]()
+			{
+			return this->releaseCapacityReservation(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EcsClient::ReleaseDedicatedHostOutcome EcsClient::releaseDedicatedHost(const ReleaseDedicatedHostRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

ecs/src/model/CreateCapacityReservationRequest.cc

@@ -0,0 +1,284 @@
+/*
+ * 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/ecs/model/CreateCapacityReservationRequest.h>
+
+using AlibabaCloud::Ecs::Model::CreateCapacityReservationRequest;
+
+CreateCapacityReservationRequest::CreateCapacityReservationRequest() :
+	RpcServiceRequest("ecs", "2014-05-26", "CreateCapacityReservation")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateCapacityReservationRequest::~CreateCapacityReservationRequest()
+{}
+
+long CreateCapacityReservationRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateCapacityReservationRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string CreateCapacityReservationRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateCapacityReservationRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string CreateCapacityReservationRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateCapacityReservationRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+std::string CreateCapacityReservationRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void CreateCapacityReservationRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string CreateCapacityReservationRequest::getPlatform()const
+{
+	return platform_;
+}
+
+void CreateCapacityReservationRequest::setPlatform(const std::string& platform)
+{
+	platform_ = platform;
+	setParameter("Platform", platform);
+}
+
+std::string CreateCapacityReservationRequest::getPrivatePoolOptionsMatchCriteria()const
+{
+	return privatePoolOptionsMatchCriteria_;
+}
+
+void CreateCapacityReservationRequest::setPrivatePoolOptionsMatchCriteria(const std::string& privatePoolOptionsMatchCriteria)
+{
+	privatePoolOptionsMatchCriteria_ = privatePoolOptionsMatchCriteria;
+	setParameter("PrivatePoolOptionsMatchCriteria", privatePoolOptionsMatchCriteria);
+}
+
+std::string CreateCapacityReservationRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateCapacityReservationRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreateCapacityReservationRequest::getInstanceType()const
+{
+	return instanceType_;
+}
+
+void CreateCapacityReservationRequest::setInstanceType(const std::string& instanceType)
+{
+	instanceType_ = instanceType;
+	setParameter("InstanceType", instanceType);
+}
+
+std::string CreateCapacityReservationRequest::getInstanceChargeType()const
+{
+	return instanceChargeType_;
+}
+
+void CreateCapacityReservationRequest::setInstanceChargeType(const std::string& instanceChargeType)
+{
+	instanceChargeType_ = instanceChargeType;
+	setParameter("InstanceChargeType", instanceChargeType);
+}
+
+int CreateCapacityReservationRequest::getEfficientStatus()const
+{
+	return efficientStatus_;
+}
+
+void CreateCapacityReservationRequest::setEfficientStatus(int efficientStatus)
+{
+	efficientStatus_ = efficientStatus;
+	setParameter("EfficientStatus", std::to_string(efficientStatus));
+}
+
+int CreateCapacityReservationRequest::getPeriod()const
+{
+	return period_;
+}
+
+void CreateCapacityReservationRequest::setPeriod(int period)
+{
+	period_ = period;
+	setParameter("Period", std::to_string(period));
+}
+
+std::string CreateCapacityReservationRequest::getEndTimeType()const
+{
+	return endTimeType_;
+}
+
+void CreateCapacityReservationRequest::setEndTimeType(const std::string& endTimeType)
+{
+	endTimeType_ = endTimeType;
+	setParameter("EndTimeType", endTimeType);
+}
+
+std::string CreateCapacityReservationRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateCapacityReservationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateCapacityReservationRequest::getPrivatePoolOptionsName()const
+{
+	return privatePoolOptionsName_;
+}
+
+void CreateCapacityReservationRequest::setPrivatePoolOptionsName(const std::string& privatePoolOptionsName)
+{
+	privatePoolOptionsName_ = privatePoolOptionsName;
+	setParameter("PrivatePoolOptionsName", privatePoolOptionsName);
+}
+
+std::string CreateCapacityReservationRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateCapacityReservationRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string CreateCapacityReservationRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void CreateCapacityReservationRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+long CreateCapacityReservationRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateCapacityReservationRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateCapacityReservationRequest::getResourceType()const
+{
+	return resourceType_;
+}
+
+void CreateCapacityReservationRequest::setResourceType(const std::string& resourceType)
+{
+	resourceType_ = resourceType;
+	setParameter("ResourceType", resourceType);
+}
+
+std::string CreateCapacityReservationRequest::getPeriodUnit()const
+{
+	return periodUnit_;
+}
+
+void CreateCapacityReservationRequest::setPeriodUnit(const std::string& periodUnit)
+{
+	periodUnit_ = periodUnit;
+	setParameter("PeriodUnit", periodUnit);
+}
+
+std::vector<std::string> CreateCapacityReservationRequest::getZoneId()const
+{
+	return zoneId_;
+}
+
+void CreateCapacityReservationRequest::setZoneId(const std::vector<std::string>& zoneId)
+{
+	zoneId_ = zoneId;
+	for(int dep1 = 0; dep1!= zoneId.size(); dep1++) {
+		setParameter("ZoneId."+ std::to_string(dep1), zoneId.at(dep1));
+	}
+}
+
+std::string CreateCapacityReservationRequest::getChargeType()const
+{
+	return chargeType_;
+}
+
+void CreateCapacityReservationRequest::setChargeType(const std::string& chargeType)
+{
+	chargeType_ = chargeType;
+	setParameter("ChargeType", chargeType);
+}
+
+std::string CreateCapacityReservationRequest::getPackageType()const
+{
+	return packageType_;
+}
+
+void CreateCapacityReservationRequest::setPackageType(const std::string& packageType)
+{
+	packageType_ = packageType;
+	setParameter("PackageType", packageType);
+}
+
+int CreateCapacityReservationRequest::getInstanceAmount()const
+{
+	return instanceAmount_;
+}
+
+void CreateCapacityReservationRequest::setInstanceAmount(int instanceAmount)
+{
+	instanceAmount_ = instanceAmount;
+	setParameter("InstanceAmount", std::to_string(instanceAmount));
+}
+

ecs/src/model/CreateCapacityReservationResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/ecs/model/CreateCapacityReservationResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecs;
+using namespace AlibabaCloud::Ecs::Model;
+
+CreateCapacityReservationResult::CreateCapacityReservationResult() :
+	ServiceResult()
+{}
+
+CreateCapacityReservationResult::CreateCapacityReservationResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateCapacityReservationResult::~CreateCapacityReservationResult()
+{}
+
+void CreateCapacityReservationResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["PrivatePoolOptionsId"].isNull())
+		privatePoolOptionsId_ = value["PrivatePoolOptionsId"].asString();
+
+}
+
+std::string CreateCapacityReservationResult::getPrivatePoolOptionsId()const
+{
+	return privatePoolOptionsId_;
+}
+

ecs/src/model/DescribeCapacityReservationInstancesRequest.cc

@@ -0,0 +1,128 @@
+/*
+ * 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/ecs/model/DescribeCapacityReservationInstancesRequest.h>
+
+using AlibabaCloud::Ecs::Model::DescribeCapacityReservationInstancesRequest;
+
+DescribeCapacityReservationInstancesRequest::DescribeCapacityReservationInstancesRequest() :
+	RpcServiceRequest("ecs", "2014-05-26", "DescribeCapacityReservationInstances")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeCapacityReservationInstancesRequest::~DescribeCapacityReservationInstancesRequest()
+{}
+
+long DescribeCapacityReservationInstancesRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeCapacityReservationInstancesRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeCapacityReservationInstancesRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeCapacityReservationInstancesRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DescribeCapacityReservationInstancesRequest::getNextToken()const
+{
+	return nextToken_;
+}
+
+void DescribeCapacityReservationInstancesRequest::setNextToken(const std::string& nextToken)
+{
+	nextToken_ = nextToken;
+	setParameter("NextToken", nextToken);
+}
+
+std::string DescribeCapacityReservationInstancesRequest::getPrivatePoolOptionsId()const
+{
+	return privatePoolOptionsId_;
+}
+
+void DescribeCapacityReservationInstancesRequest::setPrivatePoolOptionsId(const std::string& privatePoolOptionsId)
+{
+	privatePoolOptionsId_ = privatePoolOptionsId;
+	setParameter("PrivatePoolOptionsId", privatePoolOptionsId);
+}
+
+std::string DescribeCapacityReservationInstancesRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeCapacityReservationInstancesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeCapacityReservationInstancesRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeCapacityReservationInstancesRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DescribeCapacityReservationInstancesRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeCapacityReservationInstancesRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+int DescribeCapacityReservationInstancesRequest::getMaxResults()const
+{
+	return maxResults_;
+}
+
+void DescribeCapacityReservationInstancesRequest::setMaxResults(int maxResults)
+{
+	maxResults_ = maxResults;
+	setParameter("MaxResults", std::to_string(maxResults));
+}
+
+std::string DescribeCapacityReservationInstancesRequest::getPackageType()const
+{
+	return packageType_;
+}
+
+void DescribeCapacityReservationInstancesRequest::setPackageType(const std::string& packageType)
+{
+	packageType_ = packageType;
+	setParameter("PackageType", packageType);
+}
+

ecs/src/model/DescribeCapacityReservationInstancesResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/ecs/model/DescribeCapacityReservationInstancesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecs;
+using namespace AlibabaCloud::Ecs::Model;
+
+DescribeCapacityReservationInstancesResult::DescribeCapacityReservationInstancesResult() :
+	ServiceResult()
+{}
+
+DescribeCapacityReservationInstancesResult::DescribeCapacityReservationInstancesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeCapacityReservationInstancesResult::~DescribeCapacityReservationInstancesResult()
+{}
+
+void DescribeCapacityReservationInstancesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allCapacityReservationItemNode = value["CapacityReservationItem"]["InstanceIdSet"];
+	for (auto valueCapacityReservationItemInstanceIdSet : allCapacityReservationItemNode)
+	{
+		InstanceIdSet capacityReservationItemObject;
+		if(!valueCapacityReservationItemInstanceIdSet["InstanceId"].isNull())
+			capacityReservationItemObject.instanceId = valueCapacityReservationItemInstanceIdSet["InstanceId"].asString();
+		capacityReservationItem_.push_back(capacityReservationItemObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["MaxResults"].isNull())
+		maxResults_ = std::stoi(value["MaxResults"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+std::vector<DescribeCapacityReservationInstancesResult::InstanceIdSet> DescribeCapacityReservationInstancesResult::getCapacityReservationItem()const
+{
+	return capacityReservationItem_;
+}
+
+int DescribeCapacityReservationInstancesResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::string DescribeCapacityReservationInstancesResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+int DescribeCapacityReservationInstancesResult::getMaxResults()const
+{
+	return maxResults_;
+}
+

ecs/src/model/DescribeCapacityReservationsRequest.cc

@@ -0,0 +1,172 @@
+/*
+ * 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/ecs/model/DescribeCapacityReservationsRequest.h>
+
+using AlibabaCloud::Ecs::Model::DescribeCapacityReservationsRequest;
+
+DescribeCapacityReservationsRequest::DescribeCapacityReservationsRequest() :
+	RpcServiceRequest("ecs", "2014-05-26", "DescribeCapacityReservations")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeCapacityReservationsRequest::~DescribeCapacityReservationsRequest()
+{}
+
+long DescribeCapacityReservationsRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeCapacityReservationsRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeCapacityReservationsRequest::getPlatform()const
+{
+	return platform_;
+}
+
+void DescribeCapacityReservationsRequest::setPlatform(const std::string& platform)
+{
+	platform_ = platform;
+	setParameter("Platform", platform);
+}
+
+std::string DescribeCapacityReservationsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeCapacityReservationsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DescribeCapacityReservationsRequest::getNextToken()const
+{
+	return nextToken_;
+}
+
+void DescribeCapacityReservationsRequest::setNextToken(const std::string& nextToken)
+{
+	nextToken_ = nextToken;
+	setParameter("NextToken", nextToken);
+}
+
+std::string DescribeCapacityReservationsRequest::getInstanceType()const
+{
+	return instanceType_;
+}
+
+void DescribeCapacityReservationsRequest::setInstanceType(const std::string& instanceType)
+{
+	instanceType_ = instanceType;
+	setParameter("InstanceType", instanceType);
+}
+
+std::string DescribeCapacityReservationsRequest::getInstanceChargeType()const
+{
+	return instanceChargeType_;
+}
+
+void DescribeCapacityReservationsRequest::setInstanceChargeType(const std::string& instanceChargeType)
+{
+	instanceChargeType_ = instanceChargeType;
+	setParameter("InstanceChargeType", instanceChargeType);
+}
+
+std::string DescribeCapacityReservationsRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeCapacityReservationsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeCapacityReservationsRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeCapacityReservationsRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DescribeCapacityReservationsRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeCapacityReservationsRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeCapacityReservationsRequest::getPrivatePoolOptionsIds()const
+{
+	return privatePoolOptionsIds_;
+}
+
+void DescribeCapacityReservationsRequest::setPrivatePoolOptionsIds(const std::string& privatePoolOptionsIds)
+{
+	privatePoolOptionsIds_ = privatePoolOptionsIds;
+	setParameter("PrivatePoolOptionsIds", privatePoolOptionsIds);
+}
+
+int DescribeCapacityReservationsRequest::getMaxResults()const
+{
+	return maxResults_;
+}
+
+void DescribeCapacityReservationsRequest::setMaxResults(int maxResults)
+{
+	maxResults_ = maxResults;
+	setParameter("MaxResults", std::to_string(maxResults));
+}
+
+std::string DescribeCapacityReservationsRequest::getZoneId()const
+{
+	return zoneId_;
+}
+
+void DescribeCapacityReservationsRequest::setZoneId(const std::string& zoneId)
+{
+	zoneId_ = zoneId;
+	setParameter("ZoneId", zoneId);
+}
+
+std::string DescribeCapacityReservationsRequest::getPackageType()const
+{
+	return packageType_;
+}
+
+void DescribeCapacityReservationsRequest::setPackageType(const std::string& packageType)
+{
+	packageType_ = packageType;
+	setParameter("PackageType", packageType);
+}
+

ecs/src/model/DescribeCapacityReservationsResult.cc

@@ -0,0 +1,112 @@
+/*
+ * 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/ecs/model/DescribeCapacityReservationsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecs;
+using namespace AlibabaCloud::Ecs::Model;
+
+DescribeCapacityReservationsResult::DescribeCapacityReservationsResult() :
+	ServiceResult()
+{}
+
+DescribeCapacityReservationsResult::DescribeCapacityReservationsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeCapacityReservationsResult::~DescribeCapacityReservationsResult()
+{}
+
+void DescribeCapacityReservationsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allCapacityReservationSetNode = value["CapacityReservationSet"]["CapacityReservationItem"];
+	for (auto valueCapacityReservationSetCapacityReservationItem : allCapacityReservationSetNode)
+	{
+		CapacityReservationItem capacityReservationSetObject;
+		if(!valueCapacityReservationSetCapacityReservationItem["PrivatePoolOptionsId"].isNull())
+			capacityReservationSetObject.privatePoolOptionsId = valueCapacityReservationSetCapacityReservationItem["PrivatePoolOptionsId"].asString();
+		if(!valueCapacityReservationSetCapacityReservationItem["PrivatePoolOptionsName"].isNull())
+			capacityReservationSetObject.privatePoolOptionsName = valueCapacityReservationSetCapacityReservationItem["PrivatePoolOptionsName"].asString();
+		if(!valueCapacityReservationSetCapacityReservationItem["Description"].isNull())
+			capacityReservationSetObject.description = valueCapacityReservationSetCapacityReservationItem["Description"].asString();
+		if(!valueCapacityReservationSetCapacityReservationItem["RegionId"].isNull())
+			capacityReservationSetObject.regionId = valueCapacityReservationSetCapacityReservationItem["RegionId"].asString();
+		if(!valueCapacityReservationSetCapacityReservationItem["PrivatePoolOptionsMatchCriteria"].isNull())
+			capacityReservationSetObject.privatePoolOptionsMatchCriteria = valueCapacityReservationSetCapacityReservationItem["PrivatePoolOptionsMatchCriteria"].asString();
+		if(!valueCapacityReservationSetCapacityReservationItem["Status"].isNull())
+			capacityReservationSetObject.status = valueCapacityReservationSetCapacityReservationItem["Status"].asString();
+		if(!valueCapacityReservationSetCapacityReservationItem["StartTime"].isNull())
+			capacityReservationSetObject.startTime = valueCapacityReservationSetCapacityReservationItem["StartTime"].asString();
+		if(!valueCapacityReservationSetCapacityReservationItem["EndTime"].isNull())
+			capacityReservationSetObject.endTime = valueCapacityReservationSetCapacityReservationItem["EndTime"].asString();
+		if(!valueCapacityReservationSetCapacityReservationItem["EndTimeType"].isNull())
+			capacityReservationSetObject.endTimeType = valueCapacityReservationSetCapacityReservationItem["EndTimeType"].asString();
+		if(!valueCapacityReservationSetCapacityReservationItem["InstanceChargeType"].isNull())
+			capacityReservationSetObject.instanceChargeType = valueCapacityReservationSetCapacityReservationItem["InstanceChargeType"].asString();
+		if(!valueCapacityReservationSetCapacityReservationItem["Platform"].isNull())
+			capacityReservationSetObject.platform = valueCapacityReservationSetCapacityReservationItem["Platform"].asString();
+		auto allAllocatedResourcesNode = allCapacityReservationSetNode["AllocatedResources"]["AllocatedResource"];
+		for (auto allCapacityReservationSetNodeAllocatedResourcesAllocatedResource : allAllocatedResourcesNode)
+		{
+			CapacityReservationItem::AllocatedResource allocatedResourcesObject;
+			if(!allCapacityReservationSetNodeAllocatedResourcesAllocatedResource["zoneId"].isNull())
+				allocatedResourcesObject.zoneId = allCapacityReservationSetNodeAllocatedResourcesAllocatedResource["zoneId"].asString();
+			if(!allCapacityReservationSetNodeAllocatedResourcesAllocatedResource["InstanceType"].isNull())
+				allocatedResourcesObject.instanceType = allCapacityReservationSetNodeAllocatedResourcesAllocatedResource["InstanceType"].asString();
+			if(!allCapacityReservationSetNodeAllocatedResourcesAllocatedResource["TotalAmount"].isNull())
+				allocatedResourcesObject.totalAmount = std::stoi(allCapacityReservationSetNodeAllocatedResourcesAllocatedResource["TotalAmount"].asString());
+			if(!allCapacityReservationSetNodeAllocatedResourcesAllocatedResource["UsedAmount"].isNull())
+				allocatedResourcesObject.usedAmount = std::stoi(allCapacityReservationSetNodeAllocatedResourcesAllocatedResource["UsedAmount"].asString());
+			capacityReservationSetObject.allocatedResources.push_back(allocatedResourcesObject);
+		}
+		capacityReservationSet_.push_back(capacityReservationSetObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["MaxResults"].isNull())
+		maxResults_ = std::stoi(value["MaxResults"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+int DescribeCapacityReservationsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::string DescribeCapacityReservationsResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+int DescribeCapacityReservationsResult::getMaxResults()const
+{
+	return maxResults_;
+}
+
+std::vector<DescribeCapacityReservationsResult::CapacityReservationItem> DescribeCapacityReservationsResult::getCapacityReservationSet()const
+{
+	return capacityReservationSet_;
+}
+

ecs/src/model/DescribeElasticityAssurancesRequest.cc

@@ -38,6 +38,17 @@ void DescribeElasticityAssurancesRequest::setResourceOwnerId(long resourceOwnerI
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+std::string DescribeElasticityAssurancesRequest::getPlatform()const
+{
+	return platform_;
+}
+
+void DescribeElasticityAssurancesRequest::setPlatform(const std::string& platform)
+{
+	platform_ = platform;
+	setParameter("Platform", platform);
+}
+
 std::string DescribeElasticityAssurancesRequest::getRegionId()const
 {
 	return regionId_;
@@ -60,6 +71,28 @@ void DescribeElasticityAssurancesRequest::setNextToken(const std::string& nextTo
 	setParameter("NextToken", nextToken);
 }
 
+std::string DescribeElasticityAssurancesRequest::getInstanceType()const
+{
+	return instanceType_;
+}
+
+void DescribeElasticityAssurancesRequest::setInstanceType(const std::string& instanceType)
+{
+	instanceType_ = instanceType;
+	setParameter("InstanceType", instanceType);
+}
+
+std::string DescribeElasticityAssurancesRequest::getInstanceChargeType()const
+{
+	return instanceChargeType_;
+}
+
+void DescribeElasticityAssurancesRequest::setInstanceChargeType(const std::string& instanceChargeType)
+{
+	instanceChargeType_ = instanceChargeType;
+	setParameter("InstanceChargeType", instanceChargeType);
+}
+
 std::string DescribeElasticityAssurancesRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -115,6 +148,17 @@ void DescribeElasticityAssurancesRequest::setMaxResults(int maxResults)
 	setParameter("MaxResults", std::to_string(maxResults));
 }
 
+std::string DescribeElasticityAssurancesRequest::getZoneId()const
+{
+	return zoneId_;
+}
+
+void DescribeElasticityAssurancesRequest::setZoneId(const std::string& zoneId)
+{
+	zoneId_ = zoneId;
+	setParameter("ZoneId", zoneId);
+}
+
 std::string DescribeElasticityAssurancesRequest::getPackageType()const
 {
 	return packageType_;

ecs/src/model/ReleaseCapacityReservationRequest.cc

@@ -0,0 +1,106 @@
+/*
+ * 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/ecs/model/ReleaseCapacityReservationRequest.h>
+
+using AlibabaCloud::Ecs::Model::ReleaseCapacityReservationRequest;
+
+ReleaseCapacityReservationRequest::ReleaseCapacityReservationRequest() :
+	RpcServiceRequest("ecs", "2014-05-26", "ReleaseCapacityReservation")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ReleaseCapacityReservationRequest::~ReleaseCapacityReservationRequest()
+{}
+
+long ReleaseCapacityReservationRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void ReleaseCapacityReservationRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string ReleaseCapacityReservationRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ReleaseCapacityReservationRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string ReleaseCapacityReservationRequest::getPrivatePoolOptionsId()const
+{
+	return privatePoolOptionsId_;
+}
+
+void ReleaseCapacityReservationRequest::setPrivatePoolOptionsId(const std::string& privatePoolOptionsId)
+{
+	privatePoolOptionsId_ = privatePoolOptionsId;
+	setParameter("PrivatePoolOptionsId", privatePoolOptionsId);
+}
+
+bool ReleaseCapacityReservationRequest::getDryRun()const
+{
+	return dryRun_;
+}
+
+void ReleaseCapacityReservationRequest::setDryRun(bool dryRun)
+{
+	dryRun_ = dryRun;
+	setParameter("DryRun", dryRun ? "true" : "false");
+}
+
+std::string ReleaseCapacityReservationRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void ReleaseCapacityReservationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string ReleaseCapacityReservationRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void ReleaseCapacityReservationRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long ReleaseCapacityReservationRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ReleaseCapacityReservationRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

ecs/src/model/ReleaseCapacityReservationResult.cc

@@ -0,0 +1,44 @@
+/*
+ * 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/ecs/model/ReleaseCapacityReservationResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecs;
+using namespace AlibabaCloud::Ecs::Model;
+
+ReleaseCapacityReservationResult::ReleaseCapacityReservationResult() :
+	ServiceResult()
+{}
+
+ReleaseCapacityReservationResult::ReleaseCapacityReservationResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ReleaseCapacityReservationResult::~ReleaseCapacityReservationResult()
+{}
+
+void ReleaseCapacityReservationResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

ecs/src/model/RunInstancesRequest.cc

@@ -916,6 +916,17 @@ void RunInstancesRequest::setLaunchTemplateVersion(long launchTemplateVersion)
 	setParameter("LaunchTemplateVersion", std::to_string(launchTemplateVersion));
 }
 
+std::string RunInstancesRequest::getSchedulerOptionsManagedPrivateSpaceId()const
+{
+	return schedulerOptionsManagedPrivateSpaceId_;
+}
+
+void RunInstancesRequest::setSchedulerOptionsManagedPrivateSpaceId(const std::string& schedulerOptionsManagedPrivateSpaceId)
+{
+	schedulerOptionsManagedPrivateSpaceId_ = schedulerOptionsManagedPrivateSpaceId;
+	setParameter("SchedulerOptionsManagedPrivateSpaceId", schedulerOptionsManagedPrivateSpaceId);
+}
+
 std::string RunInstancesRequest::getStorageSetId()const
 {
 	return storageSetId_;