Ecs support hibernation.

ecs/src/EcsClient.cc

@@ -5235,6 +5235,42 @@ EcsClient::DescribeInstanceMaintenanceAttributesOutcomeCallable EcsClient::descr
 	return task->get_future();
 }
 
+EcsClient::DescribeInstanceModificationPriceOutcome EcsClient::describeInstanceModificationPrice(const DescribeInstanceModificationPriceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeInstanceModificationPriceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeInstanceModificationPriceOutcome(DescribeInstanceModificationPriceResult(outcome.result()));
+	else
+		return DescribeInstanceModificationPriceOutcome(outcome.error());
+}
+
+void EcsClient::describeInstanceModificationPriceAsync(const DescribeInstanceModificationPriceRequest& request, const DescribeInstanceModificationPriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeInstanceModificationPrice(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EcsClient::DescribeInstanceModificationPriceOutcomeCallable EcsClient::describeInstanceModificationPriceCallable(const DescribeInstanceModificationPriceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeInstanceModificationPriceOutcome()>>(
+			[this, request]()
+			{
+			return this->describeInstanceModificationPrice(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EcsClient::DescribeInstanceMonitorDataOutcome EcsClient::describeInstanceMonitorData(const DescribeInstanceMonitorDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

ecs/src/model/AllocateDedicatedHostsRequest.cc

@@ -82,6 +82,17 @@ void AllocateDedicatedHostsRequest::setResourceGroupId(const std::string& resour
 	setParameter("ResourceGroupId", resourceGroupId);
 }
 
+int AllocateDedicatedHostsRequest::getMinQuantity()const
+{
+	return minQuantity_;
+}
+
+void AllocateDedicatedHostsRequest::setMinQuantity(int minQuantity)
+{
+	minQuantity_ = minQuantity;
+	setParameter("MinQuantity", std::to_string(minQuantity));
+}
+
 std::string AllocateDedicatedHostsRequest::getRegionId()const
 {
 	return regionId_;

ecs/src/model/CreateAutoProvisioningGroupRequest.cc

@@ -128,6 +128,17 @@ void CreateAutoProvisioningGroupRequest::setLaunchConfigurationResourceGroupId(c
 	setParameter("LaunchConfigurationResourceGroupId", launchConfigurationResourceGroupId);
 }
 
+std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationPassword()const
+{
+	return launchConfigurationPassword_;
+}
+
+void CreateAutoProvisioningGroupRequest::setLaunchConfigurationPassword(const std::string& launchConfigurationPassword)
+{
+	launchConfigurationPassword_ = launchConfigurationPassword;
+	setParameter("LaunchConfigurationPassword", launchConfigurationPassword);
+}
+
 std::string CreateAutoProvisioningGroupRequest::getPayAsYouGoAllocationStrategy()const
 {
 	return payAsYouGoAllocationStrategy_;
@@ -512,6 +523,17 @@ void CreateAutoProvisioningGroupRequest::setLaunchConfigurationTag(const std::ve
 	}
 }
 
+std::string CreateAutoProvisioningGroupRequest::getLaunchConfigurationDeploymentSetId()const
+{
+	return launchConfigurationDeploymentSetId_;
+}
+
+void CreateAutoProvisioningGroupRequest::setLaunchConfigurationDeploymentSetId(const std::string& launchConfigurationDeploymentSetId)
+{
+	launchConfigurationDeploymentSetId_ = launchConfigurationDeploymentSetId;
+	setParameter("LaunchConfigurationDeploymentSetId", launchConfigurationDeploymentSetId);
+}
+
 std::string CreateAutoProvisioningGroupRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;

ecs/src/model/CreateCapacityReservationRequest.cc

@@ -82,6 +82,17 @@ void CreateCapacityReservationRequest::setPlatform(const std::string& platform)
 	setParameter("Platform", platform);
 }
 
+std::string CreateCapacityReservationRequest::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+void CreateCapacityReservationRequest::setResourceGroupId(const std::string& resourceGroupId)
+{
+	resourceGroupId_ = resourceGroupId;
+	setParameter("ResourceGroupId", resourceGroupId);
+}
+
 std::string CreateCapacityReservationRequest::getPrivatePoolOptionsMatchCriteria()const
 {
 	return privatePoolOptionsMatchCriteria_;
@@ -115,6 +126,22 @@ void CreateCapacityReservationRequest::setInstanceType(const std::string& instan
 	setParameter("InstanceType", instanceType);
 }
 
+std::vector<CreateCapacityReservationRequest::Tag> CreateCapacityReservationRequest::getTag()const
+{
+	return tag_;
+}
+
+void CreateCapacityReservationRequest::setTag(const std::vector<Tag>& tag)
+{
+	tag_ = tag;
+	for(int dep1 = 0; dep1!= tag.size(); dep1++) {
+		auto tagObj = tag.at(dep1);
+		std::string tagObjStr = "Tag." + std::to_string(dep1 + 1);
+		setParameter(tagObjStr + ".Key", tagObj.key);
+		setParameter(tagObjStr + ".Value", tagObj.value);
+	}
+}
+
 std::string CreateCapacityReservationRequest::getInstanceChargeType()const
 {
 	return instanceChargeType_;

ecs/src/model/CreateElasticityAssuranceRequest.cc

@@ -82,6 +82,17 @@ void CreateElasticityAssuranceRequest::setPlatform(const std::string& platform)
 	setParameter("Platform", platform);
 }
 
+std::string CreateElasticityAssuranceRequest::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+void CreateElasticityAssuranceRequest::setResourceGroupId(const std::string& resourceGroupId)
+{
+	resourceGroupId_ = resourceGroupId;
+	setParameter("ResourceGroupId", resourceGroupId);
+}
+
 std::string CreateElasticityAssuranceRequest::getPrivatePoolOptionsMatchCriteria()const
 {
 	return privatePoolOptionsMatchCriteria_;
@@ -117,6 +128,22 @@ void CreateElasticityAssuranceRequest::setInstanceType(const std::vector<std::st
 	}
 }
 
+std::vector<CreateElasticityAssuranceRequest::Tag> CreateElasticityAssuranceRequest::getTag()const
+{
+	return tag_;
+}
+
+void CreateElasticityAssuranceRequest::setTag(const std::vector<Tag>& tag)
+{
+	tag_ = tag;
+	for(int dep1 = 0; dep1!= tag.size(); dep1++) {
+		auto tagObj = tag.at(dep1);
+		std::string tagObjStr = "Tag." + std::to_string(dep1 + 1);
+		setParameter(tagObjStr + ".Key", tagObj.key);
+		setParameter(tagObjStr + ".Value", tagObj.value);
+	}
+}
+
 std::string CreateElasticityAssuranceRequest::getInstanceChargeType()const
 {
 	return instanceChargeType_;

ecs/src/model/CreateInstanceRequest.cc

@@ -461,6 +461,17 @@ void CreateInstanceRequest::setInternetMaxBandwidthOut(int internetMaxBandwidthO
 	setParameter("InternetMaxBandwidthOut", std::to_string(internetMaxBandwidthOut));
 }
 
+bool CreateInstanceRequest::getHibernationOptionsConfigured()const
+{
+	return hibernationOptionsConfigured_;
+}
+
+void CreateInstanceRequest::setHibernationOptionsConfigured(bool hibernationOptionsConfigured)
+{
+	hibernationOptionsConfigured_ = hibernationOptionsConfigured;
+	setParameter("HibernationOptionsConfigured", hibernationOptionsConfigured ? "true" : "false");
+}
+
 std::string CreateInstanceRequest::getDescription()const
 {
 	return description_;

ecs/src/model/DescribeCapacityReservationsRequest.cc

@@ -49,6 +49,17 @@ void DescribeCapacityReservationsRequest::setPlatform(const std::string& platfor
 	setParameter("Platform", platform);
 }
 
+std::string DescribeCapacityReservationsRequest::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+void DescribeCapacityReservationsRequest::setResourceGroupId(const std::string& resourceGroupId)
+{
+	resourceGroupId_ = resourceGroupId;
+	setParameter("ResourceGroupId", resourceGroupId);
+}
+
 std::string DescribeCapacityReservationsRequest::getRegionId()const
 {
 	return regionId_;
@@ -82,6 +93,22 @@ void DescribeCapacityReservationsRequest::setInstanceType(const std::string& ins
 	setParameter("InstanceType", instanceType);
 }
 
+std::vector<DescribeCapacityReservationsRequest::Tag> DescribeCapacityReservationsRequest::getTag()const
+{
+	return tag_;
+}
+
+void DescribeCapacityReservationsRequest::setTag(const std::vector<Tag>& tag)
+{
+	tag_ = tag;
+	for(int dep1 = 0; dep1!= tag.size(); dep1++) {
+		auto tagObj = tag.at(dep1);
+		std::string tagObjStr = "Tag." + std::to_string(dep1 + 1);
+		setParameter(tagObjStr + ".Key", tagObj.key);
+		setParameter(tagObjStr + ".Value", tagObj.value);
+	}
+}
+
 std::string DescribeCapacityReservationsRequest::getInstanceChargeType()const
 {
 	return instanceChargeType_;

ecs/src/model/DescribeCapacityReservationsResult.cc

@@ -67,6 +67,8 @@ void DescribeCapacityReservationsResult::parse(const std::string &payload)
 			capacityReservationSetObject.platform = valueCapacityReservationSetCapacityReservationItem["Platform"].asString();
 		if(!valueCapacityReservationSetCapacityReservationItem["TimeSlot"].isNull())
 			capacityReservationSetObject.timeSlot = valueCapacityReservationSetCapacityReservationItem["TimeSlot"].asString();
+		if(!valueCapacityReservationSetCapacityReservationItem["ResourceGroupId"].isNull())
+			capacityReservationSetObject.resourceGroupId = valueCapacityReservationSetCapacityReservationItem["ResourceGroupId"].asString();
 		auto allAllocatedResourcesNode = valueCapacityReservationSetCapacityReservationItem["AllocatedResources"]["AllocatedResource"];
 		for (auto valueCapacityReservationSetCapacityReservationItemAllocatedResourcesAllocatedResource : allAllocatedResourcesNode)
 		{
@@ -81,6 +83,16 @@ void DescribeCapacityReservationsResult::parse(const std::string &payload)
 				allocatedResourcesObject.usedAmount = std::stoi(valueCapacityReservationSetCapacityReservationItemAllocatedResourcesAllocatedResource["UsedAmount"].asString());
 			capacityReservationSetObject.allocatedResources.push_back(allocatedResourcesObject);
 		}
+		auto allTagsNode = valueCapacityReservationSetCapacityReservationItem["Tags"]["Tag"];
+		for (auto valueCapacityReservationSetCapacityReservationItemTagsTag : allTagsNode)
+		{
+			CapacityReservationItem::Tag tagsObject;
+			if(!valueCapacityReservationSetCapacityReservationItemTagsTag["TagKey"].isNull())
+				tagsObject.tagKey = valueCapacityReservationSetCapacityReservationItemTagsTag["TagKey"].asString();
+			if(!valueCapacityReservationSetCapacityReservationItemTagsTag["TagValue"].isNull())
+				tagsObject.tagValue = valueCapacityReservationSetCapacityReservationItemTagsTag["TagValue"].asString();
+			capacityReservationSetObject.tags.push_back(tagsObject);
+		}
 		capacityReservationSet_.push_back(capacityReservationSetObject);
 	}
 	if(!value["NextToken"].isNull())

ecs/src/model/DescribeCloudAssistantStatusRequest.cc

@@ -38,6 +38,17 @@ void DescribeCloudAssistantStatusRequest::setResourceOwnerId(long resourceOwnerI
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+long DescribeCloudAssistantStatusRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeCloudAssistantStatusRequest::setPageNumber(long pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
 std::string DescribeCloudAssistantStatusRequest::getRegionId()const
 {
 	return regionId_;
@@ -49,6 +60,17 @@ void DescribeCloudAssistantStatusRequest::setRegionId(const std::string& regionI
 	setParameter("RegionId", regionId);
 }
 
+long DescribeCloudAssistantStatusRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeCloudAssistantStatusRequest::setPageSize(long pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
 std::string DescribeCloudAssistantStatusRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -71,6 +93,17 @@ void DescribeCloudAssistantStatusRequest::setOwnerAccount(const std::string& own
 	setParameter("OwnerAccount", ownerAccount);
 }
 
+std::string DescribeCloudAssistantStatusRequest::getOSType()const
+{
+	return oSType_;
+}
+
+void DescribeCloudAssistantStatusRequest::setOSType(const std::string& oSType)
+{
+	oSType_ = oSType;
+	setParameter("OSType", oSType);
+}
+
 long DescribeCloudAssistantStatusRequest::getOwnerId()const
 {
 	return ownerId_;

ecs/src/model/DescribeCloudAssistantStatusResult.cc

@@ -45,17 +45,46 @@ void DescribeCloudAssistantStatusResult::parse(const std::string &payload)
 		InstanceCloudAssistantStatus instanceCloudAssistantStatusSetObject;
 		if(!valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["InstanceId"].isNull())
 			instanceCloudAssistantStatusSetObject.instanceId = valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["InstanceId"].asString();
+		if(!valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["OSType"].isNull())
+			instanceCloudAssistantStatusSetObject.oSType = valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["OSType"].asString();
 		if(!valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["CloudAssistantStatus"].isNull())
 			instanceCloudAssistantStatusSetObject.cloudAssistantStatus = valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["CloudAssistantStatus"].asString();
 		if(!valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["CloudAssistantVersion"].isNull())
 			instanceCloudAssistantStatusSetObject.cloudAssistantVersion = valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["CloudAssistantVersion"].asString();
+		if(!valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["InvocationCount"].isNull())
+			instanceCloudAssistantStatusSetObject.invocationCount = std::stol(valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["InvocationCount"].asString());
+		if(!valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["ActiveTaskCount"].isNull())
+			instanceCloudAssistantStatusSetObject.activeTaskCount = std::stol(valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["ActiveTaskCount"].asString());
+		if(!valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["LastInvokedTime"].isNull())
+			instanceCloudAssistantStatusSetObject.lastInvokedTime = valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["LastInvokedTime"].asString();
 		instanceCloudAssistantStatusSet_.push_back(instanceCloudAssistantStatusSetObject);
 	}
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stol(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stol(value["PageSize"].asString());
 
 }
 
+long DescribeCloudAssistantStatusResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+long DescribeCloudAssistantStatusResult::getPageSize()const
+{
+	return pageSize_;
+}
+
 std::vector<DescribeCloudAssistantStatusResult::InstanceCloudAssistantStatus> DescribeCloudAssistantStatusResult::getInstanceCloudAssistantStatusSet()const
 {
 	return instanceCloudAssistantStatusSet_;
 }
 
+long DescribeCloudAssistantStatusResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

ecs/src/model/DescribeElasticityAssurancesRequest.cc

@@ -49,6 +49,17 @@ void DescribeElasticityAssurancesRequest::setPlatform(const std::string& platfor
 	setParameter("Platform", platform);
 }
 
+std::string DescribeElasticityAssurancesRequest::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+void DescribeElasticityAssurancesRequest::setResourceGroupId(const std::string& resourceGroupId)
+{
+	resourceGroupId_ = resourceGroupId;
+	setParameter("ResourceGroupId", resourceGroupId);
+}
+
 std::string DescribeElasticityAssurancesRequest::getRegionId()const
 {
 	return regionId_;
@@ -82,6 +93,22 @@ void DescribeElasticityAssurancesRequest::setInstanceType(const std::string& ins
 	setParameter("InstanceType", instanceType);
 }
 
+std::vector<DescribeElasticityAssurancesRequest::Tag> DescribeElasticityAssurancesRequest::getTag()const
+{
+	return tag_;
+}
+
+void DescribeElasticityAssurancesRequest::setTag(const std::vector<Tag>& tag)
+{
+	tag_ = tag;
+	for(int dep1 = 0; dep1!= tag.size(); dep1++) {
+		auto tagObj = tag.at(dep1);
+		std::string tagObjStr = "Tag." + std::to_string(dep1 + 1);
+		setParameter(tagObjStr + ".Key", tagObj.key);
+		setParameter(tagObjStr + ".Value", tagObj.value);
+	}
+}
+
 std::string DescribeElasticityAssurancesRequest::getInstanceChargeType()const
 {
 	return instanceChargeType_;

ecs/src/model/DescribeElasticityAssurancesResult.cc

@@ -65,6 +65,8 @@ void DescribeElasticityAssurancesResult::parse(const std::string &payload)
 			elasticityAssuranceSetObject.endTime = valueElasticityAssuranceSetElasticityAssuranceItem["EndTime"].asString();
 		if(!valueElasticityAssuranceSetElasticityAssuranceItem["LatestStartTime"].isNull())
 			elasticityAssuranceSetObject.latestStartTime = valueElasticityAssuranceSetElasticityAssuranceItem["LatestStartTime"].asString();
+		if(!valueElasticityAssuranceSetElasticityAssuranceItem["ResourceGroupId"].isNull())
+			elasticityAssuranceSetObject.resourceGroupId = valueElasticityAssuranceSetElasticityAssuranceItem["ResourceGroupId"].asString();
 		auto allAllocatedResourcesNode = valueElasticityAssuranceSetElasticityAssuranceItem["AllocatedResources"]["AllocatedResource"];
 		for (auto valueElasticityAssuranceSetElasticityAssuranceItemAllocatedResourcesAllocatedResource : allAllocatedResourcesNode)
 		{
@@ -79,6 +81,16 @@ void DescribeElasticityAssurancesResult::parse(const std::string &payload)
 				allocatedResourcesObject.usedAmount = std::stoi(valueElasticityAssuranceSetElasticityAssuranceItemAllocatedResourcesAllocatedResource["UsedAmount"].asString());
 			elasticityAssuranceSetObject.allocatedResources.push_back(allocatedResourcesObject);
 		}
+		auto allTagsNode = valueElasticityAssuranceSetElasticityAssuranceItem["Tags"]["Tag"];
+		for (auto valueElasticityAssuranceSetElasticityAssuranceItemTagsTag : allTagsNode)
+		{
+			ElasticityAssuranceItem::Tag tagsObject;
+			if(!valueElasticityAssuranceSetElasticityAssuranceItemTagsTag["TagKey"].isNull())
+				tagsObject.tagKey = valueElasticityAssuranceSetElasticityAssuranceItemTagsTag["TagKey"].asString();
+			if(!valueElasticityAssuranceSetElasticityAssuranceItemTagsTag["TagValue"].isNull())
+				tagsObject.tagValue = valueElasticityAssuranceSetElasticityAssuranceItemTagsTag["TagValue"].asString();
+			elasticityAssuranceSetObject.tags.push_back(tagsObject);
+		}
 		elasticityAssuranceSet_.push_back(elasticityAssuranceSetObject);
 	}
 	if(!value["NextToken"].isNull())

ecs/src/model/DescribeInstanceModificationPriceRequest.cc

@@ -0,0 +1,134 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecs/model/DescribeInstanceModificationPriceRequest.h>
+
+using AlibabaCloud::Ecs::Model::DescribeInstanceModificationPriceRequest;
+
+DescribeInstanceModificationPriceRequest::DescribeInstanceModificationPriceRequest() :
+	RpcServiceRequest("ecs", "2014-05-26", "DescribeInstanceModificationPrice")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeInstanceModificationPriceRequest::~DescribeInstanceModificationPriceRequest()
+{}
+
+long DescribeInstanceModificationPriceRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeInstanceModificationPriceRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeInstanceModificationPriceRequest::getSystemDiskCategory()const
+{
+	return systemDiskCategory_;
+}
+
+void DescribeInstanceModificationPriceRequest::setSystemDiskCategory(const std::string& systemDiskCategory)
+{
+	systemDiskCategory_ = systemDiskCategory;
+	setParameter("SystemDiskCategory", systemDiskCategory);
+}
+
+std::string DescribeInstanceModificationPriceRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeInstanceModificationPriceRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DescribeInstanceModificationPriceRequest::getInstanceType()const
+{
+	return instanceType_;
+}
+
+void DescribeInstanceModificationPriceRequest::setInstanceType(const std::string& instanceType)
+{
+	instanceType_ = instanceType;
+	setParameter("InstanceType", instanceType);
+}
+
+std::string DescribeInstanceModificationPriceRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeInstanceModificationPriceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeInstanceModificationPriceRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeInstanceModificationPriceRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DescribeInstanceModificationPriceRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeInstanceModificationPriceRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::vector<DescribeInstanceModificationPriceRequest::DataDisk> DescribeInstanceModificationPriceRequest::getDataDisk()const
+{
+	return dataDisk_;
+}
+
+void DescribeInstanceModificationPriceRequest::setDataDisk(const std::vector<DataDisk>& dataDisk)
+{
+	dataDisk_ = dataDisk;
+	for(int dep1 = 0; dep1!= dataDisk.size(); dep1++) {
+		auto dataDiskObj = dataDisk.at(dep1);
+		std::string dataDiskObjStr = "DataDisk." + std::to_string(dep1 + 1);
+		setParameter(dataDiskObjStr + ".Size", std::to_string(dataDiskObj.size));
+		setParameter(dataDiskObjStr + ".Category", dataDiskObj.category);
+		setParameter(dataDiskObjStr + ".PerformanceLevel", dataDiskObj.performanceLevel);
+	}
+}
+
+std::string DescribeInstanceModificationPriceRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void DescribeInstanceModificationPriceRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+

ecs/src/model/DescribeInstanceModificationPriceResult.cc

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecs/model/DescribeInstanceModificationPriceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecs;
+using namespace AlibabaCloud::Ecs::Model;
+
+DescribeInstanceModificationPriceResult::DescribeInstanceModificationPriceResult() :
+	ServiceResult()
+{}
+
+DescribeInstanceModificationPriceResult::DescribeInstanceModificationPriceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeInstanceModificationPriceResult::~DescribeInstanceModificationPriceResult()
+{}
+
+void DescribeInstanceModificationPriceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto priceInfoNode = value["PriceInfo"];
+	auto allRulesNode = priceInfoNode["Rules"]["Rule"];
+	for (auto priceInfoNodeRulesRule : allRulesNode)
+	{
+		PriceInfo::Rule ruleObject;
+		if(!priceInfoNodeRulesRule["RuleId"].isNull())
+			ruleObject.ruleId = std::stol(priceInfoNodeRulesRule["RuleId"].asString());
+		if(!priceInfoNodeRulesRule["Description"].isNull())
+			ruleObject.description = priceInfoNodeRulesRule["Description"].asString();
+		priceInfo_.rules.push_back(ruleObject);
+	}
+	auto priceNode = priceInfoNode["Price"];
+	if(!priceNode["OriginalPrice"].isNull())
+		priceInfo_.price.originalPrice = std::stof(priceNode["OriginalPrice"].asString());
+	if(!priceNode["DiscountPrice"].isNull())
+		priceInfo_.price.discountPrice = std::stof(priceNode["DiscountPrice"].asString());
+	if(!priceNode["TradePrice"].isNull())
+		priceInfo_.price.tradePrice = std::stof(priceNode["TradePrice"].asString());
+	if(!priceNode["Currency"].isNull())
+		priceInfo_.price.currency = priceNode["Currency"].asString();
+
+}
+
+DescribeInstanceModificationPriceResult::PriceInfo DescribeInstanceModificationPriceResult::getPriceInfo()const
+{
+	return priceInfo_;
+}
+

ecs/src/model/DescribeInstanceTypesResult.cc

@@ -93,6 +93,8 @@ void DescribeInstanceTypesResult::parse(const std::string &payload)
 			instanceTypesObject.primaryEniQueueNumber = std::stoi(valueInstanceTypesInstanceType["PrimaryEniQueueNumber"].asString());
 		if(!valueInstanceTypesInstanceType["SecondaryEniQueueNumber"].isNull())
 			instanceTypesObject.secondaryEniQueueNumber = std::stoi(valueInstanceTypesInstanceType["SecondaryEniQueueNumber"].asString());
+		if(!valueInstanceTypesInstanceType["DiskQuantity"].isNull())
+			instanceTypesObject.diskQuantity = std::stoi(valueInstanceTypesInstanceType["DiskQuantity"].asString());
 		instanceTypes_.push_back(instanceTypesObject);
 	}
 

ecs/src/model/DescribeInstancesResult.cc

@@ -210,6 +210,9 @@ void DescribeInstancesResult::parse(const std::string &payload)
 			instancesObject.eipAddress.internetChargeType = eipAddressNode["InternetChargeType"].asString();
 		if(!eipAddressNode["IsSupportUnassociate"].isNull())
 			instancesObject.eipAddress.isSupportUnassociate = eipAddressNode["IsSupportUnassociate"].asString() == "true";
+		auto hibernationOptionsNode = value["HibernationOptions"];
+		if(!hibernationOptionsNode["Configured"].isNull())
+			instancesObject.hibernationOptions.configured = hibernationOptionsNode["Configured"].asString() == "true";
 		auto dedicatedHostAttributeNode = value["DedicatedHostAttribute"];
 		if(!dedicatedHostAttributeNode["DedicatedHostId"].isNull())
 			instancesObject.dedicatedHostAttribute.dedicatedHostId = dedicatedHostAttributeNode["DedicatedHostId"].asString();

ecs/src/model/DescribePriceRequest.cc

@@ -337,6 +337,17 @@ void DescribePriceRequest::setInstanceType(const std::string& instanceType)
 	setParameter("InstanceType", instanceType);
 }
 
+std::string DescribePriceRequest::getDedicatedHostType()const
+{
+	return dedicatedHostType_;
+}
+
+void DescribePriceRequest::setDedicatedHostType(const std::string& dedicatedHostType)
+{
+	dedicatedHostType_ = dedicatedHostType;
+	setParameter("DedicatedHostType", dedicatedHostType);
+}
+
 std::string DescribePriceRequest::getDataDisk2Category()const
 {
 	return dataDisk2Category_;

ecs/src/model/DescribeRenewalPriceRequest.cc

@@ -104,6 +104,17 @@ void DescribeRenewalPriceRequest::setOwnerAccount(const std::string& ownerAccoun
 	setParameter("OwnerAccount", ownerAccount);
 }
 
+int DescribeRenewalPriceRequest::getExpectedRenewDay()const
+{
+	return expectedRenewDay_;
+}
+
+void DescribeRenewalPriceRequest::setExpectedRenewDay(int expectedRenewDay)
+{
+	expectedRenewDay_ = expectedRenewDay;
+	setParameter("ExpectedRenewDay", std::to_string(expectedRenewDay));
+}
+
 long DescribeRenewalPriceRequest::getOwnerId()const
 {
 	return ownerId_;

ecs/src/model/DescribeSnapshotGroupsRequest.cc

@@ -106,6 +106,19 @@ void DescribeSnapshotGroupsRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
+std::vector<std::string> DescribeSnapshotGroupsRequest::getAdditionalAttributes()const
+{
+	return additionalAttributes_;
+}
+
+void DescribeSnapshotGroupsRequest::setAdditionalAttributes(const std::vector<std::string>& additionalAttributes)
+{
+	additionalAttributes_ = additionalAttributes;
+	for(int dep1 = 0; dep1!= additionalAttributes.size(); dep1++) {
+		setParameter("AdditionalAttributes."+ std::to_string(dep1), additionalAttributes.at(dep1));
+	}
+}
+
 std::string DescribeSnapshotGroupsRequest::getInstanceId()const
 {
 	return instanceId_;

ecs/src/model/DescribeSnapshotGroupsResult.cc

@@ -55,6 +55,8 @@ void DescribeSnapshotGroupsResult::parse(const std::string &payload)
 			snapshotGroupsObject.description = valueSnapshotGroupsSnapshotGroup["Description"].asString();
 		if(!valueSnapshotGroupsSnapshotGroup["CreationTime"].isNull())
 			snapshotGroupsObject.creationTime = valueSnapshotGroupsSnapshotGroup["CreationTime"].asString();
+		if(!valueSnapshotGroupsSnapshotGroup["ProgressStatus"].isNull())
+			snapshotGroupsObject.progressStatus = valueSnapshotGroupsSnapshotGroup["ProgressStatus"].asString();
 		auto allSnapshotsNode = valueSnapshotGroupsSnapshotGroup["Snapshots"]["Snapshot"];
 		for (auto valueSnapshotGroupsSnapshotGroupSnapshotsSnapshot : allSnapshotsNode)
 		{

ecs/src/model/RenewInstanceRequest.cc

@@ -82,6 +82,17 @@ void RenewInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
 	setParameter("OwnerAccount", ownerAccount);
 }
 
+int RenewInstanceRequest::getExpectedRenewDay()const
+{
+	return expectedRenewDay_;
+}
+
+void RenewInstanceRequest::setExpectedRenewDay(int expectedRenewDay)
+{
+	expectedRenewDay_ = expectedRenewDay;
+	setParameter("ExpectedRenewDay", std::to_string(expectedRenewDay));
+}
+
 long RenewInstanceRequest::getOwnerId()const
 {
 	return ownerId_;

ecs/src/model/RunInstancesRequest.cc

@@ -324,6 +324,17 @@ void RunInstancesRequest::setSecurityGroupId(const std::string& securityGroupId)
 	setParameter("SecurityGroupId", securityGroupId);
 }
 
+bool RunInstancesRequest::getHibernationOptionsConfigured()const
+{
+	return hibernationOptionsConfigured_;
+}
+
+void RunInstancesRequest::setHibernationOptionsConfigured(bool hibernationOptionsConfigured)
+{
+	hibernationOptionsConfigured_ = hibernationOptionsConfigured;
+	setParameter("HibernationOptionsConfigured", hibernationOptionsConfigured ? "true" : "false");
+}
+
 std::string RunInstancesRequest::getSystemDiskPerformanceLevel()const
 {
 	return systemDiskPerformanceLevel_;
@@ -357,17 +368,6 @@ void RunInstancesRequest::setInstanceType(const std::string& instanceType)
 	setParameter("InstanceType", instanceType);
 }
 
-bool RunInstancesRequest::getHibernationConfigured()const
-{
-	return hibernationConfigured_;
-}
-
-void RunInstancesRequest::setHibernationConfigured(bool hibernationConfigured)
-{
-	hibernationConfigured_ = hibernationConfigured;
-	setParameter("HibernationConfigured", hibernationConfigured ? "true" : "false");
-}
-
 std::vector<RunInstancesRequest::Arn> RunInstancesRequest::getArn()const
 {
 	return arn_;
@@ -385,17 +385,6 @@ void RunInstancesRequest::setArn(const std::vector<Arn>& arn)
 	}
 }
 
-std::string RunInstancesRequest::getSchedulerOptions()const
-{
-	return schedulerOptions_;
-}
-
-void RunInstancesRequest::setSchedulerOptions(const std::string& schedulerOptions)
-{
-	schedulerOptions_ = schedulerOptions;
-	setParameter("SchedulerOptions", schedulerOptions);
-}
-
 std::string RunInstancesRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -634,6 +623,19 @@ void RunInstancesRequest::setIpv6AddressCount(int ipv6AddressCount)
 	setParameter("Ipv6AddressCount", std::to_string(ipv6AddressCount));
 }
 
+std::vector<std::string> RunInstancesRequest::getHostNames()const
+{
+	return hostNames_;
+}
+
+void RunInstancesRequest::setHostNames(const std::vector<std::string>& hostNames)
+{
+	hostNames_ = hostNames;
+	for(int dep1 = 0; dep1!= hostNames.size(); dep1++) {
+		setParameter("HostNames."+ std::to_string(dep1), hostNames.at(dep1));
+	}
+}
+
 std::string RunInstancesRequest::getCapacityReservationPreference()const
 {
 	return capacityReservationPreference_;
@@ -746,6 +748,17 @@ void RunInstancesRequest::setSystemDiskCategory(const std::string& systemDiskCat
 	setParameter("SystemDiskCategory", systemDiskCategory);
 }
 
+std::string RunInstancesRequest::getSecurityOptionsTrustedSystemMode()const
+{
+	return securityOptionsTrustedSystemMode_;
+}
+
+void RunInstancesRequest::setSecurityOptionsTrustedSystemMode(const std::string& securityOptionsTrustedSystemMode)
+{
+	securityOptionsTrustedSystemMode_ = securityOptionsTrustedSystemMode;
+	setParameter("SecurityOptionsTrustedSystemMode", securityOptionsTrustedSystemMode);
+}
+
 std::string RunInstancesRequest::getCapacityReservationId()const
 {
 	return capacityReservationId_;

ecs/src/model/RunInstancesResult.cc

@@ -44,6 +44,8 @@ void RunInstancesResult::parse(const std::string &payload)
 		instanceIdSets_.push_back(item.asString());
 	if(!value["TradePrice"].isNull())
 		tradePrice_ = std::stof(value["TradePrice"].asString());
+	if(!value["OrderId"].isNull())
+		orderId_ = value["OrderId"].asString();
 
 }
 
@@ -57,3 +59,8 @@ float RunInstancesResult::getTradePrice()const
 	return tradePrice_;
 }
 
+std::string RunInstancesResult::getOrderId()const
+{
+	return orderId_;
+}
+