AcceptInquiredSystemEvent adds Choice parameter.

CHANGELOG

@@ -1,3 +1,7 @@
+2021-04-22 Version: 1.36.696
+- AcceptInquiredSystemEvent adds Choice parameter.
+- DescribeInstanceHistoryEvents supports multiple resource types.
+
 2021-04-22 Version: 1.36.695
 - Support CEN latest Apis.
 

VERSION

@@ -1 +1 @@
-1.36.695
+1.36.696

ecs/CMakeLists.txt

@@ -89,6 +89,8 @@ set(ecs_public_header_model
 	include/alibabacloud/ecs/model/CreateCapacityReservationResult.h
 	include/alibabacloud/ecs/model/CreateCommandRequest.h
 	include/alibabacloud/ecs/model/CreateCommandResult.h
+	include/alibabacloud/ecs/model/CreateDedicatedBlockStorageClusterRequest.h
+	include/alibabacloud/ecs/model/CreateDedicatedBlockStorageClusterResult.h
 	include/alibabacloud/ecs/model/CreateDedicatedHostClusterRequest.h
 	include/alibabacloud/ecs/model/CreateDedicatedHostClusterResult.h
 	include/alibabacloud/ecs/model/CreateDemandRequest.h
@@ -97,6 +99,8 @@ set(ecs_public_header_model
 	include/alibabacloud/ecs/model/CreateDeploymentSetResult.h
 	include/alibabacloud/ecs/model/CreateDiskRequest.h
 	include/alibabacloud/ecs/model/CreateDiskResult.h
+	include/alibabacloud/ecs/model/CreateDiskReplicaPairRequest.h
+	include/alibabacloud/ecs/model/CreateDiskReplicaPairResult.h
 	include/alibabacloud/ecs/model/CreateElasticityAssuranceRequest.h
 	include/alibabacloud/ecs/model/CreateElasticityAssuranceResult.h
 	include/alibabacloud/ecs/model/CreateForwardEntryRequest.h
@@ -167,6 +171,8 @@ set(ecs_public_header_model
 	include/alibabacloud/ecs/model/DeleteDeploymentSetResult.h
 	include/alibabacloud/ecs/model/DeleteDiskRequest.h
 	include/alibabacloud/ecs/model/DeleteDiskResult.h
+	include/alibabacloud/ecs/model/DeleteDiskReplicaPairRequest.h
+	include/alibabacloud/ecs/model/DeleteDiskReplicaPairResult.h
 	include/alibabacloud/ecs/model/DeleteForwardEntryRequest.h
 	include/alibabacloud/ecs/model/DeleteForwardEntryResult.h
 	include/alibabacloud/ecs/model/DeleteHaVipRequest.h
@@ -249,6 +255,8 @@ set(ecs_public_header_model
 	include/alibabacloud/ecs/model/DescribeClustersResult.h
 	include/alibabacloud/ecs/model/DescribeCommandsRequest.h
 	include/alibabacloud/ecs/model/DescribeCommandsResult.h
+	include/alibabacloud/ecs/model/DescribeDedicatedBlockStorageClustersRequest.h
+	include/alibabacloud/ecs/model/DescribeDedicatedBlockStorageClustersResult.h
 	include/alibabacloud/ecs/model/DescribeDedicatedHostAutoRenewRequest.h
 	include/alibabacloud/ecs/model/DescribeDedicatedHostAutoRenewResult.h
 	include/alibabacloud/ecs/model/DescribeDedicatedHostClustersRequest.h
@@ -265,6 +273,8 @@ set(ecs_public_header_model
 	include/alibabacloud/ecs/model/DescribeDeploymentSetsResult.h
 	include/alibabacloud/ecs/model/DescribeDiskMonitorDataRequest.h
 	include/alibabacloud/ecs/model/DescribeDiskMonitorDataResult.h
+	include/alibabacloud/ecs/model/DescribeDiskReplicaPairsRequest.h
+	include/alibabacloud/ecs/model/DescribeDiskReplicaPairsResult.h
 	include/alibabacloud/ecs/model/DescribeDisksRequest.h
 	include/alibabacloud/ecs/model/DescribeDisksResult.h
 	include/alibabacloud/ecs/model/DescribeDisksFullStatusRequest.h
@@ -643,6 +653,8 @@ set(ecs_public_header_model
 	include/alibabacloud/ecs/model/RunInstancesResult.h
 	include/alibabacloud/ecs/model/SendFileRequest.h
 	include/alibabacloud/ecs/model/SendFileResult.h
+	include/alibabacloud/ecs/model/StartDiskReplicaPairRequest.h
+	include/alibabacloud/ecs/model/StartDiskReplicaPairResult.h
 	include/alibabacloud/ecs/model/StartElasticityAssuranceRequest.h
 	include/alibabacloud/ecs/model/StartElasticityAssuranceResult.h
 	include/alibabacloud/ecs/model/StartImagePipelineExecutionRequest.h
@@ -651,6 +663,8 @@ set(ecs_public_header_model
 	include/alibabacloud/ecs/model/StartInstanceResult.h
 	include/alibabacloud/ecs/model/StartInstancesRequest.h
 	include/alibabacloud/ecs/model/StartInstancesResult.h
+	include/alibabacloud/ecs/model/StopDiskReplicaPairRequest.h
+	include/alibabacloud/ecs/model/StopDiskReplicaPairResult.h
 	include/alibabacloud/ecs/model/StopInstanceRequest.h
 	include/alibabacloud/ecs/model/StopInstanceResult.h
 	include/alibabacloud/ecs/model/StopInstancesRequest.h
@@ -744,6 +758,8 @@ set(ecs_src
 	src/model/CreateCapacityReservationResult.cc
 	src/model/CreateCommandRequest.cc
 	src/model/CreateCommandResult.cc
+	src/model/CreateDedicatedBlockStorageClusterRequest.cc
+	src/model/CreateDedicatedBlockStorageClusterResult.cc
 	src/model/CreateDedicatedHostClusterRequest.cc
 	src/model/CreateDedicatedHostClusterResult.cc
 	src/model/CreateDemandRequest.cc
@@ -752,6 +768,8 @@ set(ecs_src
 	src/model/CreateDeploymentSetResult.cc
 	src/model/CreateDiskRequest.cc
 	src/model/CreateDiskResult.cc
+	src/model/CreateDiskReplicaPairRequest.cc
+	src/model/CreateDiskReplicaPairResult.cc
 	src/model/CreateElasticityAssuranceRequest.cc
 	src/model/CreateElasticityAssuranceResult.cc
 	src/model/CreateForwardEntryRequest.cc
@@ -822,6 +840,8 @@ set(ecs_src
 	src/model/DeleteDeploymentSetResult.cc
 	src/model/DeleteDiskRequest.cc
 	src/model/DeleteDiskResult.cc
+	src/model/DeleteDiskReplicaPairRequest.cc
+	src/model/DeleteDiskReplicaPairResult.cc
 	src/model/DeleteForwardEntryRequest.cc
 	src/model/DeleteForwardEntryResult.cc
 	src/model/DeleteHaVipRequest.cc
@@ -904,6 +924,8 @@ set(ecs_src
 	src/model/DescribeClustersResult.cc
 	src/model/DescribeCommandsRequest.cc
 	src/model/DescribeCommandsResult.cc
+	src/model/DescribeDedicatedBlockStorageClustersRequest.cc
+	src/model/DescribeDedicatedBlockStorageClustersResult.cc
 	src/model/DescribeDedicatedHostAutoRenewRequest.cc
 	src/model/DescribeDedicatedHostAutoRenewResult.cc
 	src/model/DescribeDedicatedHostClustersRequest.cc
@@ -920,6 +942,8 @@ set(ecs_src
 	src/model/DescribeDeploymentSetsResult.cc
 	src/model/DescribeDiskMonitorDataRequest.cc
 	src/model/DescribeDiskMonitorDataResult.cc
+	src/model/DescribeDiskReplicaPairsRequest.cc
+	src/model/DescribeDiskReplicaPairsResult.cc
 	src/model/DescribeDisksRequest.cc
 	src/model/DescribeDisksResult.cc
 	src/model/DescribeDisksFullStatusRequest.cc
@@ -1298,6 +1322,8 @@ set(ecs_src
 	src/model/RunInstancesResult.cc
 	src/model/SendFileRequest.cc
 	src/model/SendFileResult.cc
+	src/model/StartDiskReplicaPairRequest.cc
+	src/model/StartDiskReplicaPairResult.cc
 	src/model/StartElasticityAssuranceRequest.cc
 	src/model/StartElasticityAssuranceResult.cc
 	src/model/StartImagePipelineExecutionRequest.cc
@@ -1306,6 +1332,8 @@ set(ecs_src
 	src/model/StartInstanceResult.cc
 	src/model/StartInstancesRequest.cc
 	src/model/StartInstancesResult.cc
+	src/model/StopDiskReplicaPairRequest.cc
+	src/model/StopDiskReplicaPairResult.cc
 	src/model/StopInstanceRequest.cc
 	src/model/StopInstanceResult.cc
 	src/model/StopInstancesRequest.cc

ecs/include/alibabacloud/ecs/EcsClient.h

@@ -90,6 +90,8 @@
 #include "model/CreateCapacityReservationResult.h"
 #include "model/CreateCommandRequest.h"
 #include "model/CreateCommandResult.h"
+#include "model/CreateDedicatedBlockStorageClusterRequest.h"
+#include "model/CreateDedicatedBlockStorageClusterResult.h"
 #include "model/CreateDedicatedHostClusterRequest.h"
 #include "model/CreateDedicatedHostClusterResult.h"
 #include "model/CreateDemandRequest.h"
@@ -98,6 +100,8 @@
 #include "model/CreateDeploymentSetResult.h"
 #include "model/CreateDiskRequest.h"
 #include "model/CreateDiskResult.h"
+#include "model/CreateDiskReplicaPairRequest.h"
+#include "model/CreateDiskReplicaPairResult.h"
 #include "model/CreateElasticityAssuranceRequest.h"
 #include "model/CreateElasticityAssuranceResult.h"
 #include "model/CreateForwardEntryRequest.h"
@@ -168,6 +172,8 @@
 #include "model/DeleteDeploymentSetResult.h"
 #include "model/DeleteDiskRequest.h"
 #include "model/DeleteDiskResult.h"
+#include "model/DeleteDiskReplicaPairRequest.h"
+#include "model/DeleteDiskReplicaPairResult.h"
 #include "model/DeleteForwardEntryRequest.h"
 #include "model/DeleteForwardEntryResult.h"
 #include "model/DeleteHaVipRequest.h"
@@ -250,6 +256,8 @@
 #include "model/DescribeClustersResult.h"
 #include "model/DescribeCommandsRequest.h"
 #include "model/DescribeCommandsResult.h"
+#include "model/DescribeDedicatedBlockStorageClustersRequest.h"
+#include "model/DescribeDedicatedBlockStorageClustersResult.h"
 #include "model/DescribeDedicatedHostAutoRenewRequest.h"
 #include "model/DescribeDedicatedHostAutoRenewResult.h"
 #include "model/DescribeDedicatedHostClustersRequest.h"
@@ -266,6 +274,8 @@
 #include "model/DescribeDeploymentSetsResult.h"
 #include "model/DescribeDiskMonitorDataRequest.h"
 #include "model/DescribeDiskMonitorDataResult.h"
+#include "model/DescribeDiskReplicaPairsRequest.h"
+#include "model/DescribeDiskReplicaPairsResult.h"
 #include "model/DescribeDisksRequest.h"
 #include "model/DescribeDisksResult.h"
 #include "model/DescribeDisksFullStatusRequest.h"
@@ -644,6 +654,8 @@
 #include "model/RunInstancesResult.h"
 #include "model/SendFileRequest.h"
 #include "model/SendFileResult.h"
+#include "model/StartDiskReplicaPairRequest.h"
+#include "model/StartDiskReplicaPairResult.h"
 #include "model/StartElasticityAssuranceRequest.h"
 #include "model/StartElasticityAssuranceResult.h"
 #include "model/StartImagePipelineExecutionRequest.h"
@@ -652,6 +664,8 @@
 #include "model/StartInstanceResult.h"
 #include "model/StartInstancesRequest.h"
 #include "model/StartInstancesResult.h"
+#include "model/StopDiskReplicaPairRequest.h"
+#include "model/StopDiskReplicaPairResult.h"
 #include "model/StopInstanceRequest.h"
 #include "model/StopInstanceResult.h"
 #include "model/StopInstancesRequest.h"
@@ -785,6 +799,9 @@ namespace AlibabaCloud
 			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;
+			typedef Outcome<Error, Model::CreateDedicatedBlockStorageClusterResult> CreateDedicatedBlockStorageClusterOutcome;
+			typedef std::future<CreateDedicatedBlockStorageClusterOutcome> CreateDedicatedBlockStorageClusterOutcomeCallable;
+			typedef std::function<void(const EcsClient*, const Model::CreateDedicatedBlockStorageClusterRequest&, const CreateDedicatedBlockStorageClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDedicatedBlockStorageClusterAsyncHandler;
 			typedef Outcome<Error, Model::CreateDedicatedHostClusterResult> CreateDedicatedHostClusterOutcome;
 			typedef std::future<CreateDedicatedHostClusterOutcome> CreateDedicatedHostClusterOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::CreateDedicatedHostClusterRequest&, const CreateDedicatedHostClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDedicatedHostClusterAsyncHandler;
@@ -797,6 +814,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateDiskResult> CreateDiskOutcome;
 			typedef std::future<CreateDiskOutcome> CreateDiskOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::CreateDiskRequest&, const CreateDiskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDiskAsyncHandler;
+			typedef Outcome<Error, Model::CreateDiskReplicaPairResult> CreateDiskReplicaPairOutcome;
+			typedef std::future<CreateDiskReplicaPairOutcome> CreateDiskReplicaPairOutcomeCallable;
+			typedef std::function<void(const EcsClient*, const Model::CreateDiskReplicaPairRequest&, const CreateDiskReplicaPairOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDiskReplicaPairAsyncHandler;
 			typedef Outcome<Error, Model::CreateElasticityAssuranceResult> CreateElasticityAssuranceOutcome;
 			typedef std::future<CreateElasticityAssuranceOutcome> CreateElasticityAssuranceOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::CreateElasticityAssuranceRequest&, const CreateElasticityAssuranceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateElasticityAssuranceAsyncHandler;
@@ -902,6 +922,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteDiskResult> DeleteDiskOutcome;
 			typedef std::future<DeleteDiskOutcome> DeleteDiskOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::DeleteDiskRequest&, const DeleteDiskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDiskAsyncHandler;
+			typedef Outcome<Error, Model::DeleteDiskReplicaPairResult> DeleteDiskReplicaPairOutcome;
+			typedef std::future<DeleteDiskReplicaPairOutcome> DeleteDiskReplicaPairOutcomeCallable;
+			typedef std::function<void(const EcsClient*, const Model::DeleteDiskReplicaPairRequest&, const DeleteDiskReplicaPairOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDiskReplicaPairAsyncHandler;
 			typedef Outcome<Error, Model::DeleteForwardEntryResult> DeleteForwardEntryOutcome;
 			typedef std::future<DeleteForwardEntryOutcome> DeleteForwardEntryOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::DeleteForwardEntryRequest&, const DeleteForwardEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteForwardEntryAsyncHandler;
@@ -1025,6 +1048,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeCommandsResult> DescribeCommandsOutcome;
 			typedef std::future<DescribeCommandsOutcome> DescribeCommandsOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::DescribeCommandsRequest&, const DescribeCommandsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCommandsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDedicatedBlockStorageClustersResult> DescribeDedicatedBlockStorageClustersOutcome;
+			typedef std::future<DescribeDedicatedBlockStorageClustersOutcome> DescribeDedicatedBlockStorageClustersOutcomeCallable;
+			typedef std::function<void(const EcsClient*, const Model::DescribeDedicatedBlockStorageClustersRequest&, const DescribeDedicatedBlockStorageClustersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDedicatedBlockStorageClustersAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDedicatedHostAutoRenewResult> DescribeDedicatedHostAutoRenewOutcome;
 			typedef std::future<DescribeDedicatedHostAutoRenewOutcome> DescribeDedicatedHostAutoRenewOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::DescribeDedicatedHostAutoRenewRequest&, const DescribeDedicatedHostAutoRenewOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDedicatedHostAutoRenewAsyncHandler;
@@ -1049,6 +1075,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeDiskMonitorDataResult> DescribeDiskMonitorDataOutcome;
 			typedef std::future<DescribeDiskMonitorDataOutcome> DescribeDiskMonitorDataOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::DescribeDiskMonitorDataRequest&, const DescribeDiskMonitorDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDiskMonitorDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDiskReplicaPairsResult> DescribeDiskReplicaPairsOutcome;
+			typedef std::future<DescribeDiskReplicaPairsOutcome> DescribeDiskReplicaPairsOutcomeCallable;
+			typedef std::function<void(const EcsClient*, const Model::DescribeDiskReplicaPairsRequest&, const DescribeDiskReplicaPairsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDiskReplicaPairsAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDisksResult> DescribeDisksOutcome;
 			typedef std::future<DescribeDisksOutcome> DescribeDisksOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::DescribeDisksRequest&, const DescribeDisksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDisksAsyncHandler;
@@ -1616,6 +1645,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::SendFileResult> SendFileOutcome;
 			typedef std::future<SendFileOutcome> SendFileOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::SendFileRequest&, const SendFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SendFileAsyncHandler;
+			typedef Outcome<Error, Model::StartDiskReplicaPairResult> StartDiskReplicaPairOutcome;
+			typedef std::future<StartDiskReplicaPairOutcome> StartDiskReplicaPairOutcomeCallable;
+			typedef std::function<void(const EcsClient*, const Model::StartDiskReplicaPairRequest&, const StartDiskReplicaPairOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartDiskReplicaPairAsyncHandler;
 			typedef Outcome<Error, Model::StartElasticityAssuranceResult> StartElasticityAssuranceOutcome;
 			typedef std::future<StartElasticityAssuranceOutcome> StartElasticityAssuranceOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::StartElasticityAssuranceRequest&, const StartElasticityAssuranceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartElasticityAssuranceAsyncHandler;
@@ -1628,6 +1660,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::StartInstancesResult> StartInstancesOutcome;
 			typedef std::future<StartInstancesOutcome> StartInstancesOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::StartInstancesRequest&, const StartInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartInstancesAsyncHandler;
+			typedef Outcome<Error, Model::StopDiskReplicaPairResult> StopDiskReplicaPairOutcome;
+			typedef std::future<StopDiskReplicaPairOutcome> StopDiskReplicaPairOutcomeCallable;
+			typedef std::function<void(const EcsClient*, const Model::StopDiskReplicaPairRequest&, const StopDiskReplicaPairOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopDiskReplicaPairAsyncHandler;
 			typedef Outcome<Error, Model::StopInstanceResult> StopInstanceOutcome;
 			typedef std::future<StopInstanceOutcome> StopInstanceOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::StopInstanceRequest&, const StopInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopInstanceAsyncHandler;
@@ -1768,6 +1803,9 @@ namespace AlibabaCloud
 			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;
+			CreateDedicatedBlockStorageClusterOutcome createDedicatedBlockStorageCluster(const Model::CreateDedicatedBlockStorageClusterRequest &request)const;
+			void createDedicatedBlockStorageClusterAsync(const Model::CreateDedicatedBlockStorageClusterRequest& request, const CreateDedicatedBlockStorageClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateDedicatedBlockStorageClusterOutcomeCallable createDedicatedBlockStorageClusterCallable(const Model::CreateDedicatedBlockStorageClusterRequest& request) const;
 			CreateDedicatedHostClusterOutcome createDedicatedHostCluster(const Model::CreateDedicatedHostClusterRequest &request)const;
 			void createDedicatedHostClusterAsync(const Model::CreateDedicatedHostClusterRequest& request, const CreateDedicatedHostClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateDedicatedHostClusterOutcomeCallable createDedicatedHostClusterCallable(const Model::CreateDedicatedHostClusterRequest& request) const;
@@ -1780,6 +1818,9 @@ namespace AlibabaCloud
 			CreateDiskOutcome createDisk(const Model::CreateDiskRequest &request)const;
 			void createDiskAsync(const Model::CreateDiskRequest& request, const CreateDiskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateDiskOutcomeCallable createDiskCallable(const Model::CreateDiskRequest& request) const;
+			CreateDiskReplicaPairOutcome createDiskReplicaPair(const Model::CreateDiskReplicaPairRequest &request)const;
+			void createDiskReplicaPairAsync(const Model::CreateDiskReplicaPairRequest& request, const CreateDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateDiskReplicaPairOutcomeCallable createDiskReplicaPairCallable(const Model::CreateDiskReplicaPairRequest& request) const;
 			CreateElasticityAssuranceOutcome createElasticityAssurance(const Model::CreateElasticityAssuranceRequest &request)const;
 			void createElasticityAssuranceAsync(const Model::CreateElasticityAssuranceRequest& request, const CreateElasticityAssuranceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateElasticityAssuranceOutcomeCallable createElasticityAssuranceCallable(const Model::CreateElasticityAssuranceRequest& request) const;
@@ -1885,6 +1926,9 @@ namespace AlibabaCloud
 			DeleteDiskOutcome deleteDisk(const Model::DeleteDiskRequest &request)const;
 			void deleteDiskAsync(const Model::DeleteDiskRequest& request, const DeleteDiskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteDiskOutcomeCallable deleteDiskCallable(const Model::DeleteDiskRequest& request) const;
+			DeleteDiskReplicaPairOutcome deleteDiskReplicaPair(const Model::DeleteDiskReplicaPairRequest &request)const;
+			void deleteDiskReplicaPairAsync(const Model::DeleteDiskReplicaPairRequest& request, const DeleteDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteDiskReplicaPairOutcomeCallable deleteDiskReplicaPairCallable(const Model::DeleteDiskReplicaPairRequest& request) const;
 			DeleteForwardEntryOutcome deleteForwardEntry(const Model::DeleteForwardEntryRequest &request)const;
 			void deleteForwardEntryAsync(const Model::DeleteForwardEntryRequest& request, const DeleteForwardEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteForwardEntryOutcomeCallable deleteForwardEntryCallable(const Model::DeleteForwardEntryRequest& request) const;
@@ -2008,6 +2052,9 @@ namespace AlibabaCloud
 			DescribeCommandsOutcome describeCommands(const Model::DescribeCommandsRequest &request)const;
 			void describeCommandsAsync(const Model::DescribeCommandsRequest& request, const DescribeCommandsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeCommandsOutcomeCallable describeCommandsCallable(const Model::DescribeCommandsRequest& request) const;
+			DescribeDedicatedBlockStorageClustersOutcome describeDedicatedBlockStorageClusters(const Model::DescribeDedicatedBlockStorageClustersRequest &request)const;
+			void describeDedicatedBlockStorageClustersAsync(const Model::DescribeDedicatedBlockStorageClustersRequest& request, const DescribeDedicatedBlockStorageClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDedicatedBlockStorageClustersOutcomeCallable describeDedicatedBlockStorageClustersCallable(const Model::DescribeDedicatedBlockStorageClustersRequest& request) const;
 			DescribeDedicatedHostAutoRenewOutcome describeDedicatedHostAutoRenew(const Model::DescribeDedicatedHostAutoRenewRequest &request)const;
 			void describeDedicatedHostAutoRenewAsync(const Model::DescribeDedicatedHostAutoRenewRequest& request, const DescribeDedicatedHostAutoRenewAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDedicatedHostAutoRenewOutcomeCallable describeDedicatedHostAutoRenewCallable(const Model::DescribeDedicatedHostAutoRenewRequest& request) const;
@@ -2032,6 +2079,9 @@ namespace AlibabaCloud
 			DescribeDiskMonitorDataOutcome describeDiskMonitorData(const Model::DescribeDiskMonitorDataRequest &request)const;
 			void describeDiskMonitorDataAsync(const Model::DescribeDiskMonitorDataRequest& request, const DescribeDiskMonitorDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDiskMonitorDataOutcomeCallable describeDiskMonitorDataCallable(const Model::DescribeDiskMonitorDataRequest& request) const;
+			DescribeDiskReplicaPairsOutcome describeDiskReplicaPairs(const Model::DescribeDiskReplicaPairsRequest &request)const;
+			void describeDiskReplicaPairsAsync(const Model::DescribeDiskReplicaPairsRequest& request, const DescribeDiskReplicaPairsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDiskReplicaPairsOutcomeCallable describeDiskReplicaPairsCallable(const Model::DescribeDiskReplicaPairsRequest& request) const;
 			DescribeDisksOutcome describeDisks(const Model::DescribeDisksRequest &request)const;
 			void describeDisksAsync(const Model::DescribeDisksRequest& request, const DescribeDisksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDisksOutcomeCallable describeDisksCallable(const Model::DescribeDisksRequest& request) const;
@@ -2599,6 +2649,9 @@ namespace AlibabaCloud
 			SendFileOutcome sendFile(const Model::SendFileRequest &request)const;
 			void sendFileAsync(const Model::SendFileRequest& request, const SendFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SendFileOutcomeCallable sendFileCallable(const Model::SendFileRequest& request) const;
+			StartDiskReplicaPairOutcome startDiskReplicaPair(const Model::StartDiskReplicaPairRequest &request)const;
+			void startDiskReplicaPairAsync(const Model::StartDiskReplicaPairRequest& request, const StartDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartDiskReplicaPairOutcomeCallable startDiskReplicaPairCallable(const Model::StartDiskReplicaPairRequest& request) const;
 			StartElasticityAssuranceOutcome startElasticityAssurance(const Model::StartElasticityAssuranceRequest &request)const;
 			void startElasticityAssuranceAsync(const Model::StartElasticityAssuranceRequest& request, const StartElasticityAssuranceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StartElasticityAssuranceOutcomeCallable startElasticityAssuranceCallable(const Model::StartElasticityAssuranceRequest& request) const;
@@ -2611,6 +2664,9 @@ namespace AlibabaCloud
 			StartInstancesOutcome startInstances(const Model::StartInstancesRequest &request)const;
 			void startInstancesAsync(const Model::StartInstancesRequest& request, const StartInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StartInstancesOutcomeCallable startInstancesCallable(const Model::StartInstancesRequest& request) const;
+			StopDiskReplicaPairOutcome stopDiskReplicaPair(const Model::StopDiskReplicaPairRequest &request)const;
+			void stopDiskReplicaPairAsync(const Model::StopDiskReplicaPairRequest& request, const StopDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopDiskReplicaPairOutcomeCallable stopDiskReplicaPairCallable(const Model::StopDiskReplicaPairRequest& request) const;
 			StopInstanceOutcome stopInstance(const Model::StopInstanceRequest &request)const;
 			void stopInstanceAsync(const Model::StopInstanceRequest& request, const StopInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StopInstanceOutcomeCallable stopInstanceCallable(const Model::StopInstanceRequest& request) const;

ecs/include/alibabacloud/ecs/model/AcceptInquiredSystemEventRequest.h

@@ -47,6 +47,8 @@ namespace AlibabaCloud
 				void setOwnerAccount(const std::string& ownerAccount);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
+				std::string getChoice()const;
+				void setChoice(const std::string& choice);
 
             private:
 				std::string eventId_;
@@ -55,6 +57,7 @@ namespace AlibabaCloud
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
 				long ownerId_;
+				std::string choice_;
 
 			};
 		}

ecs/include/alibabacloud/ecs/model/CreateDedicatedBlockStorageClusterRequest.h

@@ -0,0 +1,90 @@
+/*
+ * 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_CREATEDEDICATEDBLOCKSTORAGECLUSTERREQUEST_H_
+#define ALIBABACLOUD_ECS_MODEL_CREATEDEDICATEDBLOCKSTORAGECLUSTERREQUEST_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 CreateDedicatedBlockStorageClusterRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateDedicatedBlockStorageClusterRequest();
+				~CreateDedicatedBlockStorageClusterRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getDedicatedBlockStorageClusterName()const;
+				void setDedicatedBlockStorageClusterName(const std::string& dedicatedBlockStorageClusterName);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				int getCapacity()const;
+				void setCapacity(int capacity);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				int getPeriod()const;
+				void setPeriod(int period);
+				std::string getFromApp()const;
+				void setFromApp(const std::string& fromApp);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getPerformanceLevel()const;
+				void setPerformanceLevel(const std::string& performanceLevel);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getPeriodUnit()const;
+				void setPeriodUnit(const std::string& periodUnit);
+				std::string getZoneId()const;
+				void setZoneId(const std::string& zoneId);
+				std::string getCategory()const;
+				void setCategory(const std::string& category);
+
+            private:
+				long resourceOwnerId_;
+				std::string dedicatedBlockStorageClusterName_;
+				std::string clientToken_;
+				std::string description_;
+				int capacity_;
+				std::string regionId_;
+				int period_;
+				std::string fromApp_;
+				std::string resourceOwnerAccount_;
+				std::string performanceLevel_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string periodUnit_;
+				std::string zoneId_;
+				std::string category_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_CREATEDEDICATEDBLOCKSTORAGECLUSTERREQUEST_H_

ecs/include/alibabacloud/ecs/model/CreateDedicatedBlockStorageClusterResult.h

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

ecs/include/alibabacloud/ecs/model/CreateDiskReplicaPairRequest.h

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ECS_MODEL_CREATEDISKREPLICAPAIRREQUEST_H_
+#define ALIBABACLOUD_ECS_MODEL_CREATEDISKREPLICAPAIRREQUEST_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 CreateDiskReplicaPairRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateDiskReplicaPairRequest();
+				~CreateDiskReplicaPairRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getPairName()const;
+				void setPairName(const std::string& pairName);
+				std::string getDestinationRegionId()const;
+				void setDestinationRegionId(const std::string& destinationRegionId);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getDiskId()const;
+				void setDiskId(const std::string& diskId);
+				int getAsyncCycle()const;
+				void setAsyncCycle(int asyncCycle);
+				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 getDestinationDiskId()const;
+				void setDestinationDiskId(const std::string& destinationDiskId);
+
+            private:
+				long resourceOwnerId_;
+				std::string pairName_;
+				std::string destinationRegionId_;
+				std::string description_;
+				std::string regionId_;
+				std::string diskId_;
+				int asyncCycle_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string destinationDiskId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_CREATEDISKREPLICAPAIRREQUEST_H_

ecs/include/alibabacloud/ecs/model/CreateDiskReplicaPairResult.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_CREATEDISKREPLICAPAIRRESULT_H_
+#define ALIBABACLOUD_ECS_MODEL_CREATEDISKREPLICAPAIRRESULT_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 CreateDiskReplicaPairResult : public ServiceResult
+			{
+			public:
+
+
+				CreateDiskReplicaPairResult();
+				explicit CreateDiskReplicaPairResult(const std::string &payload);
+				~CreateDiskReplicaPairResult();
+				std::string getPairId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string pairId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_CREATEDISKREPLICAPAIRRESULT_H_

ecs/include/alibabacloud/ecs/model/CreateDiskRequest.h

@@ -73,6 +73,8 @@ namespace AlibabaCloud
 				void setArn(const std::vector<Arn>& arn);
 				std::string getAdvancedFeatures()const;
 				void setAdvancedFeatures(const std::string& advancedFeatures);
+				std::string getDedicatedBlockStorageClusterId()const;
+				void setDedicatedBlockStorageClusterId(const std::string& dedicatedBlockStorageClusterId);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getPerformanceLevel()const;
@@ -108,6 +110,7 @@ namespace AlibabaCloud
 				std::vector<Tag> tag_;
 				std::vector<Arn> arn_;
 				std::string advancedFeatures_;
+				std::string dedicatedBlockStorageClusterId_;
 				std::string resourceOwnerAccount_;
 				std::string performanceLevel_;
 				std::string ownerAccount_;

ecs/include/alibabacloud/ecs/model/CreateNetworkInterfaceRequest.h

@@ -71,10 +71,14 @@ namespace AlibabaCloud
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
+				int getQueuePairNumber()const;
+				void setQueuePairNumber(int queuePairNumber);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
 				std::vector<std::string> getSecurityGroupIds()const;
 				void setSecurityGroupIds(const std::vector<std::string>& securityGroupIds);
+				std::string getNetworkInterfaceTrafficMode()const;
+				void setNetworkInterfaceTrafficMode(const std::string& networkInterfaceTrafficMode);
 				std::string getVSwitchId()const;
 				void setVSwitchId(const std::string& vSwitchId);
 				std::vector<std::string> getPrivateIpAddress()const;
@@ -98,8 +102,10 @@ namespace AlibabaCloud
 				bool visible_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
+				int queuePairNumber_;
 				long ownerId_;
 				std::vector<std::string> securityGroupIds_;
+				std::string networkInterfaceTrafficMode_;
 				std::string vSwitchId_;
 				std::vector<std::string> privateIpAddress_;
 				std::string primaryIpAddress_;

ecs/include/alibabacloud/ecs/model/DeleteDiskReplicaPairRequest.h

@@ -0,0 +1,63 @@
+/*
+ * 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_DELETEDISKREPLICAPAIRREQUEST_H_
+#define ALIBABACLOUD_ECS_MODEL_DELETEDISKREPLICAPAIRREQUEST_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 DeleteDiskReplicaPairRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteDiskReplicaPairRequest();
+				~DeleteDiskReplicaPairRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				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 getReplicaPairId()const;
+				void setReplicaPairId(const std::string& replicaPairId);
+
+            private:
+				long resourceOwnerId_;
+				std::string regionId_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string replicaPairId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_DELETEDISKREPLICAPAIRREQUEST_H_

ecs/include/alibabacloud/ecs/model/DeleteDiskReplicaPairResult.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_DELETEDISKREPLICAPAIRRESULT_H_
+#define ALIBABACLOUD_ECS_MODEL_DELETEDISKREPLICAPAIRRESULT_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 DeleteDiskReplicaPairResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteDiskReplicaPairResult();
+				explicit DeleteDiskReplicaPairResult(const std::string &payload);
+				~DeleteDiskReplicaPairResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_DELETEDISKREPLICAPAIRRESULT_H_

ecs/include/alibabacloud/ecs/model/DescribeCloudAssistantStatusResult.h

@@ -39,6 +39,7 @@ namespace AlibabaCloud
 					std::string oSType;
 					long invocationCount;
 					std::string cloudAssistantStatus;
+					std::string lastHeartbeatTime;
 					std::string lastInvokedTime;
 					long activeTaskCount;
 				};

ecs/include/alibabacloud/ecs/model/DescribeDedicatedBlockStorageClustersRequest.h

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ECS_MODEL_DESCRIBEDEDICATEDBLOCKSTORAGECLUSTERSREQUEST_H_
+#define ALIBABACLOUD_ECS_MODEL_DESCRIBEDEDICATEDBLOCKSTORAGECLUSTERSREQUEST_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 DescribeDedicatedBlockStorageClustersRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDedicatedBlockStorageClustersRequest();
+				~DescribeDedicatedBlockStorageClustersRequest();
+
+				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::vector<std::string> getDedicatedBlockStorageClusterId()const;
+				void setDedicatedBlockStorageClusterId(const std::vector<std::string>& dedicatedBlockStorageClusterId);
+				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 getZoneId()const;
+				void setZoneId(const std::string& zoneId);
+				int getMaxResults()const;
+				void setMaxResults(int maxResults);
+				std::string getCategory()const;
+				void setCategory(const std::string& category);
+				std::vector<std::string> getStatus()const;
+				void setStatus(const std::vector<std::string>& status);
+
+            private:
+				long resourceOwnerId_;
+				std::string regionId_;
+				std::string nextToken_;
+				std::vector<std::string> dedicatedBlockStorageClusterId_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string zoneId_;
+				int maxResults_;
+				std::string category_;
+				std::vector<std::string> status_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_DESCRIBEDEDICATEDBLOCKSTORAGECLUSTERSREQUEST_H_

ecs/include/alibabacloud/ecs/model/DescribeDedicatedBlockStorageClustersResult.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ECS_MODEL_DESCRIBEDEDICATEDBLOCKSTORAGECLUSTERSRESULT_H_
+#define ALIBABACLOUD_ECS_MODEL_DESCRIBEDEDICATEDBLOCKSTORAGECLUSTERSRESULT_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 DescribeDedicatedBlockStorageClustersResult : public ServiceResult
+			{
+			public:
+				struct DedicatedBlockStorageCluster
+				{
+					struct DedicatedBlockStorageClusterCapacity
+					{
+						long availableCapacity;
+						long totalCapacity;
+					};
+					std::string status;
+					std::string description;
+					std::string category;
+					std::string zoneId;
+					std::string dedicatedBlockStorageClusterId;
+					std::string performanceLevel;
+					std::string expiredTime;
+					std::string createTime;
+					std::string dedicatedBlockStorageClusterName;
+					DedicatedBlockStorageClusterCapacity dedicatedBlockStorageClusterCapacity;
+				};
+
+
+				DescribeDedicatedBlockStorageClustersResult();
+				explicit DescribeDedicatedBlockStorageClustersResult(const std::string &payload);
+				~DescribeDedicatedBlockStorageClustersResult();
+				std::vector<DedicatedBlockStorageCluster> getDedicatedBlockStorageClusters()const;
+				std::string getNextToken()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<DedicatedBlockStorageCluster> dedicatedBlockStorageClusters_;
+				std::string nextToken_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_DESCRIBEDEDICATEDBLOCKSTORAGECLUSTERSRESULT_H_

ecs/include/alibabacloud/ecs/model/DescribeDiskReplicaPairsRequest.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_DESCRIBEDISKREPLICAPAIRSREQUEST_H_
+#define ALIBABACLOUD_ECS_MODEL_DESCRIBEDISKREPLICAPAIRSREQUEST_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 DescribeDiskReplicaPairsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDiskReplicaPairsRequest();
+				~DescribeDiskReplicaPairsRequest();
+
+				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 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);
+
+            private:
+				long resourceOwnerId_;
+				std::string regionId_;
+				std::string nextToken_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				int maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_DESCRIBEDISKREPLICAPAIRSREQUEST_H_

ecs/include/alibabacloud/ecs/model/DescribeDiskReplicaPairsResult.h

@@ -0,0 +1,64 @@
+/*
+ * 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_DESCRIBEDISKREPLICAPAIRSRESULT_H_
+#define ALIBABACLOUD_ECS_MODEL_DESCRIBEDISKREPLICAPAIRSRESULT_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 DescribeDiskReplicaPairsResult : public ServiceResult
+			{
+			public:
+				struct DiskReplicaPair
+				{
+					std::string status;
+					std::string destinationDiskId;
+					std::string description;
+					std::string pairName;
+					std::string destinationRegion;
+					std::string replicaPairId;
+					std::string sourceRegion;
+					std::string sourceDiskId;
+				};
+
+
+				DescribeDiskReplicaPairsResult();
+				explicit DescribeDiskReplicaPairsResult(const std::string &payload);
+				~DescribeDiskReplicaPairsResult();
+				std::string getNextToken()const;
+				std::vector<DiskReplicaPair> getDiskReplicaPairs()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string nextToken_;
+				std::vector<DiskReplicaPair> diskReplicaPairs_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_DESCRIBEDISKREPLICAPAIRSRESULT_H_

ecs/include/alibabacloud/ecs/model/DescribeDisksResult.h

@@ -54,6 +54,7 @@ namespace AlibabaCloud
 					std::string category;
 					std::string kMSKeyId;
 					std::string resourceGroupId;
+					std::string dedicatedBlockStorageClusterId;
 					int size;
 					bool encrypted;
 					bool deleteAutoSnapshot;

ecs/include/alibabacloud/ecs/model/DescribeInstanceHistoryEventsRequest.h

@@ -53,6 +53,8 @@ namespace AlibabaCloud
 				void setInstanceEventCycleStatus(const std::vector<std::string>& instanceEventCycleStatus);
 				std::string getEventPublishTimeEnd()const;
 				void setEventPublishTimeEnd(const std::string& eventPublishTimeEnd);
+				std::vector<std::string> getResourceId()const;
+				void setResourceId(const std::vector<std::string>& resourceId);
 				std::vector<std::string> getInstanceEventType()const;
 				void setInstanceEventType(const std::vector<std::string>& instanceEventType);
 				std::string getResourceOwnerAccount()const;
@@ -63,6 +65,8 @@ namespace AlibabaCloud
 				void setNotBeforeStart(const std::string& notBeforeStart);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
+				std::string getResourceType()const;
+				void setResourceType(const std::string& resourceType);
 				std::string getEventPublishTimeStart()const;
 				void setEventPublishTimeStart(const std::string& eventPublishTimeStart);
 				std::string getInstanceId()const;
@@ -82,11 +86,13 @@ namespace AlibabaCloud
 				int pageSize_;
 				std::vector<std::string> instanceEventCycleStatus_;
 				std::string eventPublishTimeEnd_;
+				std::vector<std::string> resourceId_;
 				std::vector<std::string> instanceEventType_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
 				std::string notBeforeStart_;
 				long ownerId_;
+				std::string resourceType_;
 				std::string eventPublishTimeStart_;
 				std::string instanceId_;
 				std::string notBeforeEnd_;

ecs/include/alibabacloud/ecs/model/DescribeInstanceHistoryEventsResult.h

@@ -66,6 +66,7 @@ namespace AlibabaCloud
 					std::string impactLevel;
 					ExtendedAttribute extendedAttribute;
 					std::string eventId;
+					std::string resourceType;
 					std::string notBefore;
 					std::string reason;
 				};

ecs/include/alibabacloud/ecs/model/DescribeInstanceTypesResult.h

@@ -35,12 +35,14 @@ namespace AlibabaCloud
 				struct InstanceType
 				{
 					long instancePpsTx;
+					std::string nvmeSupport;
 					int primaryEniQueueNumber;
 					long localStorageCapacity;
 					int totalEniQueueQuantity;
 					bool eniTrunkSupported;
 					std::string instanceTypeFamily;
 					long instancePpsRx;
+					int eriQuantity;
 					int instanceBandwidthRx;
 					int instanceBandwidthTx;
 					int localStorageAmount;
@@ -57,6 +59,7 @@ namespace AlibabaCloud
 					int eniQuantity;
 					int gPUAmount;
 					int diskQuantity;
+					int queuePairNumber;
 					int baselineCredit;
 					std::string instanceFamilyLevel;
 					int eniPrivateIpAddressQuantity;

ecs/include/alibabacloud/ecs/model/DescribeInvocationsResult.h

@@ -39,6 +39,7 @@ namespace AlibabaCloud
 						int dropped;
 						std::string invocationStatus;
 						std::string instanceId;
+						bool timed;
 						std::string instanceInvokeStatus;
 						long exitCode;
 						std::string errorInfo;
@@ -56,6 +57,7 @@ namespace AlibabaCloud
 					bool timed;
 					std::vector<Invocation::InvokeInstance> invokeInstances;
 					std::string commandContent;
+					std::string repeatMode;
 					std::string invokeStatus;
 					std::string commandType;
 					std::string username;

ecs/include/alibabacloud/ecs/model/DescribeNetworkInterfaceAttributeResult.h

@@ -69,55 +69,59 @@ namespace AlibabaCloud
 				DescribeNetworkInterfaceAttributeResult();
 				explicit DescribeNetworkInterfaceAttributeResult(const std::string &payload);
 				~DescribeNetworkInterfaceAttributeResult();
-				std::string getStatus()const;
 				std::string getPrivateIpAddress()const;
 				std::string getDescription()const;
-				std::string getZoneId()const;
 				std::string getResourceGroupId()const;
 				bool getServiceManaged()const;
+				Attachment getAttachment()const;
+				std::string getNetworkInterfaceId()const;
+				std::vector<Ipv6Set> getIpv6Sets()const;
+				std::string getOwnerId()const;
+				AssociatedPublicIp getAssociatedPublicIp()const;
+				std::vector<Tag> getTags()const;
+				std::string getStatus()const;
+				std::string getNetworkInterfaceTrafficMode()const;
+				std::string getZoneId()const;
 				std::string getInstanceId()const;
 				std::string getVSwitchId()const;
 				std::string getNetworkInterfaceName()const;
-				Attachment getAttachment()const;
-				std::string getNetworkInterfaceId()const;
 				std::string getMacAddress()const;
 				std::vector<std::string> getSecurityGroupIds()const;
 				long getServiceID()const;
 				std::string getType()const;
-				std::vector<Ipv6Set> getIpv6Sets()const;
 				int getQueueNumber()const;
+				int getQueuePairNumber()const;
 				std::string getVpcId()const;
-				std::string getOwnerId()const;
-				AssociatedPublicIp getAssociatedPublicIp()const;
 				std::string getCreationTime()const;
-				std::vector<Tag> getTags()const;
 				std::vector<PrivateIpSet> getPrivateIpSets()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string status_;
 				std::string privateIpAddress_;
 				std::string description_;
-				std::string zoneId_;
 				std::string resourceGroupId_;
 				bool serviceManaged_;
+				Attachment attachment_;
+				std::string networkInterfaceId_;
+				std::vector<Ipv6Set> ipv6Sets_;
+				std::string ownerId_;
+				AssociatedPublicIp associatedPublicIp_;
+				std::vector<Tag> tags_;
+				std::string status_;
+				std::string networkInterfaceTrafficMode_;
+				std::string zoneId_;
 				std::string instanceId_;
 				std::string vSwitchId_;
 				std::string networkInterfaceName_;
-				Attachment attachment_;
-				std::string networkInterfaceId_;
 				std::string macAddress_;
 				std::vector<std::string> securityGroupIds_;
 				long serviceID_;
 				std::string type_;
-				std::vector<Ipv6Set> ipv6Sets_;
 				int queueNumber_;
+				int queuePairNumber_;
 				std::string vpcId_;
-				std::string ownerId_;
-				AssociatedPublicIp associatedPublicIp_;
 				std::string creationTime_;
-				std::vector<Tag> tags_;
 				std::vector<PrivateIpSet> privateIpSets_;
 
 			};

ecs/include/alibabacloud/ecs/model/DescribeNetworkInterfacesResult.h

@@ -65,28 +65,30 @@ namespace AlibabaCloud
 						std::string tagKey;
 						std::string tagValue;
 					};
-					std::string status;
 					std::string privateIpAddress;
 					std::string description;
-					std::string zoneId;
 					std::string resourceGroupId;
 					bool serviceManaged;
+					Attachment attachment;
+					std::string networkInterfaceId;
+					std::vector<NetworkInterfaceSet::Ipv6Set> ipv6Sets;
+					std::string ownerId;
+					AssociatedPublicIp associatedPublicIp;
+					std::vector<NetworkInterfaceSet::Tag> tags;
+					std::string status;
+					std::string networkInterfaceTrafficMode;
+					std::string zoneId;
 					std::string instanceId;
 					std::string vSwitchId;
 					std::string networkInterfaceName;
-					Attachment attachment;
-					std::string networkInterfaceId;
 					std::string macAddress;
 					std::vector<std::string> securityGroupIds;
 					long serviceID;
 					std::string type;
-					std::vector<NetworkInterfaceSet::Ipv6Set> ipv6Sets;
 					int queueNumber;
+					int queuePairNumber;
 					std::string vpcId;
-					std::string ownerId;
-					AssociatedPublicIp associatedPublicIp;
 					std::string creationTime;
-					std::vector<NetworkInterfaceSet::Tag> tags;
 					std::vector<NetworkInterfaceSet::PrivateIpSet> privateIpSets;
 				};
 

ecs/include/alibabacloud/ecs/model/InvokeCommandRequest.h

@@ -43,6 +43,8 @@ namespace AlibabaCloud
 				void setFrequency(const std::string& frequency);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
+				std::string getRepeatMode()const;
+				void setRepeatMode(const std::string& repeatMode);
 				std::string getWindowsPasswordName()const;
 				void setWindowsPasswordName(const std::string& windowsPasswordName);
 				bool getTimed()const;
@@ -65,6 +67,7 @@ namespace AlibabaCloud
 				std::string commandId_;
 				std::string frequency_;
 				std::string regionId_;
+				std::string repeatMode_;
 				std::string windowsPasswordName_;
 				bool timed_;
 				std::string resourceOwnerAccount_;

ecs/include/alibabacloud/ecs/model/ModifyDiskAttributeRequest.h

@@ -43,6 +43,8 @@ namespace AlibabaCloud
 				void setDiskName(const std::string& diskName);
 				bool getDeleteAutoSnapshot()const;
 				void setDeleteAutoSnapshot(bool deleteAutoSnapshot);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
 				std::vector<std::string> getDiskIds()const;
 				void setDiskIds(const std::vector<std::string>& diskIds);
 				std::string getDiskId()const;
@@ -63,6 +65,7 @@ namespace AlibabaCloud
 				std::string description_;
 				std::string diskName_;
 				bool deleteAutoSnapshot_;
+				std::string regionId_;
 				std::vector<std::string> diskIds_;
 				std::string diskId_;
 				bool deleteWithInstance_;

ecs/include/alibabacloud/ecs/model/RunCommandRequest.h

@@ -53,6 +53,8 @@ namespace AlibabaCloud
 				void setRegionId(const std::string& regionId);
 				std::string getContentEncoding()const;
 				void setContentEncoding(const std::string& contentEncoding);
+				std::string getRepeatMode()const;
+				void setRepeatMode(const std::string& repeatMode);
 				std::string getWindowsPasswordName()const;
 				void setWindowsPasswordName(const std::string& windowsPasswordName);
 				bool getKeepCommand()const;
@@ -86,6 +88,7 @@ namespace AlibabaCloud
 				std::string frequency_;
 				std::string regionId_;
 				std::string contentEncoding_;
+				std::string repeatMode_;
 				std::string windowsPasswordName_;
 				bool keepCommand_;
 				bool timed_;

ecs/include/alibabacloud/ecs/model/StartDiskReplicaPairRequest.h

@@ -0,0 +1,63 @@
+/*
+ * 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_STARTDISKREPLICAPAIRREQUEST_H_
+#define ALIBABACLOUD_ECS_MODEL_STARTDISKREPLICAPAIRREQUEST_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 StartDiskReplicaPairRequest : public RpcServiceRequest
+			{
+
+			public:
+				StartDiskReplicaPairRequest();
+				~StartDiskReplicaPairRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				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 getReplicaPairId()const;
+				void setReplicaPairId(const std::string& replicaPairId);
+
+            private:
+				long resourceOwnerId_;
+				std::string regionId_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string replicaPairId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_STARTDISKREPLICAPAIRREQUEST_H_

ecs/include/alibabacloud/ecs/model/StartDiskReplicaPairResult.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_STARTDISKREPLICAPAIRRESULT_H_
+#define ALIBABACLOUD_ECS_MODEL_STARTDISKREPLICAPAIRRESULT_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 StartDiskReplicaPairResult : public ServiceResult
+			{
+			public:
+
+
+				StartDiskReplicaPairResult();
+				explicit StartDiskReplicaPairResult(const std::string &payload);
+				~StartDiskReplicaPairResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_STARTDISKREPLICAPAIRRESULT_H_

ecs/include/alibabacloud/ecs/model/StopDiskReplicaPairRequest.h

@@ -0,0 +1,63 @@
+/*
+ * 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_STOPDISKREPLICAPAIRREQUEST_H_
+#define ALIBABACLOUD_ECS_MODEL_STOPDISKREPLICAPAIRREQUEST_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 StopDiskReplicaPairRequest : public RpcServiceRequest
+			{
+
+			public:
+				StopDiskReplicaPairRequest();
+				~StopDiskReplicaPairRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				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 getReplicaPairId()const;
+				void setReplicaPairId(const std::string& replicaPairId);
+
+            private:
+				long resourceOwnerId_;
+				std::string regionId_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string replicaPairId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_STOPDISKREPLICAPAIRREQUEST_H_

ecs/include/alibabacloud/ecs/model/StopDiskReplicaPairResult.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_STOPDISKREPLICAPAIRRESULT_H_
+#define ALIBABACLOUD_ECS_MODEL_STOPDISKREPLICAPAIRRESULT_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 StopDiskReplicaPairResult : public ServiceResult
+			{
+			public:
+
+
+				StopDiskReplicaPairResult();
+				explicit StopDiskReplicaPairResult(const std::string &payload);
+				~StopDiskReplicaPairResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECS_MODEL_STOPDISKREPLICAPAIRRESULT_H_

ecs/src/EcsClient.cc

@@ -1275,6 +1275,42 @@ EcsClient::CreateCommandOutcomeCallable EcsClient::createCommandCallable(const C
 	return task->get_future();
 }
 
+EcsClient::CreateDedicatedBlockStorageClusterOutcome EcsClient::createDedicatedBlockStorageCluster(const CreateDedicatedBlockStorageClusterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateDedicatedBlockStorageClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateDedicatedBlockStorageClusterOutcome(CreateDedicatedBlockStorageClusterResult(outcome.result()));
+	else
+		return CreateDedicatedBlockStorageClusterOutcome(outcome.error());
+}
+
+void EcsClient::createDedicatedBlockStorageClusterAsync(const CreateDedicatedBlockStorageClusterRequest& request, const CreateDedicatedBlockStorageClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createDedicatedBlockStorageCluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EcsClient::CreateDedicatedBlockStorageClusterOutcomeCallable EcsClient::createDedicatedBlockStorageClusterCallable(const CreateDedicatedBlockStorageClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateDedicatedBlockStorageClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->createDedicatedBlockStorageCluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EcsClient::CreateDedicatedHostClusterOutcome EcsClient::createDedicatedHostCluster(const CreateDedicatedHostClusterRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1419,6 +1455,42 @@ EcsClient::CreateDiskOutcomeCallable EcsClient::createDiskCallable(const CreateD
 	return task->get_future();
 }
 
+EcsClient::CreateDiskReplicaPairOutcome EcsClient::createDiskReplicaPair(const CreateDiskReplicaPairRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateDiskReplicaPairOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateDiskReplicaPairOutcome(CreateDiskReplicaPairResult(outcome.result()));
+	else
+		return CreateDiskReplicaPairOutcome(outcome.error());
+}
+
+void EcsClient::createDiskReplicaPairAsync(const CreateDiskReplicaPairRequest& request, const CreateDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createDiskReplicaPair(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EcsClient::CreateDiskReplicaPairOutcomeCallable EcsClient::createDiskReplicaPairCallable(const CreateDiskReplicaPairRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateDiskReplicaPairOutcome()>>(
+			[this, request]()
+			{
+			return this->createDiskReplicaPair(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EcsClient::CreateElasticityAssuranceOutcome EcsClient::createElasticityAssurance(const CreateElasticityAssuranceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2679,6 +2751,42 @@ EcsClient::DeleteDiskOutcomeCallable EcsClient::deleteDiskCallable(const DeleteD
 	return task->get_future();
 }
 
+EcsClient::DeleteDiskReplicaPairOutcome EcsClient::deleteDiskReplicaPair(const DeleteDiskReplicaPairRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteDiskReplicaPairOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteDiskReplicaPairOutcome(DeleteDiskReplicaPairResult(outcome.result()));
+	else
+		return DeleteDiskReplicaPairOutcome(outcome.error());
+}
+
+void EcsClient::deleteDiskReplicaPairAsync(const DeleteDiskReplicaPairRequest& request, const DeleteDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteDiskReplicaPair(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EcsClient::DeleteDiskReplicaPairOutcomeCallable EcsClient::deleteDiskReplicaPairCallable(const DeleteDiskReplicaPairRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteDiskReplicaPairOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteDiskReplicaPair(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EcsClient::DeleteForwardEntryOutcome EcsClient::deleteForwardEntry(const DeleteForwardEntryRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4155,6 +4263,42 @@ EcsClient::DescribeCommandsOutcomeCallable EcsClient::describeCommandsCallable(c
 	return task->get_future();
 }
 
+EcsClient::DescribeDedicatedBlockStorageClustersOutcome EcsClient::describeDedicatedBlockStorageClusters(const DescribeDedicatedBlockStorageClustersRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDedicatedBlockStorageClustersOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDedicatedBlockStorageClustersOutcome(DescribeDedicatedBlockStorageClustersResult(outcome.result()));
+	else
+		return DescribeDedicatedBlockStorageClustersOutcome(outcome.error());
+}
+
+void EcsClient::describeDedicatedBlockStorageClustersAsync(const DescribeDedicatedBlockStorageClustersRequest& request, const DescribeDedicatedBlockStorageClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDedicatedBlockStorageClusters(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EcsClient::DescribeDedicatedBlockStorageClustersOutcomeCallable EcsClient::describeDedicatedBlockStorageClustersCallable(const DescribeDedicatedBlockStorageClustersRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDedicatedBlockStorageClustersOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDedicatedBlockStorageClusters(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EcsClient::DescribeDedicatedHostAutoRenewOutcome EcsClient::describeDedicatedHostAutoRenew(const DescribeDedicatedHostAutoRenewRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4443,6 +4587,42 @@ EcsClient::DescribeDiskMonitorDataOutcomeCallable EcsClient::describeDiskMonitor
 	return task->get_future();
 }
 
+EcsClient::DescribeDiskReplicaPairsOutcome EcsClient::describeDiskReplicaPairs(const DescribeDiskReplicaPairsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDiskReplicaPairsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDiskReplicaPairsOutcome(DescribeDiskReplicaPairsResult(outcome.result()));
+	else
+		return DescribeDiskReplicaPairsOutcome(outcome.error());
+}
+
+void EcsClient::describeDiskReplicaPairsAsync(const DescribeDiskReplicaPairsRequest& request, const DescribeDiskReplicaPairsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDiskReplicaPairs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EcsClient::DescribeDiskReplicaPairsOutcomeCallable EcsClient::describeDiskReplicaPairsCallable(const DescribeDiskReplicaPairsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDiskReplicaPairsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDiskReplicaPairs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EcsClient::DescribeDisksOutcome EcsClient::describeDisks(const DescribeDisksRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -11247,6 +11427,42 @@ EcsClient::SendFileOutcomeCallable EcsClient::sendFileCallable(const SendFileReq
 	return task->get_future();
 }
 
+EcsClient::StartDiskReplicaPairOutcome EcsClient::startDiskReplicaPair(const StartDiskReplicaPairRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StartDiskReplicaPairOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StartDiskReplicaPairOutcome(StartDiskReplicaPairResult(outcome.result()));
+	else
+		return StartDiskReplicaPairOutcome(outcome.error());
+}
+
+void EcsClient::startDiskReplicaPairAsync(const StartDiskReplicaPairRequest& request, const StartDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, startDiskReplicaPair(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EcsClient::StartDiskReplicaPairOutcomeCallable EcsClient::startDiskReplicaPairCallable(const StartDiskReplicaPairRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StartDiskReplicaPairOutcome()>>(
+			[this, request]()
+			{
+			return this->startDiskReplicaPair(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EcsClient::StartElasticityAssuranceOutcome EcsClient::startElasticityAssurance(const StartElasticityAssuranceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -11391,6 +11607,42 @@ EcsClient::StartInstancesOutcomeCallable EcsClient::startInstancesCallable(const
 	return task->get_future();
 }
 
+EcsClient::StopDiskReplicaPairOutcome EcsClient::stopDiskReplicaPair(const StopDiskReplicaPairRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StopDiskReplicaPairOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StopDiskReplicaPairOutcome(StopDiskReplicaPairResult(outcome.result()));
+	else
+		return StopDiskReplicaPairOutcome(outcome.error());
+}
+
+void EcsClient::stopDiskReplicaPairAsync(const StopDiskReplicaPairRequest& request, const StopDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, stopDiskReplicaPair(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EcsClient::StopDiskReplicaPairOutcomeCallable EcsClient::stopDiskReplicaPairCallable(const StopDiskReplicaPairRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StopDiskReplicaPairOutcome()>>(
+			[this, request]()
+			{
+			return this->stopDiskReplicaPair(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EcsClient::StopInstanceOutcome EcsClient::stopInstance(const StopInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

ecs/src/model/AcceptInquiredSystemEventRequest.cc

@@ -93,3 +93,14 @@ void AcceptInquiredSystemEventRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
+std::string AcceptInquiredSystemEventRequest::getChoice()const
+{
+	return choice_;
+}
+
+void AcceptInquiredSystemEventRequest::setChoice(const std::string& choice)
+{
+	choice_ = choice;
+	setParameter("Choice", choice);
+}
+

ecs/src/model/CreateDedicatedBlockStorageClusterRequest.cc

@@ -0,0 +1,194 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ecs/model/CreateDedicatedBlockStorageClusterRequest.h>
+
+using AlibabaCloud::Ecs::Model::CreateDedicatedBlockStorageClusterRequest;
+
+CreateDedicatedBlockStorageClusterRequest::CreateDedicatedBlockStorageClusterRequest() :
+	RpcServiceRequest("ecs", "2014-05-26", "CreateDedicatedBlockStorageCluster")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateDedicatedBlockStorageClusterRequest::~CreateDedicatedBlockStorageClusterRequest()
+{}
+
+long CreateDedicatedBlockStorageClusterRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateDedicatedBlockStorageClusterRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string CreateDedicatedBlockStorageClusterRequest::getDedicatedBlockStorageClusterName()const
+{
+	return dedicatedBlockStorageClusterName_;
+}
+
+void CreateDedicatedBlockStorageClusterRequest::setDedicatedBlockStorageClusterName(const std::string& dedicatedBlockStorageClusterName)
+{
+	dedicatedBlockStorageClusterName_ = dedicatedBlockStorageClusterName;
+	setParameter("DedicatedBlockStorageClusterName", dedicatedBlockStorageClusterName);
+}
+
+std::string CreateDedicatedBlockStorageClusterRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateDedicatedBlockStorageClusterRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string CreateDedicatedBlockStorageClusterRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateDedicatedBlockStorageClusterRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+int CreateDedicatedBlockStorageClusterRequest::getCapacity()const
+{
+	return capacity_;
+}
+
+void CreateDedicatedBlockStorageClusterRequest::setCapacity(int capacity)
+{
+	capacity_ = capacity;
+	setParameter("Capacity", std::to_string(capacity));
+}
+
+std::string CreateDedicatedBlockStorageClusterRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateDedicatedBlockStorageClusterRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+int CreateDedicatedBlockStorageClusterRequest::getPeriod()const
+{
+	return period_;
+}
+
+void CreateDedicatedBlockStorageClusterRequest::setPeriod(int period)
+{
+	period_ = period;
+	setParameter("Period", std::to_string(period));
+}
+
+std::string CreateDedicatedBlockStorageClusterRequest::getFromApp()const
+{
+	return fromApp_;
+}
+
+void CreateDedicatedBlockStorageClusterRequest::setFromApp(const std::string& fromApp)
+{
+	fromApp_ = fromApp;
+	setParameter("FromApp", fromApp);
+}
+
+std::string CreateDedicatedBlockStorageClusterRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateDedicatedBlockStorageClusterRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateDedicatedBlockStorageClusterRequest::getPerformanceLevel()const
+{
+	return performanceLevel_;
+}
+
+void CreateDedicatedBlockStorageClusterRequest::setPerformanceLevel(const std::string& performanceLevel)
+{
+	performanceLevel_ = performanceLevel;
+	setParameter("PerformanceLevel", performanceLevel);
+}
+
+std::string CreateDedicatedBlockStorageClusterRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateDedicatedBlockStorageClusterRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long CreateDedicatedBlockStorageClusterRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateDedicatedBlockStorageClusterRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateDedicatedBlockStorageClusterRequest::getPeriodUnit()const
+{
+	return periodUnit_;
+}
+
+void CreateDedicatedBlockStorageClusterRequest::setPeriodUnit(const std::string& periodUnit)
+{
+	periodUnit_ = periodUnit;
+	setParameter("PeriodUnit", periodUnit);
+}
+
+std::string CreateDedicatedBlockStorageClusterRequest::getZoneId()const
+{
+	return zoneId_;
+}
+
+void CreateDedicatedBlockStorageClusterRequest::setZoneId(const std::string& zoneId)
+{
+	zoneId_ = zoneId;
+	setParameter("ZoneId", zoneId);
+}
+
+std::string CreateDedicatedBlockStorageClusterRequest::getCategory()const
+{
+	return category_;
+}
+
+void CreateDedicatedBlockStorageClusterRequest::setCategory(const std::string& category)
+{
+	category_ = category;
+	setParameter("Category", category);
+}
+

ecs/src/model/CreateDedicatedBlockStorageClusterResult.cc

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

ecs/src/model/CreateDiskReplicaPairRequest.cc

@@ -0,0 +1,150 @@
+/*
+ * 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/CreateDiskReplicaPairRequest.h>
+
+using AlibabaCloud::Ecs::Model::CreateDiskReplicaPairRequest;
+
+CreateDiskReplicaPairRequest::CreateDiskReplicaPairRequest() :
+	RpcServiceRequest("ecs", "2014-05-26", "CreateDiskReplicaPair")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateDiskReplicaPairRequest::~CreateDiskReplicaPairRequest()
+{}
+
+long CreateDiskReplicaPairRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateDiskReplicaPairRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string CreateDiskReplicaPairRequest::getPairName()const
+{
+	return pairName_;
+}
+
+void CreateDiskReplicaPairRequest::setPairName(const std::string& pairName)
+{
+	pairName_ = pairName;
+	setParameter("PairName", pairName);
+}
+
+std::string CreateDiskReplicaPairRequest::getDestinationRegionId()const
+{
+	return destinationRegionId_;
+}
+
+void CreateDiskReplicaPairRequest::setDestinationRegionId(const std::string& destinationRegionId)
+{
+	destinationRegionId_ = destinationRegionId;
+	setParameter("DestinationRegionId", destinationRegionId);
+}
+
+std::string CreateDiskReplicaPairRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateDiskReplicaPairRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+std::string CreateDiskReplicaPairRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateDiskReplicaPairRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreateDiskReplicaPairRequest::getDiskId()const
+{
+	return diskId_;
+}
+
+void CreateDiskReplicaPairRequest::setDiskId(const std::string& diskId)
+{
+	diskId_ = diskId;
+	setParameter("DiskId", diskId);
+}
+
+int CreateDiskReplicaPairRequest::getAsyncCycle()const
+{
+	return asyncCycle_;
+}
+
+void CreateDiskReplicaPairRequest::setAsyncCycle(int asyncCycle)
+{
+	asyncCycle_ = asyncCycle;
+	setParameter("AsyncCycle", std::to_string(asyncCycle));
+}
+
+std::string CreateDiskReplicaPairRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateDiskReplicaPairRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateDiskReplicaPairRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateDiskReplicaPairRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long CreateDiskReplicaPairRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateDiskReplicaPairRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateDiskReplicaPairRequest::getDestinationDiskId()const
+{
+	return destinationDiskId_;
+}
+
+void CreateDiskReplicaPairRequest::setDestinationDiskId(const std::string& destinationDiskId)
+{
+	destinationDiskId_ = destinationDiskId;
+	setParameter("DestinationDiskId", destinationDiskId);
+}
+

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

ecs/src/model/CreateDiskRequest.cc

@@ -181,6 +181,17 @@ void CreateDiskRequest::setAdvancedFeatures(const std::string& advancedFeatures)
 	setParameter("AdvancedFeatures", advancedFeatures);
 }
 
+std::string CreateDiskRequest::getDedicatedBlockStorageClusterId()const
+{
+	return dedicatedBlockStorageClusterId_;
+}
+
+void CreateDiskRequest::setDedicatedBlockStorageClusterId(const std::string& dedicatedBlockStorageClusterId)
+{
+	dedicatedBlockStorageClusterId_ = dedicatedBlockStorageClusterId;
+	setParameter("DedicatedBlockStorageClusterId", dedicatedBlockStorageClusterId);
+}
+
 std::string CreateDiskRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;

ecs/src/model/CreateNetworkInterfaceRequest.cc

@@ -197,6 +197,17 @@ void CreateNetworkInterfaceRequest::setOwnerAccount(const std::string& ownerAcco
 	setParameter("OwnerAccount", ownerAccount);
 }
 
+int CreateNetworkInterfaceRequest::getQueuePairNumber()const
+{
+	return queuePairNumber_;
+}
+
+void CreateNetworkInterfaceRequest::setQueuePairNumber(int queuePairNumber)
+{
+	queuePairNumber_ = queuePairNumber;
+	setParameter("QueuePairNumber", std::to_string(queuePairNumber));
+}
+
 long CreateNetworkInterfaceRequest::getOwnerId()const
 {
 	return ownerId_;
@@ -221,6 +232,17 @@ void CreateNetworkInterfaceRequest::setSecurityGroupIds(const std::vector<std::s
 	}
 }
 
+std::string CreateNetworkInterfaceRequest::getNetworkInterfaceTrafficMode()const
+{
+	return networkInterfaceTrafficMode_;
+}
+
+void CreateNetworkInterfaceRequest::setNetworkInterfaceTrafficMode(const std::string& networkInterfaceTrafficMode)
+{
+	networkInterfaceTrafficMode_ = networkInterfaceTrafficMode;
+	setParameter("NetworkInterfaceTrafficMode", networkInterfaceTrafficMode);
+}
+
 std::string CreateNetworkInterfaceRequest::getVSwitchId()const
 {
 	return vSwitchId_;

ecs/src/model/DeleteDiskReplicaPairRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * 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/DeleteDiskReplicaPairRequest.h>
+
+using AlibabaCloud::Ecs::Model::DeleteDiskReplicaPairRequest;
+
+DeleteDiskReplicaPairRequest::DeleteDiskReplicaPairRequest() :
+	RpcServiceRequest("ecs", "2014-05-26", "DeleteDiskReplicaPair")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteDiskReplicaPairRequest::~DeleteDiskReplicaPairRequest()
+{}
+
+long DeleteDiskReplicaPairRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DeleteDiskReplicaPairRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DeleteDiskReplicaPairRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteDiskReplicaPairRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DeleteDiskReplicaPairRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DeleteDiskReplicaPairRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DeleteDiskReplicaPairRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DeleteDiskReplicaPairRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DeleteDiskReplicaPairRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DeleteDiskReplicaPairRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DeleteDiskReplicaPairRequest::getReplicaPairId()const
+{
+	return replicaPairId_;
+}
+
+void DeleteDiskReplicaPairRequest::setReplicaPairId(const std::string& replicaPairId)
+{
+	replicaPairId_ = replicaPairId;
+	setParameter("ReplicaPairId", replicaPairId);
+}
+

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

ecs/src/model/DescribeCloudAssistantStatusResult.cc

@@ -57,6 +57,8 @@ void DescribeCloudAssistantStatusResult::parse(const std::string &payload)
 			instanceCloudAssistantStatusSetObject.activeTaskCount = std::stol(valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["ActiveTaskCount"].asString());
 		if(!valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["LastInvokedTime"].isNull())
 			instanceCloudAssistantStatusSetObject.lastInvokedTime = valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["LastInvokedTime"].asString();
+		if(!valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["LastHeartbeatTime"].isNull())
+			instanceCloudAssistantStatusSetObject.lastHeartbeatTime = valueInstanceCloudAssistantStatusSetInstanceCloudAssistantStatus["LastHeartbeatTime"].asString();
 		instanceCloudAssistantStatusSet_.push_back(instanceCloudAssistantStatusSetObject);
 	}
 	if(!value["TotalCount"].isNull())

ecs/src/model/DescribeDedicatedBlockStorageClustersRequest.cc

@@ -0,0 +1,154 @@
+/*
+ * 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/DescribeDedicatedBlockStorageClustersRequest.h>
+
+using AlibabaCloud::Ecs::Model::DescribeDedicatedBlockStorageClustersRequest;
+
+DescribeDedicatedBlockStorageClustersRequest::DescribeDedicatedBlockStorageClustersRequest() :
+	RpcServiceRequest("ecs", "2014-05-26", "DescribeDedicatedBlockStorageClusters")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDedicatedBlockStorageClustersRequest::~DescribeDedicatedBlockStorageClustersRequest()
+{}
+
+long DescribeDedicatedBlockStorageClustersRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeDedicatedBlockStorageClustersRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeDedicatedBlockStorageClustersRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeDedicatedBlockStorageClustersRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DescribeDedicatedBlockStorageClustersRequest::getNextToken()const
+{
+	return nextToken_;
+}
+
+void DescribeDedicatedBlockStorageClustersRequest::setNextToken(const std::string& nextToken)
+{
+	nextToken_ = nextToken;
+	setParameter("NextToken", nextToken);
+}
+
+std::vector<std::string> DescribeDedicatedBlockStorageClustersRequest::getDedicatedBlockStorageClusterId()const
+{
+	return dedicatedBlockStorageClusterId_;
+}
+
+void DescribeDedicatedBlockStorageClustersRequest::setDedicatedBlockStorageClusterId(const std::vector<std::string>& dedicatedBlockStorageClusterId)
+{
+	dedicatedBlockStorageClusterId_ = dedicatedBlockStorageClusterId;
+	for(int dep1 = 0; dep1!= dedicatedBlockStorageClusterId.size(); dep1++) {
+		setParameter("DedicatedBlockStorageClusterId."+ std::to_string(dep1), dedicatedBlockStorageClusterId.at(dep1));
+	}
+}
+
+std::string DescribeDedicatedBlockStorageClustersRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeDedicatedBlockStorageClustersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeDedicatedBlockStorageClustersRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeDedicatedBlockStorageClustersRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DescribeDedicatedBlockStorageClustersRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDedicatedBlockStorageClustersRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeDedicatedBlockStorageClustersRequest::getZoneId()const
+{
+	return zoneId_;
+}
+
+void DescribeDedicatedBlockStorageClustersRequest::setZoneId(const std::string& zoneId)
+{
+	zoneId_ = zoneId;
+	setParameter("ZoneId", zoneId);
+}
+
+int DescribeDedicatedBlockStorageClustersRequest::getMaxResults()const
+{
+	return maxResults_;
+}
+
+void DescribeDedicatedBlockStorageClustersRequest::setMaxResults(int maxResults)
+{
+	maxResults_ = maxResults;
+	setParameter("MaxResults", std::to_string(maxResults));
+}
+
+std::string DescribeDedicatedBlockStorageClustersRequest::getCategory()const
+{
+	return category_;
+}
+
+void DescribeDedicatedBlockStorageClustersRequest::setCategory(const std::string& category)
+{
+	category_ = category;
+	setParameter("Category", category);
+}
+
+std::vector<std::string> DescribeDedicatedBlockStorageClustersRequest::getStatus()const
+{
+	return status_;
+}
+
+void DescribeDedicatedBlockStorageClustersRequest::setStatus(const std::vector<std::string>& status)
+{
+	status_ = status;
+	for(int dep1 = 0; dep1!= status.size(); dep1++) {
+		setParameter("Status."+ std::to_string(dep1), status.at(dep1));
+	}
+}
+

ecs/src/model/DescribeDedicatedBlockStorageClustersResult.cc

@@ -0,0 +1,85 @@
+/*
+ * 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/DescribeDedicatedBlockStorageClustersResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecs;
+using namespace AlibabaCloud::Ecs::Model;
+
+DescribeDedicatedBlockStorageClustersResult::DescribeDedicatedBlockStorageClustersResult() :
+	ServiceResult()
+{}
+
+DescribeDedicatedBlockStorageClustersResult::DescribeDedicatedBlockStorageClustersResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDedicatedBlockStorageClustersResult::~DescribeDedicatedBlockStorageClustersResult()
+{}
+
+void DescribeDedicatedBlockStorageClustersResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDedicatedBlockStorageClustersNode = value["DedicatedBlockStorageClusters"]["DedicatedBlockStorageCluster"];
+	for (auto valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster : allDedicatedBlockStorageClustersNode)
+	{
+		DedicatedBlockStorageCluster dedicatedBlockStorageClustersObject;
+		if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["DedicatedBlockStorageClusterId"].isNull())
+			dedicatedBlockStorageClustersObject.dedicatedBlockStorageClusterId = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["DedicatedBlockStorageClusterId"].asString();
+		if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["DedicatedBlockStorageClusterName"].isNull())
+			dedicatedBlockStorageClustersObject.dedicatedBlockStorageClusterName = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["DedicatedBlockStorageClusterName"].asString();
+		if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Description"].isNull())
+			dedicatedBlockStorageClustersObject.description = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Description"].asString();
+		if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["ZoneId"].isNull())
+			dedicatedBlockStorageClustersObject.zoneId = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["ZoneId"].asString();
+		if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Status"].isNull())
+			dedicatedBlockStorageClustersObject.status = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Status"].asString();
+		if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Category"].isNull())
+			dedicatedBlockStorageClustersObject.category = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["Category"].asString();
+		if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["PerformanceLevel"].isNull())
+			dedicatedBlockStorageClustersObject.performanceLevel = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["PerformanceLevel"].asString();
+		if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["ExpiredTime"].isNull())
+			dedicatedBlockStorageClustersObject.expiredTime = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["ExpiredTime"].asString();
+		if(!valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["CreateTime"].isNull())
+			dedicatedBlockStorageClustersObject.createTime = valueDedicatedBlockStorageClustersDedicatedBlockStorageCluster["CreateTime"].asString();
+		auto dedicatedBlockStorageClusterCapacityNode = value["DedicatedBlockStorageClusterCapacity"];
+		if(!dedicatedBlockStorageClusterCapacityNode["AvailableCapacity"].isNull())
+			dedicatedBlockStorageClustersObject.dedicatedBlockStorageClusterCapacity.availableCapacity = std::stol(dedicatedBlockStorageClusterCapacityNode["AvailableCapacity"].asString());
+		if(!dedicatedBlockStorageClusterCapacityNode["TotalCapacity"].isNull())
+			dedicatedBlockStorageClustersObject.dedicatedBlockStorageClusterCapacity.totalCapacity = std::stol(dedicatedBlockStorageClusterCapacityNode["TotalCapacity"].asString());
+		dedicatedBlockStorageClusters_.push_back(dedicatedBlockStorageClustersObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+
+}
+
+std::vector<DescribeDedicatedBlockStorageClustersResult::DedicatedBlockStorageCluster> DescribeDedicatedBlockStorageClustersResult::getDedicatedBlockStorageClusters()const
+{
+	return dedicatedBlockStorageClusters_;
+}
+
+std::string DescribeDedicatedBlockStorageClustersResult::getNextToken()const
+{
+	return nextToken_;
+}
+

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

ecs/src/model/DescribeDiskReplicaPairsResult.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/DescribeDiskReplicaPairsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ecs;
+using namespace AlibabaCloud::Ecs::Model;
+
+DescribeDiskReplicaPairsResult::DescribeDiskReplicaPairsResult() :
+	ServiceResult()
+{}
+
+DescribeDiskReplicaPairsResult::DescribeDiskReplicaPairsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDiskReplicaPairsResult::~DescribeDiskReplicaPairsResult()
+{}
+
+void DescribeDiskReplicaPairsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDiskReplicaPairsNode = value["DiskReplicaPairs"]["DiskReplicaPair"];
+	for (auto valueDiskReplicaPairsDiskReplicaPair : allDiskReplicaPairsNode)
+	{
+		DiskReplicaPair diskReplicaPairsObject;
+		if(!valueDiskReplicaPairsDiskReplicaPair["ReplicaPairId"].isNull())
+			diskReplicaPairsObject.replicaPairId = valueDiskReplicaPairsDiskReplicaPair["ReplicaPairId"].asString();
+		if(!valueDiskReplicaPairsDiskReplicaPair["SourceRegion"].isNull())
+			diskReplicaPairsObject.sourceRegion = valueDiskReplicaPairsDiskReplicaPair["SourceRegion"].asString();
+		if(!valueDiskReplicaPairsDiskReplicaPair["SourceDiskId"].isNull())
+			diskReplicaPairsObject.sourceDiskId = valueDiskReplicaPairsDiskReplicaPair["SourceDiskId"].asString();
+		if(!valueDiskReplicaPairsDiskReplicaPair["DestinationRegion"].isNull())
+			diskReplicaPairsObject.destinationRegion = valueDiskReplicaPairsDiskReplicaPair["DestinationRegion"].asString();
+		if(!valueDiskReplicaPairsDiskReplicaPair["DestinationDiskId"].isNull())
+			diskReplicaPairsObject.destinationDiskId = valueDiskReplicaPairsDiskReplicaPair["DestinationDiskId"].asString();
+		if(!valueDiskReplicaPairsDiskReplicaPair["PairName"].isNull())
+			diskReplicaPairsObject.pairName = valueDiskReplicaPairsDiskReplicaPair["PairName"].asString();
+		if(!valueDiskReplicaPairsDiskReplicaPair["Description"].isNull())
+			diskReplicaPairsObject.description = valueDiskReplicaPairsDiskReplicaPair["Description"].asString();
+		if(!valueDiskReplicaPairsDiskReplicaPair["Status"].isNull())
+			diskReplicaPairsObject.status = valueDiskReplicaPairsDiskReplicaPair["Status"].asString();
+		diskReplicaPairs_.push_back(diskReplicaPairsObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+
+}
+
+std::string DescribeDiskReplicaPairsResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::vector<DescribeDiskReplicaPairsResult::DiskReplicaPair> DescribeDiskReplicaPairsResult::getDiskReplicaPairs()const
+{
+	return diskReplicaPairs_;
+}
+

ecs/src/model/DescribeDisksResult.cc

@@ -117,6 +117,8 @@ void DescribeDisksResult::parse(const std::string &payload)
 			disksObject.bdfId = valueDisksDisk["BdfId"].asString();
 		if(!valueDisksDisk["SerialNumber"].isNull())
 			disksObject.serialNumber = valueDisksDisk["SerialNumber"].asString();
+		if(!valueDisksDisk["DedicatedBlockStorageClusterId"].isNull())
+			disksObject.dedicatedBlockStorageClusterId = valueDisksDisk["DedicatedBlockStorageClusterId"].asString();
 		auto allOperationLocksNode = valueDisksDisk["OperationLocks"]["OperationLock"];
 		for (auto valueDisksDiskOperationLocksOperationLock : allOperationLocksNode)
 		{

ecs/src/model/DescribeInstanceHistoryEventsRequest.cc

@@ -130,6 +130,19 @@ void DescribeInstanceHistoryEventsRequest::setEventPublishTimeEnd(const std::str
 	setParameter("EventPublishTimeEnd", eventPublishTimeEnd);
 }
 
+std::vector<std::string> DescribeInstanceHistoryEventsRequest::getResourceId()const
+{
+	return resourceId_;
+}
+
+void DescribeInstanceHistoryEventsRequest::setResourceId(const std::vector<std::string>& resourceId)
+{
+	resourceId_ = resourceId;
+	for(int dep1 = 0; dep1!= resourceId.size(); dep1++) {
+		setParameter("ResourceId."+ std::to_string(dep1), resourceId.at(dep1));
+	}
+}
+
 std::vector<std::string> DescribeInstanceHistoryEventsRequest::getInstanceEventType()const
 {
 	return instanceEventType_;
@@ -187,6 +200,17 @@ void DescribeInstanceHistoryEventsRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
+std::string DescribeInstanceHistoryEventsRequest::getResourceType()const
+{
+	return resourceType_;
+}
+
+void DescribeInstanceHistoryEventsRequest::setResourceType(const std::string& resourceType)
+{
+	resourceType_ = resourceType;
+	setParameter("ResourceType", resourceType);
+}
+
 std::string DescribeInstanceHistoryEventsRequest::getEventPublishTimeStart()const
 {
 	return eventPublishTimeStart_;

ecs/src/model/DescribeInstanceHistoryEventsResult.cc

@@ -57,6 +57,8 @@ void DescribeInstanceHistoryEventsResult::parse(const std::string &payload)
 			instanceSystemEventSetObject.reason = valueInstanceSystemEventSetInstanceSystemEventType["Reason"].asString();
 		if(!valueInstanceSystemEventSetInstanceSystemEventType["ImpactLevel"].isNull())
 			instanceSystemEventSetObject.impactLevel = valueInstanceSystemEventSetInstanceSystemEventType["ImpactLevel"].asString();
+		if(!valueInstanceSystemEventSetInstanceSystemEventType["ResourceType"].isNull())
+			instanceSystemEventSetObject.resourceType = valueInstanceSystemEventSetInstanceSystemEventType["ResourceType"].asString();
 		auto eventTypeNode = value["EventType"];
 		if(!eventTypeNode["Code"].isNull())
 			instanceSystemEventSetObject.eventType.code = std::stoi(eventTypeNode["Code"].asString());

ecs/src/model/DescribeInstanceTypesResult.cc

@@ -95,6 +95,12 @@ void DescribeInstanceTypesResult::parse(const std::string &payload)
 			instanceTypesObject.secondaryEniQueueNumber = std::stoi(valueInstanceTypesInstanceType["SecondaryEniQueueNumber"].asString());
 		if(!valueInstanceTypesInstanceType["DiskQuantity"].isNull())
 			instanceTypesObject.diskQuantity = std::stoi(valueInstanceTypesInstanceType["DiskQuantity"].asString());
+		if(!valueInstanceTypesInstanceType["EriQuantity"].isNull())
+			instanceTypesObject.eriQuantity = std::stoi(valueInstanceTypesInstanceType["EriQuantity"].asString());
+		if(!valueInstanceTypesInstanceType["QueuePairNumber"].isNull())
+			instanceTypesObject.queuePairNumber = std::stoi(valueInstanceTypesInstanceType["QueuePairNumber"].asString());
+		if(!valueInstanceTypesInstanceType["NvmeSupport"].isNull())
+			instanceTypesObject.nvmeSupport = valueInstanceTypesInstanceType["NvmeSupport"].asString();
 		instanceTypes_.push_back(instanceTypesObject);
 	}
 

ecs/src/model/DescribeInvocationsResult.cc

@@ -59,6 +59,8 @@ void DescribeInvocationsResult::parse(const std::string &payload)
 			invocationsObject.frequency = valueInvocationsInvocation["Frequency"].asString();
 		if(!valueInvocationsInvocation["Timed"].isNull())
 			invocationsObject.timed = valueInvocationsInvocation["Timed"].asString() == "true";
+		if(!valueInvocationsInvocation["RepeatMode"].isNull())
+			invocationsObject.repeatMode = valueInvocationsInvocation["RepeatMode"].asString();
 		if(!valueInvocationsInvocation["InvokeStatus"].isNull())
 			invocationsObject.invokeStatus = valueInvocationsInvocation["InvokeStatus"].asString();
 		if(!valueInvocationsInvocation["InvocationStatus"].isNull())
@@ -75,6 +77,8 @@ void DescribeInvocationsResult::parse(const std::string &payload)
 				invokeInstancesObject.instanceId = valueInvocationsInvocationInvokeInstancesInvokeInstance["InstanceId"].asString();
 			if(!valueInvocationsInvocationInvokeInstancesInvokeInstance["Repeats"].isNull())
 				invokeInstancesObject.repeats = std::stoi(valueInvocationsInvocationInvokeInstancesInvokeInstance["Repeats"].asString());
+			if(!valueInvocationsInvocationInvokeInstancesInvokeInstance["Timed"].isNull())
+				invokeInstancesObject.timed = valueInvocationsInvocationInvokeInstancesInvokeInstance["Timed"].asString() == "true";
 			if(!valueInvocationsInvocationInvokeInstancesInvokeInstance["InstanceInvokeStatus"].isNull())
 				invokeInstancesObject.instanceInvokeStatus = valueInvocationsInvocationInvokeInstancesInvokeInstance["InstanceInvokeStatus"].asString();
 			if(!valueInvocationsInvocationInvokeInstancesInvokeInstance["InvocationStatus"].isNull())

ecs/src/model/DescribeNetworkInterfaceAttributeResult.cc

@@ -124,14 +124,13 @@ void DescribeNetworkInterfaceAttributeResult::parse(const std::string &payload)
 		queueNumber_ = std::stoi(value["QueueNumber"].asString());
 	if(!value["OwnerId"].isNull())
 		ownerId_ = value["OwnerId"].asString();
+	if(!value["NetworkInterfaceTrafficMode"].isNull())
+		networkInterfaceTrafficMode_ = value["NetworkInterfaceTrafficMode"].asString();
+	if(!value["QueuePairNumber"].isNull())
+		queuePairNumber_ = std::stoi(value["QueuePairNumber"].asString());
 
 }
 
-std::string DescribeNetworkInterfaceAttributeResult::getStatus()const
-{
-	return status_;
-}
-
 std::string DescribeNetworkInterfaceAttributeResult::getPrivateIpAddress()const
 {
 	return privateIpAddress_;
@@ -142,11 +141,6 @@ std::string DescribeNetworkInterfaceAttributeResult::getDescription()const
 	return description_;
 }
 
-std::string DescribeNetworkInterfaceAttributeResult::getZoneId()const
-{
-	return zoneId_;
-}
-
 std::string DescribeNetworkInterfaceAttributeResult::getResourceGroupId()const
 {
 	return resourceGroupId_;
@@ -157,29 +151,64 @@ bool DescribeNetworkInterfaceAttributeResult::getServiceManaged()const
 	return serviceManaged_;
 }
 
-std::string DescribeNetworkInterfaceAttributeResult::getInstanceId()const
+DescribeNetworkInterfaceAttributeResult::Attachment DescribeNetworkInterfaceAttributeResult::getAttachment()const
 {
-	return instanceId_;
+	return attachment_;
 }
 
-std::string DescribeNetworkInterfaceAttributeResult::getVSwitchId()const
+std::string DescribeNetworkInterfaceAttributeResult::getNetworkInterfaceId()const
 {
-	return vSwitchId_;
+	return networkInterfaceId_;
 }
 
-std::string DescribeNetworkInterfaceAttributeResult::getNetworkInterfaceName()const
+std::vector<DescribeNetworkInterfaceAttributeResult::Ipv6Set> DescribeNetworkInterfaceAttributeResult::getIpv6Sets()const
 {
-	return networkInterfaceName_;
+	return ipv6Sets_;
 }
 
-DescribeNetworkInterfaceAttributeResult::Attachment DescribeNetworkInterfaceAttributeResult::getAttachment()const
+std::string DescribeNetworkInterfaceAttributeResult::getOwnerId()const
 {
-	return attachment_;
+	return ownerId_;
 }
 
-std::string DescribeNetworkInterfaceAttributeResult::getNetworkInterfaceId()const
+DescribeNetworkInterfaceAttributeResult::AssociatedPublicIp DescribeNetworkInterfaceAttributeResult::getAssociatedPublicIp()const
 {
-	return networkInterfaceId_;
+	return associatedPublicIp_;
+}
+
+std::vector<DescribeNetworkInterfaceAttributeResult::Tag> DescribeNetworkInterfaceAttributeResult::getTags()const
+{
+	return tags_;
+}
+
+std::string DescribeNetworkInterfaceAttributeResult::getStatus()const
+{
+	return status_;
+}
+
+std::string DescribeNetworkInterfaceAttributeResult::getNetworkInterfaceTrafficMode()const
+{
+	return networkInterfaceTrafficMode_;
+}
+
+std::string DescribeNetworkInterfaceAttributeResult::getZoneId()const
+{
+	return zoneId_;
+}
+
+std::string DescribeNetworkInterfaceAttributeResult::getInstanceId()const
+{
+	return instanceId_;
+}
+
+std::string DescribeNetworkInterfaceAttributeResult::getVSwitchId()const
+{
+	return vSwitchId_;
+}
+
+std::string DescribeNetworkInterfaceAttributeResult::getNetworkInterfaceName()const
+{
+	return networkInterfaceName_;
 }
 
 std::string DescribeNetworkInterfaceAttributeResult::getMacAddress()const
@@ -202,29 +231,19 @@ std::string DescribeNetworkInterfaceAttributeResult::getType()const
 	return type_;
 }
 
-std::vector<DescribeNetworkInterfaceAttributeResult::Ipv6Set> DescribeNetworkInterfaceAttributeResult::getIpv6Sets()const
-{
-	return ipv6Sets_;
-}
-
 int DescribeNetworkInterfaceAttributeResult::getQueueNumber()const
 {
 	return queueNumber_;
 }
 
-std::string DescribeNetworkInterfaceAttributeResult::getVpcId()const
+int DescribeNetworkInterfaceAttributeResult::getQueuePairNumber()const
 {
-	return vpcId_;
+	return queuePairNumber_;
 }
 
-std::string DescribeNetworkInterfaceAttributeResult::getOwnerId()const
-{
-	return ownerId_;
-}
-
-DescribeNetworkInterfaceAttributeResult::AssociatedPublicIp DescribeNetworkInterfaceAttributeResult::getAssociatedPublicIp()const
+std::string DescribeNetworkInterfaceAttributeResult::getVpcId()const
 {
-	return associatedPublicIp_;
+	return vpcId_;
 }
 
 std::string DescribeNetworkInterfaceAttributeResult::getCreationTime()const
@@ -232,11 +251,6 @@ std::string DescribeNetworkInterfaceAttributeResult::getCreationTime()const
 	return creationTime_;
 }
 
-std::vector<DescribeNetworkInterfaceAttributeResult::Tag> DescribeNetworkInterfaceAttributeResult::getTags()const
-{
-	return tags_;
-}
-
 std::vector<DescribeNetworkInterfaceAttributeResult::PrivateIpSet> DescribeNetworkInterfaceAttributeResult::getPrivateIpSets()const
 {
 	return privateIpSets_;

ecs/src/model/DescribeNetworkInterfacesResult.cc

@@ -77,6 +77,10 @@ void DescribeNetworkInterfacesResult::parse(const std::string &payload)
 			networkInterfaceSetsObject.queueNumber = std::stoi(valueNetworkInterfaceSetsNetworkInterfaceSet["QueueNumber"].asString());
 		if(!valueNetworkInterfaceSetsNetworkInterfaceSet["OwnerId"].isNull())
 			networkInterfaceSetsObject.ownerId = valueNetworkInterfaceSetsNetworkInterfaceSet["OwnerId"].asString();
+		if(!valueNetworkInterfaceSetsNetworkInterfaceSet["NetworkInterfaceTrafficMode"].isNull())
+			networkInterfaceSetsObject.networkInterfaceTrafficMode = valueNetworkInterfaceSetsNetworkInterfaceSet["NetworkInterfaceTrafficMode"].asString();
+		if(!valueNetworkInterfaceSetsNetworkInterfaceSet["QueuePairNumber"].isNull())
+			networkInterfaceSetsObject.queuePairNumber = std::stoi(valueNetworkInterfaceSetsNetworkInterfaceSet["QueuePairNumber"].asString());
 		auto allPrivateIpSetsNode = valueNetworkInterfaceSetsNetworkInterfaceSet["PrivateIpSets"]["PrivateIpSet"];
 		for (auto valueNetworkInterfaceSetsNetworkInterfaceSetPrivateIpSetsPrivateIpSet : allPrivateIpSetsNode)
 		{

ecs/src/model/InvokeCommandRequest.cc

@@ -71,6 +71,17 @@ void InvokeCommandRequest::setRegionId(const std::string& regionId)
 	setParameter("RegionId", regionId);
 }
 
+std::string InvokeCommandRequest::getRepeatMode()const
+{
+	return repeatMode_;
+}
+
+void InvokeCommandRequest::setRepeatMode(const std::string& repeatMode)
+{
+	repeatMode_ = repeatMode;
+	setParameter("RepeatMode", repeatMode);
+}
+
 std::string InvokeCommandRequest::getWindowsPasswordName()const
 {
 	return windowsPasswordName_;

ecs/src/model/ModifyDiskAttributeRequest.cc

@@ -71,6 +71,17 @@ void ModifyDiskAttributeRequest::setDeleteAutoSnapshot(bool deleteAutoSnapshot)
 	setParameter("DeleteAutoSnapshot", deleteAutoSnapshot ? "true" : "false");
 }
 
+std::string ModifyDiskAttributeRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ModifyDiskAttributeRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
 std::vector<std::string> ModifyDiskAttributeRequest::getDiskIds()const
 {
 	return diskIds_;

ecs/src/model/RunCommandRequest.cc

@@ -126,6 +126,17 @@ void RunCommandRequest::setContentEncoding(const std::string& contentEncoding)
 	setParameter("ContentEncoding", contentEncoding);
 }
 
+std::string RunCommandRequest::getRepeatMode()const
+{
+	return repeatMode_;
+}
+
+void RunCommandRequest::setRepeatMode(const std::string& repeatMode)
+{
+	repeatMode_ = repeatMode;
+	setParameter("RepeatMode", repeatMode);
+}
+
 std::string RunCommandRequest::getWindowsPasswordName()const
 {
 	return windowsPasswordName_;

ecs/src/model/StartDiskReplicaPairRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * 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/StartDiskReplicaPairRequest.h>
+
+using AlibabaCloud::Ecs::Model::StartDiskReplicaPairRequest;
+
+StartDiskReplicaPairRequest::StartDiskReplicaPairRequest() :
+	RpcServiceRequest("ecs", "2014-05-26", "StartDiskReplicaPair")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+StartDiskReplicaPairRequest::~StartDiskReplicaPairRequest()
+{}
+
+long StartDiskReplicaPairRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void StartDiskReplicaPairRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string StartDiskReplicaPairRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void StartDiskReplicaPairRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string StartDiskReplicaPairRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void StartDiskReplicaPairRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string StartDiskReplicaPairRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void StartDiskReplicaPairRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long StartDiskReplicaPairRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void StartDiskReplicaPairRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string StartDiskReplicaPairRequest::getReplicaPairId()const
+{
+	return replicaPairId_;
+}
+
+void StartDiskReplicaPairRequest::setReplicaPairId(const std::string& replicaPairId)
+{
+	replicaPairId_ = replicaPairId;
+	setParameter("ReplicaPairId", replicaPairId);
+}
+

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

ecs/src/model/StopDiskReplicaPairRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * 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/StopDiskReplicaPairRequest.h>
+
+using AlibabaCloud::Ecs::Model::StopDiskReplicaPairRequest;
+
+StopDiskReplicaPairRequest::StopDiskReplicaPairRequest() :
+	RpcServiceRequest("ecs", "2014-05-26", "StopDiskReplicaPair")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+StopDiskReplicaPairRequest::~StopDiskReplicaPairRequest()
+{}
+
+long StopDiskReplicaPairRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void StopDiskReplicaPairRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string StopDiskReplicaPairRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void StopDiskReplicaPairRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string StopDiskReplicaPairRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void StopDiskReplicaPairRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string StopDiskReplicaPairRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void StopDiskReplicaPairRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long StopDiskReplicaPairRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void StopDiskReplicaPairRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string StopDiskReplicaPairRequest::getReplicaPairId()const
+{
+	return replicaPairId_;
+}
+
+void StopDiskReplicaPairRequest::setReplicaPairId(const std::string& replicaPairId)
+{
+	replicaPairId_ = replicaPairId;
+	setParameter("ReplicaPairId", replicaPairId);
+}
+

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