Supported all language sdk.

CHANGELOG

@@ -1,3 +1,7 @@
+2020-12-03 Version: patch
+- Supported all language sdk.
+- Fixed some bugs for polardbx.
+
 2020-12-03 Version: patch
 - Update DetectLungNodule.
 

polardbx/CMakeLists.txt

@@ -23,6 +23,8 @@ set(polardbx_public_header
 set(polardbx_public_header_model 
 	include/alibabacloud/polardbx/model/AllocateInstancePublicConnectionRequest.h
 	include/alibabacloud/polardbx/model/AllocateInstancePublicConnectionResult.h
+	include/alibabacloud/polardbx/model/CancelPolarxOrderRequest.h
+	include/alibabacloud/polardbx/model/CancelPolarxOrderResult.h
 	include/alibabacloud/polardbx/model/CheckHealthRequest.h
 	include/alibabacloud/polardbx/model/CheckHealthResult.h
 	include/alibabacloud/polardbx/model/CreateAccountRequest.h
@@ -33,6 +35,8 @@ set(polardbx_public_header_model
 	include/alibabacloud/polardbx/model/CreateDBInstanceResult.h
 	include/alibabacloud/polardbx/model/CreatePolarxInstanceRequest.h
 	include/alibabacloud/polardbx/model/CreatePolarxInstanceResult.h
+	include/alibabacloud/polardbx/model/CreatePolarxOrderRequest.h
+	include/alibabacloud/polardbx/model/CreatePolarxOrderResult.h
 	include/alibabacloud/polardbx/model/CreateSuperAccountRequest.h
 	include/alibabacloud/polardbx/model/CreateSuperAccountResult.h
 	include/alibabacloud/polardbx/model/DeleteAccountRequest.h
@@ -85,6 +89,10 @@ set(polardbx_public_header_model
 	include/alibabacloud/polardbx/model/DisableSqlAuditResult.h
 	include/alibabacloud/polardbx/model/EnableSqlAuditRequest.h
 	include/alibabacloud/polardbx/model/EnableSqlAuditResult.h
+	include/alibabacloud/polardbx/model/GetPolarXPriceRequest.h
+	include/alibabacloud/polardbx/model/GetPolarXPriceResult.h
+	include/alibabacloud/polardbx/model/GetPolarxCommodityRequest.h
+	include/alibabacloud/polardbx/model/GetPolarxCommodityResult.h
 	include/alibabacloud/polardbx/model/ModifyAccountDescriptionRequest.h
 	include/alibabacloud/polardbx/model/ModifyAccountDescriptionResult.h
 	include/alibabacloud/polardbx/model/ModifyAccountPrivilegeRequest.h
@@ -111,6 +119,10 @@ set(polardbx_public_header_model
 	include/alibabacloud/polardbx/model/ResetPolarxPgAccountPasswordResult.h
 	include/alibabacloud/polardbx/model/RestartDBInstanceRequest.h
 	include/alibabacloud/polardbx/model/RestartDBInstanceResult.h
+	include/alibabacloud/polardbx/model/RetryPolarxOrderRequest.h
+	include/alibabacloud/polardbx/model/RetryPolarxOrderResult.h
+	include/alibabacloud/polardbx/model/UpdatePolarDBXInstanceNodeRequest.h
+	include/alibabacloud/polardbx/model/UpdatePolarDBXInstanceNodeResult.h
 	include/alibabacloud/polardbx/model/UpgradeDBInstanceKernelVersionRequest.h
 	include/alibabacloud/polardbx/model/UpgradeDBInstanceKernelVersionResult.h )
 
@@ -118,6 +130,8 @@ set(polardbx_src
 	src/PolardbxClient.cc
 	src/model/AllocateInstancePublicConnectionRequest.cc
 	src/model/AllocateInstancePublicConnectionResult.cc
+	src/model/CancelPolarxOrderRequest.cc
+	src/model/CancelPolarxOrderResult.cc
 	src/model/CheckHealthRequest.cc
 	src/model/CheckHealthResult.cc
 	src/model/CreateAccountRequest.cc
@@ -128,6 +142,8 @@ set(polardbx_src
 	src/model/CreateDBInstanceResult.cc
 	src/model/CreatePolarxInstanceRequest.cc
 	src/model/CreatePolarxInstanceResult.cc
+	src/model/CreatePolarxOrderRequest.cc
+	src/model/CreatePolarxOrderResult.cc
 	src/model/CreateSuperAccountRequest.cc
 	src/model/CreateSuperAccountResult.cc
 	src/model/DeleteAccountRequest.cc
@@ -180,6 +196,10 @@ set(polardbx_src
 	src/model/DisableSqlAuditResult.cc
 	src/model/EnableSqlAuditRequest.cc
 	src/model/EnableSqlAuditResult.cc
+	src/model/GetPolarXPriceRequest.cc
+	src/model/GetPolarXPriceResult.cc
+	src/model/GetPolarxCommodityRequest.cc
+	src/model/GetPolarxCommodityResult.cc
 	src/model/ModifyAccountDescriptionRequest.cc
 	src/model/ModifyAccountDescriptionResult.cc
 	src/model/ModifyAccountPrivilegeRequest.cc
@@ -206,6 +226,10 @@ set(polardbx_src
 	src/model/ResetPolarxPgAccountPasswordResult.cc
 	src/model/RestartDBInstanceRequest.cc
 	src/model/RestartDBInstanceResult.cc
+	src/model/RetryPolarxOrderRequest.cc
+	src/model/RetryPolarxOrderResult.cc
+	src/model/UpdatePolarDBXInstanceNodeRequest.cc
+	src/model/UpdatePolarDBXInstanceNodeResult.cc
 	src/model/UpgradeDBInstanceKernelVersionRequest.cc
 	src/model/UpgradeDBInstanceKernelVersionResult.cc )
 

polardbx/include/alibabacloud/polardbx/PolardbxClient.h

@@ -24,6 +24,8 @@
 #include "PolardbxExport.h"
 #include "model/AllocateInstancePublicConnectionRequest.h"
 #include "model/AllocateInstancePublicConnectionResult.h"
+#include "model/CancelPolarxOrderRequest.h"
+#include "model/CancelPolarxOrderResult.h"
 #include "model/CheckHealthRequest.h"
 #include "model/CheckHealthResult.h"
 #include "model/CreateAccountRequest.h"
@@ -34,6 +36,8 @@
 #include "model/CreateDBInstanceResult.h"
 #include "model/CreatePolarxInstanceRequest.h"
 #include "model/CreatePolarxInstanceResult.h"
+#include "model/CreatePolarxOrderRequest.h"
+#include "model/CreatePolarxOrderResult.h"
 #include "model/CreateSuperAccountRequest.h"
 #include "model/CreateSuperAccountResult.h"
 #include "model/DeleteAccountRequest.h"
@@ -86,6 +90,10 @@
 #include "model/DisableSqlAuditResult.h"
 #include "model/EnableSqlAuditRequest.h"
 #include "model/EnableSqlAuditResult.h"
+#include "model/GetPolarXPriceRequest.h"
+#include "model/GetPolarXPriceResult.h"
+#include "model/GetPolarxCommodityRequest.h"
+#include "model/GetPolarxCommodityResult.h"
 #include "model/ModifyAccountDescriptionRequest.h"
 #include "model/ModifyAccountDescriptionResult.h"
 #include "model/ModifyAccountPrivilegeRequest.h"
@@ -112,6 +120,10 @@
 #include "model/ResetPolarxPgAccountPasswordResult.h"
 #include "model/RestartDBInstanceRequest.h"
 #include "model/RestartDBInstanceResult.h"
+#include "model/RetryPolarxOrderRequest.h"
+#include "model/RetryPolarxOrderResult.h"
+#include "model/UpdatePolarDBXInstanceNodeRequest.h"
+#include "model/UpdatePolarDBXInstanceNodeResult.h"
 #include "model/UpgradeDBInstanceKernelVersionRequest.h"
 #include "model/UpgradeDBInstanceKernelVersionResult.h"
 
@@ -126,6 +138,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::AllocateInstancePublicConnectionResult> AllocateInstancePublicConnectionOutcome;
 			typedef std::future<AllocateInstancePublicConnectionOutcome> AllocateInstancePublicConnectionOutcomeCallable;
 			typedef std::function<void(const PolardbxClient*, const Model::AllocateInstancePublicConnectionRequest&, const AllocateInstancePublicConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AllocateInstancePublicConnectionAsyncHandler;
+			typedef Outcome<Error, Model::CancelPolarxOrderResult> CancelPolarxOrderOutcome;
+			typedef std::future<CancelPolarxOrderOutcome> CancelPolarxOrderOutcomeCallable;
+			typedef std::function<void(const PolardbxClient*, const Model::CancelPolarxOrderRequest&, const CancelPolarxOrderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CancelPolarxOrderAsyncHandler;
 			typedef Outcome<Error, Model::CheckHealthResult> CheckHealthOutcome;
 			typedef std::future<CheckHealthOutcome> CheckHealthOutcomeCallable;
 			typedef std::function<void(const PolardbxClient*, const Model::CheckHealthRequest&, const CheckHealthOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckHealthAsyncHandler;
@@ -141,6 +156,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreatePolarxInstanceResult> CreatePolarxInstanceOutcome;
 			typedef std::future<CreatePolarxInstanceOutcome> CreatePolarxInstanceOutcomeCallable;
 			typedef std::function<void(const PolardbxClient*, const Model::CreatePolarxInstanceRequest&, const CreatePolarxInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreatePolarxInstanceAsyncHandler;
+			typedef Outcome<Error, Model::CreatePolarxOrderResult> CreatePolarxOrderOutcome;
+			typedef std::future<CreatePolarxOrderOutcome> CreatePolarxOrderOutcomeCallable;
+			typedef std::function<void(const PolardbxClient*, const Model::CreatePolarxOrderRequest&, const CreatePolarxOrderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreatePolarxOrderAsyncHandler;
 			typedef Outcome<Error, Model::CreateSuperAccountResult> CreateSuperAccountOutcome;
 			typedef std::future<CreateSuperAccountOutcome> CreateSuperAccountOutcomeCallable;
 			typedef std::function<void(const PolardbxClient*, const Model::CreateSuperAccountRequest&, const CreateSuperAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateSuperAccountAsyncHandler;
@@ -219,6 +237,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::EnableSqlAuditResult> EnableSqlAuditOutcome;
 			typedef std::future<EnableSqlAuditOutcome> EnableSqlAuditOutcomeCallable;
 			typedef std::function<void(const PolardbxClient*, const Model::EnableSqlAuditRequest&, const EnableSqlAuditOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableSqlAuditAsyncHandler;
+			typedef Outcome<Error, Model::GetPolarXPriceResult> GetPolarXPriceOutcome;
+			typedef std::future<GetPolarXPriceOutcome> GetPolarXPriceOutcomeCallable;
+			typedef std::function<void(const PolardbxClient*, const Model::GetPolarXPriceRequest&, const GetPolarXPriceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPolarXPriceAsyncHandler;
+			typedef Outcome<Error, Model::GetPolarxCommodityResult> GetPolarxCommodityOutcome;
+			typedef std::future<GetPolarxCommodityOutcome> GetPolarxCommodityOutcomeCallable;
+			typedef std::function<void(const PolardbxClient*, const Model::GetPolarxCommodityRequest&, const GetPolarxCommodityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPolarxCommodityAsyncHandler;
 			typedef Outcome<Error, Model::ModifyAccountDescriptionResult> ModifyAccountDescriptionOutcome;
 			typedef std::future<ModifyAccountDescriptionOutcome> ModifyAccountDescriptionOutcomeCallable;
 			typedef std::function<void(const PolardbxClient*, const Model::ModifyAccountDescriptionRequest&, const ModifyAccountDescriptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAccountDescriptionAsyncHandler;
@@ -258,6 +282,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::RestartDBInstanceResult> RestartDBInstanceOutcome;
 			typedef std::future<RestartDBInstanceOutcome> RestartDBInstanceOutcomeCallable;
 			typedef std::function<void(const PolardbxClient*, const Model::RestartDBInstanceRequest&, const RestartDBInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestartDBInstanceAsyncHandler;
+			typedef Outcome<Error, Model::RetryPolarxOrderResult> RetryPolarxOrderOutcome;
+			typedef std::future<RetryPolarxOrderOutcome> RetryPolarxOrderOutcomeCallable;
+			typedef std::function<void(const PolardbxClient*, const Model::RetryPolarxOrderRequest&, const RetryPolarxOrderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RetryPolarxOrderAsyncHandler;
+			typedef Outcome<Error, Model::UpdatePolarDBXInstanceNodeResult> UpdatePolarDBXInstanceNodeOutcome;
+			typedef std::future<UpdatePolarDBXInstanceNodeOutcome> UpdatePolarDBXInstanceNodeOutcomeCallable;
+			typedef std::function<void(const PolardbxClient*, const Model::UpdatePolarDBXInstanceNodeRequest&, const UpdatePolarDBXInstanceNodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdatePolarDBXInstanceNodeAsyncHandler;
 			typedef Outcome<Error, Model::UpgradeDBInstanceKernelVersionResult> UpgradeDBInstanceKernelVersionOutcome;
 			typedef std::future<UpgradeDBInstanceKernelVersionOutcome> UpgradeDBInstanceKernelVersionOutcomeCallable;
 			typedef std::function<void(const PolardbxClient*, const Model::UpgradeDBInstanceKernelVersionRequest&, const UpgradeDBInstanceKernelVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpgradeDBInstanceKernelVersionAsyncHandler;
@@ -269,6 +299,9 @@ namespace AlibabaCloud
 			AllocateInstancePublicConnectionOutcome allocateInstancePublicConnection(const Model::AllocateInstancePublicConnectionRequest &request)const;
 			void allocateInstancePublicConnectionAsync(const Model::AllocateInstancePublicConnectionRequest& request, const AllocateInstancePublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AllocateInstancePublicConnectionOutcomeCallable allocateInstancePublicConnectionCallable(const Model::AllocateInstancePublicConnectionRequest& request) const;
+			CancelPolarxOrderOutcome cancelPolarxOrder(const Model::CancelPolarxOrderRequest &request)const;
+			void cancelPolarxOrderAsync(const Model::CancelPolarxOrderRequest& request, const CancelPolarxOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CancelPolarxOrderOutcomeCallable cancelPolarxOrderCallable(const Model::CancelPolarxOrderRequest& request) const;
 			CheckHealthOutcome checkHealth(const Model::CheckHealthRequest &request)const;
 			void checkHealthAsync(const Model::CheckHealthRequest& request, const CheckHealthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CheckHealthOutcomeCallable checkHealthCallable(const Model::CheckHealthRequest& request) const;
@@ -284,6 +317,9 @@ namespace AlibabaCloud
 			CreatePolarxInstanceOutcome createPolarxInstance(const Model::CreatePolarxInstanceRequest &request)const;
 			void createPolarxInstanceAsync(const Model::CreatePolarxInstanceRequest& request, const CreatePolarxInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreatePolarxInstanceOutcomeCallable createPolarxInstanceCallable(const Model::CreatePolarxInstanceRequest& request) const;
+			CreatePolarxOrderOutcome createPolarxOrder(const Model::CreatePolarxOrderRequest &request)const;
+			void createPolarxOrderAsync(const Model::CreatePolarxOrderRequest& request, const CreatePolarxOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreatePolarxOrderOutcomeCallable createPolarxOrderCallable(const Model::CreatePolarxOrderRequest& request) const;
 			CreateSuperAccountOutcome createSuperAccount(const Model::CreateSuperAccountRequest &request)const;
 			void createSuperAccountAsync(const Model::CreateSuperAccountRequest& request, const CreateSuperAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateSuperAccountOutcomeCallable createSuperAccountCallable(const Model::CreateSuperAccountRequest& request) const;
@@ -362,6 +398,12 @@ namespace AlibabaCloud
 			EnableSqlAuditOutcome enableSqlAudit(const Model::EnableSqlAuditRequest &request)const;
 			void enableSqlAuditAsync(const Model::EnableSqlAuditRequest& request, const EnableSqlAuditAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			EnableSqlAuditOutcomeCallable enableSqlAuditCallable(const Model::EnableSqlAuditRequest& request) const;
+			GetPolarXPriceOutcome getPolarXPrice(const Model::GetPolarXPriceRequest &request)const;
+			void getPolarXPriceAsync(const Model::GetPolarXPriceRequest& request, const GetPolarXPriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetPolarXPriceOutcomeCallable getPolarXPriceCallable(const Model::GetPolarXPriceRequest& request) const;
+			GetPolarxCommodityOutcome getPolarxCommodity(const Model::GetPolarxCommodityRequest &request)const;
+			void getPolarxCommodityAsync(const Model::GetPolarxCommodityRequest& request, const GetPolarxCommodityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetPolarxCommodityOutcomeCallable getPolarxCommodityCallable(const Model::GetPolarxCommodityRequest& request) const;
 			ModifyAccountDescriptionOutcome modifyAccountDescription(const Model::ModifyAccountDescriptionRequest &request)const;
 			void modifyAccountDescriptionAsync(const Model::ModifyAccountDescriptionRequest& request, const ModifyAccountDescriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyAccountDescriptionOutcomeCallable modifyAccountDescriptionCallable(const Model::ModifyAccountDescriptionRequest& request) const;
@@ -401,6 +443,12 @@ namespace AlibabaCloud
 			RestartDBInstanceOutcome restartDBInstance(const Model::RestartDBInstanceRequest &request)const;
 			void restartDBInstanceAsync(const Model::RestartDBInstanceRequest& request, const RestartDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RestartDBInstanceOutcomeCallable restartDBInstanceCallable(const Model::RestartDBInstanceRequest& request) const;
+			RetryPolarxOrderOutcome retryPolarxOrder(const Model::RetryPolarxOrderRequest &request)const;
+			void retryPolarxOrderAsync(const Model::RetryPolarxOrderRequest& request, const RetryPolarxOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RetryPolarxOrderOutcomeCallable retryPolarxOrderCallable(const Model::RetryPolarxOrderRequest& request) const;
+			UpdatePolarDBXInstanceNodeOutcome updatePolarDBXInstanceNode(const Model::UpdatePolarDBXInstanceNodeRequest &request)const;
+			void updatePolarDBXInstanceNodeAsync(const Model::UpdatePolarDBXInstanceNodeRequest& request, const UpdatePolarDBXInstanceNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdatePolarDBXInstanceNodeOutcomeCallable updatePolarDBXInstanceNodeCallable(const Model::UpdatePolarDBXInstanceNodeRequest& request) const;
 			UpgradeDBInstanceKernelVersionOutcome upgradeDBInstanceKernelVersion(const Model::UpgradeDBInstanceKernelVersionRequest &request)const;
 			void upgradeDBInstanceKernelVersionAsync(const Model::UpgradeDBInstanceKernelVersionRequest& request, const UpgradeDBInstanceKernelVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpgradeDBInstanceKernelVersionOutcomeCallable upgradeDBInstanceKernelVersionCallable(const Model::UpgradeDBInstanceKernelVersionRequest& request) const;

polardbx/include/alibabacloud/polardbx/model/CancelPolarxOrderRequest.h

@@ -0,0 +1,54 @@
+/*
+ * 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_POLARDBX_MODEL_CANCELPOLARXORDERREQUEST_H_
+#define ALIBABACLOUD_POLARDBX_MODEL_CANCELPOLARXORDERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/polardbx/PolardbxExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardbx
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDBX_EXPORT CancelPolarxOrderRequest : public RpcServiceRequest
+			{
+
+			public:
+				CancelPolarxOrderRequest();
+				~CancelPolarxOrderRequest();
+
+				std::string getDBInstanceName()const;
+				void setDBInstanceName(const std::string& dBInstanceName);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getScaleOutToken()const;
+				void setScaleOutToken(const std::string& scaleOutToken);
+
+            private:
+				std::string dBInstanceName_;
+				std::string regionId_;
+				std::string scaleOutToken_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDBX_MODEL_CANCELPOLARXORDERREQUEST_H_

polardbx/include/alibabacloud/polardbx/model/CancelPolarxOrderResult.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_POLARDBX_MODEL_CANCELPOLARXORDERRESULT_H_
+#define ALIBABACLOUD_POLARDBX_MODEL_CANCELPOLARXORDERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/polardbx/PolardbxExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardbx
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDBX_EXPORT CancelPolarxOrderResult : public ServiceResult
+			{
+			public:
+
+
+				CancelPolarxOrderResult();
+				explicit CancelPolarxOrderResult(const std::string &payload);
+				~CancelPolarxOrderResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDBX_MODEL_CANCELPOLARXORDERRESULT_H_

polardbx/include/alibabacloud/polardbx/model/CreateDBInstanceRequest.h

@@ -35,24 +35,26 @@ namespace AlibabaCloud
 				CreateDBInstanceRequest();
 				~CreateDBInstanceRequest();
 
+				std::string getNetworkType()const;
+				void setNetworkType(const std::string& networkType);
+				std::string getEngineVersion()const;
+				void setEngineVersion(const std::string& engineVersion);
 				std::string getResourceGroupId()const;
 				void setResourceGroupId(const std::string& resourceGroupId);
 				std::string getDBNodeClass()const;
 				void setDBNodeClass(const std::string& dBNodeClass);
-				std::string getDBInstanceDescription()const;
-				void setDBInstanceDescription(const std::string& dBInstanceDescription);
 				std::string getPeriod()const;
 				void setPeriod(const std::string& period);
-				std::string getSecurityIPList()const;
-				void setSecurityIPList(const std::string& securityIPList);
+				bool getIsReadDBInstance()const;
+				void setIsReadDBInstance(bool isReadDBInstance);
 				std::string getVSwitchId()const;
 				void setVSwitchId(const std::string& vSwitchId);
 				bool getAutoRenew()const;
 				void setAutoRenew(bool autoRenew);
 				std::string getZoneId()const;
 				void setZoneId(const std::string& zoneId);
-				std::string getInstanceNetworkType()const;
-				void setInstanceNetworkType(const std::string& instanceNetworkType);
+				std::string getPrimaryDBInstanceName()const;
+				void setPrimaryDBInstanceName(const std::string& primaryDBInstanceName);
 				std::string getClientToken()const;
 				void setClientToken(const std::string& clientToken);
 				std::string getRegionId()const;
@@ -67,15 +69,16 @@ namespace AlibabaCloud
 				void setPayType(const std::string& payType);
 
             private:
+				std::string networkType_;
+				std::string engineVersion_;
 				std::string resourceGroupId_;
 				std::string dBNodeClass_;
-				std::string dBInstanceDescription_;
 				std::string period_;
-				std::string securityIPList_;
+				bool isReadDBInstance_;
 				std::string vSwitchId_;
 				bool autoRenew_;
 				std::string zoneId_;
-				std::string instanceNetworkType_;
+				std::string primaryDBInstanceName_;
 				std::string clientToken_;
 				std::string regionId_;
 				int dBNodeCount_;

polardbx/include/alibabacloud/polardbx/model/CreateDBInstanceResult.h

@@ -37,17 +37,13 @@ namespace AlibabaCloud
 				CreateDBInstanceResult();
 				explicit CreateDBInstanceResult(const std::string &payload);
 				~CreateDBInstanceResult();
-				int getPort()const;
 				std::string getOrderId()const;
-				std::string getConnectionString()const;
 				std::string getDBInstanceName()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				int port_;
 				std::string orderId_;
-				std::string connectionString_;
 				std::string dBInstanceName_;
 
 			};

polardbx/include/alibabacloud/polardbx/model/CreatePolarxOrderRequest.h

@@ -0,0 +1,54 @@
+/*
+ * 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_POLARDBX_MODEL_CREATEPOLARXORDERREQUEST_H_
+#define ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXORDERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/polardbx/PolardbxExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardbx
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDBX_EXPORT CreatePolarxOrderRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreatePolarxOrderRequest();
+				~CreatePolarxOrderRequest();
+
+				std::string getDBInstanceName()const;
+				void setDBInstanceName(const std::string& dBInstanceName);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getNodeCount()const;
+				void setNodeCount(const std::string& nodeCount);
+
+            private:
+				std::string dBInstanceName_;
+				std::string regionId_;
+				std::string nodeCount_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXORDERREQUEST_H_

polardbx/include/alibabacloud/polardbx/model/CreatePolarxOrderResult.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXORDERRESULT_H_
+#define ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXORDERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/polardbx/PolardbxExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardbx
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDBX_EXPORT CreatePolarxOrderResult : public ServiceResult
+			{
+			public:
+				struct OrderResult
+				{
+					long orderId;
+					std::string dBInstanceName;
+				};
+
+
+				CreatePolarxOrderResult();
+				explicit CreatePolarxOrderResult(const std::string &payload);
+				~CreatePolarxOrderResult();
+				std::vector<OrderResult> getOrderResultList()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<OrderResult> orderResultList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXORDERRESULT_H_

polardbx/include/alibabacloud/polardbx/model/DescribeTasksResult.h

@@ -34,13 +34,14 @@ namespace AlibabaCloud
 			public:
 				struct TaskProgressInfo
 				{
-					std::string expectedFinishTime;
+					std::string finishTime1;
 					std::string status;
 					std::string progress;
 					std::string taskId;
 					std::string finishTime;
 					std::string taskAction;
 					std::string progressInfo;
+					std::string scaleOutToken;
 					std::string dBName;
 					std::string beginTime;
 					std::string taskErrorCode;

polardbx/include/alibabacloud/polardbx/model/GetPolarXPriceRequest.h

@@ -0,0 +1,54 @@
+/*
+ * 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_POLARDBX_MODEL_GETPOLARXPRICEREQUEST_H_
+#define ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXPRICEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/polardbx/PolardbxExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardbx
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDBX_EXPORT GetPolarXPriceRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetPolarXPriceRequest();
+				~GetPolarXPriceRequest();
+
+				std::string getDBInstanceName()const;
+				void setDBInstanceName(const std::string& dBInstanceName);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getNodeCount()const;
+				void setNodeCount(const std::string& nodeCount);
+
+            private:
+				std::string dBInstanceName_;
+				std::string regionId_;
+				std::string nodeCount_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXPRICEREQUEST_H_

polardbx/include/alibabacloud/polardbx/model/GetPolarXPriceResult.h

@@ -0,0 +1,67 @@
+/*
+ * 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_POLARDBX_MODEL_GETPOLARXPRICERESULT_H_
+#define ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXPRICERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/polardbx/PolardbxExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardbx
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDBX_EXPORT GetPolarXPriceResult : public ServiceResult
+			{
+			public:
+				struct OrderPrice
+				{
+					struct Rule
+					{
+						long ruleDescId;
+						std::string title;
+						std::string name;
+					};
+					std::string totalCostAmount;
+					std::string tradeAmount;
+					std::string payType;
+					std::vector<OrderPrice::Rule> rules;
+					std::string originalAmount;
+					std::string discountAmount;
+					std::string dBInstanceName;
+				};
+
+
+				GetPolarXPriceResult();
+				explicit GetPolarXPriceResult(const std::string &payload);
+				~GetPolarXPriceResult();
+				std::vector<OrderPrice> getOrderPriceList()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<OrderPrice> orderPriceList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXPRICERESULT_H_

polardbx/include/alibabacloud/polardbx/model/GetPolarxCommodityRequest.h

@@ -0,0 +1,54 @@
+/*
+ * 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_POLARDBX_MODEL_GETPOLARXCOMMODITYREQUEST_H_
+#define ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXCOMMODITYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/polardbx/PolardbxExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardbx
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDBX_EXPORT GetPolarxCommodityRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetPolarxCommodityRequest();
+				~GetPolarxCommodityRequest();
+
+				std::string getDBInstanceName()const;
+				void setDBInstanceName(const std::string& dBInstanceName);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getOrderType()const;
+				void setOrderType(const std::string& orderType);
+
+            private:
+				std::string dBInstanceName_;
+				std::string regionId_;
+				std::string orderType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXCOMMODITYREQUEST_H_

polardbx/include/alibabacloud/polardbx/model/GetPolarxCommodityResult.h

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXCOMMODITYRESULT_H_
+#define ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXCOMMODITYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/polardbx/PolardbxExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardbx
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDBX_EXPORT GetPolarxCommodityResult : public ServiceResult
+			{
+			public:
+				struct DBInstance
+				{
+					struct DBNode
+					{
+						std::string nodeClass;
+						std::string zoneId;
+						std::string id;
+						std::string regionId;
+					};
+					struct ConnAddr
+					{
+						std::string type;
+						std::string vPCId;
+						std::string port;
+						std::string vSwitchId;
+						std::string connectionString;
+					};
+					std::string description;
+					std::string expireDate;
+					std::vector<std::string> readDBInstances;
+					std::vector<ConnAddr> connAddrs;
+					std::string port;
+					std::string dBInstanceType;
+					std::string dBType;
+					std::string dBVersion;
+					std::string maintainEndTime;
+					std::vector<DBNode> dBNodes;
+					std::string network;
+					int dBNodeCount;
+					std::string commodityCode;
+					std::string engine;
+					std::string maintainStartTime;
+					std::string status;
+					std::string zoneId;
+					std::string vPCId;
+					std::string createTime;
+					std::string vSwitchId;
+					std::string minorVersion;
+					std::string expired;
+					std::string latestMinorVersion;
+					std::string payType;
+					std::string lockMode;
+					long storageUsed;
+					std::string dBNodeClass;
+					std::string type;
+					std::string regionId;
+					std::string id;
+					std::string connectionString;
+				};
+				struct Component
+				{
+					std::string type;
+					std::vector<std::string> values;
+					std::string name;
+				};
+
+
+				GetPolarxCommodityResult();
+				explicit GetPolarxCommodityResult(const std::string &payload);
+				~GetPolarxCommodityResult();
+				DBInstance getDBInstance()const;
+				std::vector<Component> getComponentList()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				DBInstance dBInstance_;
+				std::vector<Component> componentList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXCOMMODITYRESULT_H_

polardbx/include/alibabacloud/polardbx/model/ModifyDBInstanceClassResult.h

@@ -37,10 +37,12 @@ namespace AlibabaCloud
 				ModifyDBInstanceClassResult();
 				explicit ModifyDBInstanceClassResult(const std::string &payload);
 				~ModifyDBInstanceClassResult();
+				std::string getOrderId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string orderId_;
 
 			};
 		}

polardbx/include/alibabacloud/polardbx/model/RetryPolarxOrderRequest.h

@@ -0,0 +1,54 @@
+/*
+ * 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_POLARDBX_MODEL_RETRYPOLARXORDERREQUEST_H_
+#define ALIBABACLOUD_POLARDBX_MODEL_RETRYPOLARXORDERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/polardbx/PolardbxExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardbx
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDBX_EXPORT RetryPolarxOrderRequest : public RpcServiceRequest
+			{
+
+			public:
+				RetryPolarxOrderRequest();
+				~RetryPolarxOrderRequest();
+
+				std::string getDBInstanceName()const;
+				void setDBInstanceName(const std::string& dBInstanceName);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getScaleOutToken()const;
+				void setScaleOutToken(const std::string& scaleOutToken);
+
+            private:
+				std::string dBInstanceName_;
+				std::string regionId_;
+				std::string scaleOutToken_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDBX_MODEL_RETRYPOLARXORDERREQUEST_H_

polardbx/include/alibabacloud/polardbx/model/RetryPolarxOrderResult.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_POLARDBX_MODEL_RETRYPOLARXORDERRESULT_H_
+#define ALIBABACLOUD_POLARDBX_MODEL_RETRYPOLARXORDERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/polardbx/PolardbxExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardbx
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDBX_EXPORT RetryPolarxOrderResult : public ServiceResult
+			{
+			public:
+
+
+				RetryPolarxOrderResult();
+				explicit RetryPolarxOrderResult(const std::string &payload);
+				~RetryPolarxOrderResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDBX_MODEL_RETRYPOLARXORDERRESULT_H_

polardbx/include/alibabacloud/polardbx/model/UpdatePolarDBXInstanceNodeRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_POLARDBX_MODEL_UPDATEPOLARDBXINSTANCENODEREQUEST_H_
+#define ALIBABACLOUD_POLARDBX_MODEL_UPDATEPOLARDBXINSTANCENODEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/polardbx/PolardbxExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardbx
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDBX_EXPORT UpdatePolarDBXInstanceNodeRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdatePolarDBXInstanceNodeRequest();
+				~UpdatePolarDBXInstanceNodeRequest();
+
+				std::string getDBInstanceName()const;
+				void setDBInstanceName(const std::string& dBInstanceName);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getDbInstanceNodeCount()const;
+				void setDbInstanceNodeCount(const std::string& dbInstanceNodeCount);
+
+            private:
+				std::string dBInstanceName_;
+				std::string clientToken_;
+				std::string regionId_;
+				std::string dbInstanceNodeCount_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDBX_MODEL_UPDATEPOLARDBXINSTANCENODEREQUEST_H_

polardbx/include/alibabacloud/polardbx/model/UpdatePolarDBXInstanceNodeResult.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_POLARDBX_MODEL_UPDATEPOLARDBXINSTANCENODERESULT_H_
+#define ALIBABACLOUD_POLARDBX_MODEL_UPDATEPOLARDBXINSTANCENODERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/polardbx/PolardbxExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardbx
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDBX_EXPORT UpdatePolarDBXInstanceNodeResult : public ServiceResult
+			{
+			public:
+
+
+				UpdatePolarDBXInstanceNodeResult();
+				explicit UpdatePolarDBXInstanceNodeResult(const std::string &payload);
+				~UpdatePolarDBXInstanceNodeResult();
+				std::string getOrderId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string orderId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDBX_MODEL_UPDATEPOLARDBXINSTANCENODERESULT_H_

polardbx/src/PolardbxClient.cc

@@ -87,6 +87,42 @@ PolardbxClient::AllocateInstancePublicConnectionOutcomeCallable PolardbxClient::
 	return task->get_future();
 }
 
+PolardbxClient::CancelPolarxOrderOutcome PolardbxClient::cancelPolarxOrder(const CancelPolarxOrderRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CancelPolarxOrderOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CancelPolarxOrderOutcome(CancelPolarxOrderResult(outcome.result()));
+	else
+		return CancelPolarxOrderOutcome(outcome.error());
+}
+
+void PolardbxClient::cancelPolarxOrderAsync(const CancelPolarxOrderRequest& request, const CancelPolarxOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, cancelPolarxOrder(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PolardbxClient::CancelPolarxOrderOutcomeCallable PolardbxClient::cancelPolarxOrderCallable(const CancelPolarxOrderRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CancelPolarxOrderOutcome()>>(
+			[this, request]()
+			{
+			return this->cancelPolarxOrder(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 PolardbxClient::CheckHealthOutcome PolardbxClient::checkHealth(const CheckHealthRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -267,6 +303,42 @@ PolardbxClient::CreatePolarxInstanceOutcomeCallable PolardbxClient::createPolarx
 	return task->get_future();
 }
 
+PolardbxClient::CreatePolarxOrderOutcome PolardbxClient::createPolarxOrder(const CreatePolarxOrderRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreatePolarxOrderOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreatePolarxOrderOutcome(CreatePolarxOrderResult(outcome.result()));
+	else
+		return CreatePolarxOrderOutcome(outcome.error());
+}
+
+void PolardbxClient::createPolarxOrderAsync(const CreatePolarxOrderRequest& request, const CreatePolarxOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createPolarxOrder(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PolardbxClient::CreatePolarxOrderOutcomeCallable PolardbxClient::createPolarxOrderCallable(const CreatePolarxOrderRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreatePolarxOrderOutcome()>>(
+			[this, request]()
+			{
+			return this->createPolarxOrder(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 PolardbxClient::CreateSuperAccountOutcome PolardbxClient::createSuperAccount(const CreateSuperAccountRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1203,6 +1275,78 @@ PolardbxClient::EnableSqlAuditOutcomeCallable PolardbxClient::enableSqlAuditCall
 	return task->get_future();
 }
 
+PolardbxClient::GetPolarXPriceOutcome PolardbxClient::getPolarXPrice(const GetPolarXPriceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetPolarXPriceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetPolarXPriceOutcome(GetPolarXPriceResult(outcome.result()));
+	else
+		return GetPolarXPriceOutcome(outcome.error());
+}
+
+void PolardbxClient::getPolarXPriceAsync(const GetPolarXPriceRequest& request, const GetPolarXPriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getPolarXPrice(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PolardbxClient::GetPolarXPriceOutcomeCallable PolardbxClient::getPolarXPriceCallable(const GetPolarXPriceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetPolarXPriceOutcome()>>(
+			[this, request]()
+			{
+			return this->getPolarXPrice(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PolardbxClient::GetPolarxCommodityOutcome PolardbxClient::getPolarxCommodity(const GetPolarxCommodityRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetPolarxCommodityOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetPolarxCommodityOutcome(GetPolarxCommodityResult(outcome.result()));
+	else
+		return GetPolarxCommodityOutcome(outcome.error());
+}
+
+void PolardbxClient::getPolarxCommodityAsync(const GetPolarxCommodityRequest& request, const GetPolarxCommodityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getPolarxCommodity(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PolardbxClient::GetPolarxCommodityOutcomeCallable PolardbxClient::getPolarxCommodityCallable(const GetPolarxCommodityRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetPolarxCommodityOutcome()>>(
+			[this, request]()
+			{
+			return this->getPolarxCommodity(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 PolardbxClient::ModifyAccountDescriptionOutcome PolardbxClient::modifyAccountDescription(const ModifyAccountDescriptionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1671,6 +1815,78 @@ PolardbxClient::RestartDBInstanceOutcomeCallable PolardbxClient::restartDBInstan
 	return task->get_future();
 }
 
+PolardbxClient::RetryPolarxOrderOutcome PolardbxClient::retryPolarxOrder(const RetryPolarxOrderRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RetryPolarxOrderOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RetryPolarxOrderOutcome(RetryPolarxOrderResult(outcome.result()));
+	else
+		return RetryPolarxOrderOutcome(outcome.error());
+}
+
+void PolardbxClient::retryPolarxOrderAsync(const RetryPolarxOrderRequest& request, const RetryPolarxOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, retryPolarxOrder(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PolardbxClient::RetryPolarxOrderOutcomeCallable PolardbxClient::retryPolarxOrderCallable(const RetryPolarxOrderRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RetryPolarxOrderOutcome()>>(
+			[this, request]()
+			{
+			return this->retryPolarxOrder(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PolardbxClient::UpdatePolarDBXInstanceNodeOutcome PolardbxClient::updatePolarDBXInstanceNode(const UpdatePolarDBXInstanceNodeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdatePolarDBXInstanceNodeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdatePolarDBXInstanceNodeOutcome(UpdatePolarDBXInstanceNodeResult(outcome.result()));
+	else
+		return UpdatePolarDBXInstanceNodeOutcome(outcome.error());
+}
+
+void PolardbxClient::updatePolarDBXInstanceNodeAsync(const UpdatePolarDBXInstanceNodeRequest& request, const UpdatePolarDBXInstanceNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updatePolarDBXInstanceNode(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PolardbxClient::UpdatePolarDBXInstanceNodeOutcomeCallable PolardbxClient::updatePolarDBXInstanceNodeCallable(const UpdatePolarDBXInstanceNodeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdatePolarDBXInstanceNodeOutcome()>>(
+			[this, request]()
+			{
+			return this->updatePolarDBXInstanceNode(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 PolardbxClient::UpgradeDBInstanceKernelVersionOutcome PolardbxClient::upgradeDBInstanceKernelVersion(const UpgradeDBInstanceKernelVersionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

polardbx/src/model/CancelPolarxOrderRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/polardbx/model/CancelPolarxOrderRequest.h>
+
+using AlibabaCloud::Polardbx::Model::CancelPolarxOrderRequest;
+
+CancelPolarxOrderRequest::CancelPolarxOrderRequest() :
+	RpcServiceRequest("polardbx", "2020-02-02", "CancelPolarxOrder")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CancelPolarxOrderRequest::~CancelPolarxOrderRequest()
+{}
+
+std::string CancelPolarxOrderRequest::getDBInstanceName()const
+{
+	return dBInstanceName_;
+}
+
+void CancelPolarxOrderRequest::setDBInstanceName(const std::string& dBInstanceName)
+{
+	dBInstanceName_ = dBInstanceName;
+	setParameter("DBInstanceName", dBInstanceName);
+}
+
+std::string CancelPolarxOrderRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CancelPolarxOrderRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CancelPolarxOrderRequest::getScaleOutToken()const
+{
+	return scaleOutToken_;
+}
+
+void CancelPolarxOrderRequest::setScaleOutToken(const std::string& scaleOutToken)
+{
+	scaleOutToken_ = scaleOutToken;
+	setParameter("ScaleOutToken", scaleOutToken);
+}
+

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

polardbx/src/model/CreateDBInstanceRequest.cc

@@ -27,6 +27,28 @@ CreateDBInstanceRequest::CreateDBInstanceRequest() :
 CreateDBInstanceRequest::~CreateDBInstanceRequest()
 {}
 
+std::string CreateDBInstanceRequest::getNetworkType()const
+{
+	return networkType_;
+}
+
+void CreateDBInstanceRequest::setNetworkType(const std::string& networkType)
+{
+	networkType_ = networkType;
+	setParameter("NetworkType", networkType);
+}
+
+std::string CreateDBInstanceRequest::getEngineVersion()const
+{
+	return engineVersion_;
+}
+
+void CreateDBInstanceRequest::setEngineVersion(const std::string& engineVersion)
+{
+	engineVersion_ = engineVersion;
+	setParameter("EngineVersion", engineVersion);
+}
+
 std::string CreateDBInstanceRequest::getResourceGroupId()const
 {
 	return resourceGroupId_;
@@ -49,17 +71,6 @@ void CreateDBInstanceRequest::setDBNodeClass(const std::string& dBNodeClass)
 	setParameter("DBNodeClass", dBNodeClass);
 }
 
-std::string CreateDBInstanceRequest::getDBInstanceDescription()const
-{
-	return dBInstanceDescription_;
-}
-
-void CreateDBInstanceRequest::setDBInstanceDescription(const std::string& dBInstanceDescription)
-{
-	dBInstanceDescription_ = dBInstanceDescription;
-	setParameter("DBInstanceDescription", dBInstanceDescription);
-}
-
 std::string CreateDBInstanceRequest::getPeriod()const
 {
 	return period_;
@@ -71,15 +82,15 @@ void CreateDBInstanceRequest::setPeriod(const std::string& period)
 	setParameter("Period", period);
 }
 
-std::string CreateDBInstanceRequest::getSecurityIPList()const
+bool CreateDBInstanceRequest::getIsReadDBInstance()const
 {
-	return securityIPList_;
+	return isReadDBInstance_;
 }
 
-void CreateDBInstanceRequest::setSecurityIPList(const std::string& securityIPList)
+void CreateDBInstanceRequest::setIsReadDBInstance(bool isReadDBInstance)
 {
-	securityIPList_ = securityIPList;
-	setParameter("SecurityIPList", securityIPList);
+	isReadDBInstance_ = isReadDBInstance;
+	setParameter("IsReadDBInstance", isReadDBInstance ? "true" : "false");
 }
 
 std::string CreateDBInstanceRequest::getVSwitchId()const
@@ -115,15 +126,15 @@ void CreateDBInstanceRequest::setZoneId(const std::string& zoneId)
 	setParameter("ZoneId", zoneId);
 }
 
-std::string CreateDBInstanceRequest::getInstanceNetworkType()const
+std::string CreateDBInstanceRequest::getPrimaryDBInstanceName()const
 {
-	return instanceNetworkType_;
+	return primaryDBInstanceName_;
 }
 
-void CreateDBInstanceRequest::setInstanceNetworkType(const std::string& instanceNetworkType)
+void CreateDBInstanceRequest::setPrimaryDBInstanceName(const std::string& primaryDBInstanceName)
 {
-	instanceNetworkType_ = instanceNetworkType;
-	setParameter("InstanceNetworkType", instanceNetworkType);
+	primaryDBInstanceName_ = primaryDBInstanceName;
+	setParameter("PrimaryDBInstanceName", primaryDBInstanceName);
 }
 
 std::string CreateDBInstanceRequest::getClientToken()const

polardbx/src/model/CreateDBInstanceResult.cc

@@ -43,28 +43,14 @@ void CreateDBInstanceResult::parse(const std::string &payload)
 		dBInstanceName_ = value["DBInstanceName"].asString();
 	if(!value["OrderId"].isNull())
 		orderId_ = value["OrderId"].asString();
-	if(!value["ConnectionString"].isNull())
-		connectionString_ = value["ConnectionString"].asString();
-	if(!value["Port"].isNull())
-		port_ = std::stoi(value["Port"].asString());
 
 }
 
-int CreateDBInstanceResult::getPort()const
-{
-	return port_;
-}
-
 std::string CreateDBInstanceResult::getOrderId()const
 {
 	return orderId_;
 }
 
-std::string CreateDBInstanceResult::getConnectionString()const
-{
-	return connectionString_;
-}
-
 std::string CreateDBInstanceResult::getDBInstanceName()const
 {
 	return dBInstanceName_;

polardbx/src/model/CreatePolarxOrderRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/polardbx/model/CreatePolarxOrderRequest.h>
+
+using AlibabaCloud::Polardbx::Model::CreatePolarxOrderRequest;
+
+CreatePolarxOrderRequest::CreatePolarxOrderRequest() :
+	RpcServiceRequest("polardbx", "2020-02-02", "CreatePolarxOrder")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreatePolarxOrderRequest::~CreatePolarxOrderRequest()
+{}
+
+std::string CreatePolarxOrderRequest::getDBInstanceName()const
+{
+	return dBInstanceName_;
+}
+
+void CreatePolarxOrderRequest::setDBInstanceName(const std::string& dBInstanceName)
+{
+	dBInstanceName_ = dBInstanceName;
+	setParameter("DBInstanceName", dBInstanceName);
+}
+
+std::string CreatePolarxOrderRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreatePolarxOrderRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreatePolarxOrderRequest::getNodeCount()const
+{
+	return nodeCount_;
+}
+
+void CreatePolarxOrderRequest::setNodeCount(const std::string& nodeCount)
+{
+	nodeCount_ = nodeCount;
+	setParameter("NodeCount", nodeCount);
+}
+

polardbx/src/model/CreatePolarxOrderResult.cc

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

polardbx/src/model/DescribeTasksResult.cc

@@ -57,14 +57,16 @@ void DescribeTasksResult::parse(const std::string &payload)
 			itemsObject.taskId = valueItemsTaskProgressInfo["TaskId"].asString();
 		if(!valueItemsTaskProgressInfo["Progress"].isNull())
 			itemsObject.progress = valueItemsTaskProgressInfo["Progress"].asString();
-		if(!valueItemsTaskProgressInfo["ExpectedFinishTime"].isNull())
-			itemsObject.expectedFinishTime = valueItemsTaskProgressInfo["ExpectedFinishTime"].asString();
+		if(!valueItemsTaskProgressInfo["FinishTime"].isNull())
+			itemsObject.finishTime1 = valueItemsTaskProgressInfo["FinishTime"].asString();
 		if(!valueItemsTaskProgressInfo["Status"].isNull())
 			itemsObject.status = valueItemsTaskProgressInfo["Status"].asString();
 		if(!valueItemsTaskProgressInfo["TaskErrorCode"].isNull())
 			itemsObject.taskErrorCode = valueItemsTaskProgressInfo["TaskErrorCode"].asString();
 		if(!valueItemsTaskProgressInfo["TaskErrorMessage"].isNull())
 			itemsObject.taskErrorMessage = valueItemsTaskProgressInfo["TaskErrorMessage"].asString();
+		if(!valueItemsTaskProgressInfo["ScaleOutToken"].isNull())
+			itemsObject.scaleOutToken = valueItemsTaskProgressInfo["ScaleOutToken"].asString();
 		items_.push_back(itemsObject);
 	}
 	if(!value["TotalRecordCount"].isNull())

polardbx/src/model/GetPolarXPriceRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/polardbx/model/GetPolarXPriceRequest.h>
+
+using AlibabaCloud::Polardbx::Model::GetPolarXPriceRequest;
+
+GetPolarXPriceRequest::GetPolarXPriceRequest() :
+	RpcServiceRequest("polardbx", "2020-02-02", "GetPolarXPrice")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetPolarXPriceRequest::~GetPolarXPriceRequest()
+{}
+
+std::string GetPolarXPriceRequest::getDBInstanceName()const
+{
+	return dBInstanceName_;
+}
+
+void GetPolarXPriceRequest::setDBInstanceName(const std::string& dBInstanceName)
+{
+	dBInstanceName_ = dBInstanceName;
+	setParameter("DBInstanceName", dBInstanceName);
+}
+
+std::string GetPolarXPriceRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetPolarXPriceRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string GetPolarXPriceRequest::getNodeCount()const
+{
+	return nodeCount_;
+}
+
+void GetPolarXPriceRequest::setNodeCount(const std::string& nodeCount)
+{
+	nodeCount_ = nodeCount;
+	setParameter("NodeCount", nodeCount);
+}
+

polardbx/src/model/GetPolarXPriceResult.cc

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/polardbx/model/GetPolarXPriceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Polardbx;
+using namespace AlibabaCloud::Polardbx::Model;
+
+GetPolarXPriceResult::GetPolarXPriceResult() :
+	ServiceResult()
+{}
+
+GetPolarXPriceResult::GetPolarXPriceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetPolarXPriceResult::~GetPolarXPriceResult()
+{}
+
+void GetPolarXPriceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allOrderPriceListNode = value["OrderPriceList"]["OrderPrice"];
+	for (auto valueOrderPriceListOrderPrice : allOrderPriceListNode)
+	{
+		OrderPrice orderPriceListObject;
+		if(!valueOrderPriceListOrderPrice["DBInstanceName"].isNull())
+			orderPriceListObject.dBInstanceName = valueOrderPriceListOrderPrice["DBInstanceName"].asString();
+		if(!valueOrderPriceListOrderPrice["TotalCostAmount"].isNull())
+			orderPriceListObject.totalCostAmount = valueOrderPriceListOrderPrice["TotalCostAmount"].asString();
+		if(!valueOrderPriceListOrderPrice["DiscountAmount"].isNull())
+			orderPriceListObject.discountAmount = valueOrderPriceListOrderPrice["DiscountAmount"].asString();
+		if(!valueOrderPriceListOrderPrice["TradeAmount"].isNull())
+			orderPriceListObject.tradeAmount = valueOrderPriceListOrderPrice["TradeAmount"].asString();
+		if(!valueOrderPriceListOrderPrice["OriginalAmount"].isNull())
+			orderPriceListObject.originalAmount = valueOrderPriceListOrderPrice["OriginalAmount"].asString();
+		if(!valueOrderPriceListOrderPrice["PayType"].isNull())
+			orderPriceListObject.payType = valueOrderPriceListOrderPrice["PayType"].asString();
+		auto allRulesNode = valueOrderPriceListOrderPrice["Rules"]["Rule"];
+		for (auto valueOrderPriceListOrderPriceRulesRule : allRulesNode)
+		{
+			OrderPrice::Rule rulesObject;
+			if(!valueOrderPriceListOrderPriceRulesRule["RuleDescId"].isNull())
+				rulesObject.ruleDescId = std::stol(valueOrderPriceListOrderPriceRulesRule["RuleDescId"].asString());
+			if(!valueOrderPriceListOrderPriceRulesRule["Name"].isNull())
+				rulesObject.name = valueOrderPriceListOrderPriceRulesRule["Name"].asString();
+			if(!valueOrderPriceListOrderPriceRulesRule["Title"].isNull())
+				rulesObject.title = valueOrderPriceListOrderPriceRulesRule["Title"].asString();
+			orderPriceListObject.rules.push_back(rulesObject);
+		}
+		orderPriceList_.push_back(orderPriceListObject);
+	}
+
+}
+
+std::vector<GetPolarXPriceResult::OrderPrice> GetPolarXPriceResult::getOrderPriceList()const
+{
+	return orderPriceList_;
+}
+

polardbx/src/model/GetPolarxCommodityRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/polardbx/model/GetPolarxCommodityRequest.h>
+
+using AlibabaCloud::Polardbx::Model::GetPolarxCommodityRequest;
+
+GetPolarxCommodityRequest::GetPolarxCommodityRequest() :
+	RpcServiceRequest("polardbx", "2020-02-02", "GetPolarxCommodity")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetPolarxCommodityRequest::~GetPolarxCommodityRequest()
+{}
+
+std::string GetPolarxCommodityRequest::getDBInstanceName()const
+{
+	return dBInstanceName_;
+}
+
+void GetPolarxCommodityRequest::setDBInstanceName(const std::string& dBInstanceName)
+{
+	dBInstanceName_ = dBInstanceName;
+	setParameter("DBInstanceName", dBInstanceName);
+}
+
+std::string GetPolarxCommodityRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetPolarxCommodityRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string GetPolarxCommodityRequest::getOrderType()const
+{
+	return orderType_;
+}
+
+void GetPolarxCommodityRequest::setOrderType(const std::string& orderType)
+{
+	orderType_ = orderType;
+	setParameter("OrderType", orderType);
+}
+

polardbx/src/model/GetPolarxCommodityResult.cc

@@ -0,0 +1,157 @@
+/*
+ * 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/polardbx/model/GetPolarxCommodityResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Polardbx;
+using namespace AlibabaCloud::Polardbx::Model;
+
+GetPolarxCommodityResult::GetPolarxCommodityResult() :
+	ServiceResult()
+{}
+
+GetPolarxCommodityResult::GetPolarxCommodityResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetPolarxCommodityResult::~GetPolarxCommodityResult()
+{}
+
+void GetPolarxCommodityResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allComponentListNode = value["ComponentList"]["Component"];
+	for (auto valueComponentListComponent : allComponentListNode)
+	{
+		Component componentListObject;
+		if(!valueComponentListComponent["Name"].isNull())
+			componentListObject.name = valueComponentListComponent["Name"].asString();
+		if(!valueComponentListComponent["Type"].isNull())
+			componentListObject.type = valueComponentListComponent["Type"].asString();
+		auto allValues = value["Values"]["Value"];
+		for (auto value : allValues)
+			componentListObject.values.push_back(value.asString());
+		componentList_.push_back(componentListObject);
+	}
+	auto dBInstanceNode = value["DBInstance"];
+	if(!dBInstanceNode["Status"].isNull())
+		dBInstance_.status = dBInstanceNode["Status"].asString();
+	if(!dBInstanceNode["Description"].isNull())
+		dBInstance_.description = dBInstanceNode["Description"].asString();
+	if(!dBInstanceNode["ZoneId"].isNull())
+		dBInstance_.zoneId = dBInstanceNode["ZoneId"].asString();
+	if(!dBInstanceNode["VPCId"].isNull())
+		dBInstance_.vPCId = dBInstanceNode["VPCId"].asString();
+	if(!dBInstanceNode["CreateTime"].isNull())
+		dBInstance_.createTime = dBInstanceNode["CreateTime"].asString();
+	if(!dBInstanceNode["Expired"].isNull())
+		dBInstance_.expired = dBInstanceNode["Expired"].asString();
+	if(!dBInstanceNode["PayType"].isNull())
+		dBInstance_.payType = dBInstanceNode["PayType"].asString();
+	if(!dBInstanceNode["DBType"].isNull())
+		dBInstance_.dBType = dBInstanceNode["DBType"].asString();
+	if(!dBInstanceNode["LockMode"].isNull())
+		dBInstance_.lockMode = dBInstanceNode["LockMode"].asString();
+	if(!dBInstanceNode["StorageUsed"].isNull())
+		dBInstance_.storageUsed = std::stol(dBInstanceNode["StorageUsed"].asString());
+	if(!dBInstanceNode["DBVersion"].isNull())
+		dBInstance_.dBVersion = dBInstanceNode["DBVersion"].asString();
+	if(!dBInstanceNode["Network"].isNull())
+		dBInstance_.network = dBInstanceNode["Network"].asString();
+	if(!dBInstanceNode["RegionId"].isNull())
+		dBInstance_.regionId = dBInstanceNode["RegionId"].asString();
+	if(!dBInstanceNode["Engine"].isNull())
+		dBInstance_.engine = dBInstanceNode["Engine"].asString();
+	if(!dBInstanceNode["Id"].isNull())
+		dBInstance_.id = dBInstanceNode["Id"].asString();
+	if(!dBInstanceNode["ConnectionString"].isNull())
+		dBInstance_.connectionString = dBInstanceNode["ConnectionString"].asString();
+	if(!dBInstanceNode["Port"].isNull())
+		dBInstance_.port = dBInstanceNode["Port"].asString();
+	if(!dBInstanceNode["MinorVersion"].isNull())
+		dBInstance_.minorVersion = dBInstanceNode["MinorVersion"].asString();
+	if(!dBInstanceNode["LatestMinorVersion"].isNull())
+		dBInstance_.latestMinorVersion = dBInstanceNode["LatestMinorVersion"].asString();
+	if(!dBInstanceNode["DBNodeCount"].isNull())
+		dBInstance_.dBNodeCount = std::stoi(dBInstanceNode["DBNodeCount"].asString());
+	if(!dBInstanceNode["DBInstanceType"].isNull())
+		dBInstance_.dBInstanceType = dBInstanceNode["DBInstanceType"].asString();
+	if(!dBInstanceNode["MaintainStartTime"].isNull())
+		dBInstance_.maintainStartTime = dBInstanceNode["MaintainStartTime"].asString();
+	if(!dBInstanceNode["MaintainEndTime"].isNull())
+		dBInstance_.maintainEndTime = dBInstanceNode["MaintainEndTime"].asString();
+	if(!dBInstanceNode["VSwitchId"].isNull())
+		dBInstance_.vSwitchId = dBInstanceNode["VSwitchId"].asString();
+	if(!dBInstanceNode["CommodityCode"].isNull())
+		dBInstance_.commodityCode = dBInstanceNode["CommodityCode"].asString();
+	if(!dBInstanceNode["ExpireDate"].isNull())
+		dBInstance_.expireDate = dBInstanceNode["ExpireDate"].asString();
+	if(!dBInstanceNode["Type"].isNull())
+		dBInstance_.type = dBInstanceNode["Type"].asString();
+	if(!dBInstanceNode["DBNodeClass"].isNull())
+		dBInstance_.dBNodeClass = dBInstanceNode["DBNodeClass"].asString();
+	auto allDBNodesNode = dBInstanceNode["DBNodes"]["DBNode"];
+	for (auto dBInstanceNodeDBNodesDBNode : allDBNodesNode)
+	{
+		DBInstance::DBNode dBNodeObject;
+		if(!dBInstanceNodeDBNodesDBNode["Id"].isNull())
+			dBNodeObject.id = dBInstanceNodeDBNodesDBNode["Id"].asString();
+		if(!dBInstanceNodeDBNodesDBNode["NodeClass"].isNull())
+			dBNodeObject.nodeClass = dBInstanceNodeDBNodesDBNode["NodeClass"].asString();
+		if(!dBInstanceNodeDBNodesDBNode["RegionId"].isNull())
+			dBNodeObject.regionId = dBInstanceNodeDBNodesDBNode["RegionId"].asString();
+		if(!dBInstanceNodeDBNodesDBNode["ZoneId"].isNull())
+			dBNodeObject.zoneId = dBInstanceNodeDBNodesDBNode["ZoneId"].asString();
+		dBInstance_.dBNodes.push_back(dBNodeObject);
+	}
+	auto allConnAddrsNode = dBInstanceNode["ConnAddrs"]["ConnAddr"];
+	for (auto dBInstanceNodeConnAddrsConnAddr : allConnAddrsNode)
+	{
+		DBInstance::ConnAddr connAddrObject;
+		if(!dBInstanceNodeConnAddrsConnAddr["ConnectionString"].isNull())
+			connAddrObject.connectionString = dBInstanceNodeConnAddrsConnAddr["ConnectionString"].asString();
+		if(!dBInstanceNodeConnAddrsConnAddr["Port"].isNull())
+			connAddrObject.port = dBInstanceNodeConnAddrsConnAddr["Port"].asString();
+		if(!dBInstanceNodeConnAddrsConnAddr["Type"].isNull())
+			connAddrObject.type = dBInstanceNodeConnAddrsConnAddr["Type"].asString();
+		if(!dBInstanceNodeConnAddrsConnAddr["VPCId"].isNull())
+			connAddrObject.vPCId = dBInstanceNodeConnAddrsConnAddr["VPCId"].asString();
+		if(!dBInstanceNodeConnAddrsConnAddr["VSwitchId"].isNull())
+			connAddrObject.vSwitchId = dBInstanceNodeConnAddrsConnAddr["VSwitchId"].asString();
+		dBInstance_.connAddrs.push_back(connAddrObject);
+	}
+		auto allReadDBInstances = dBInstanceNode["ReadDBInstances"]["ReadDBInstance"];
+		for (auto value : allReadDBInstances)
+			dBInstance_.readDBInstances.push_back(value.asString());
+
+}
+
+GetPolarxCommodityResult::DBInstance GetPolarxCommodityResult::getDBInstance()const
+{
+	return dBInstance_;
+}
+
+std::vector<GetPolarxCommodityResult::Component> GetPolarxCommodityResult::getComponentList()const
+{
+	return componentList_;
+}
+

polardbx/src/model/ModifyDBInstanceClassResult.cc

@@ -39,6 +39,13 @@ void ModifyDBInstanceClassResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	if(!value["OrderId"].isNull())
+		orderId_ = value["OrderId"].asString();
 
 }
 
+std::string ModifyDBInstanceClassResult::getOrderId()const
+{
+	return orderId_;
+}
+

polardbx/src/model/RetryPolarxOrderRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/polardbx/model/RetryPolarxOrderRequest.h>
+
+using AlibabaCloud::Polardbx::Model::RetryPolarxOrderRequest;
+
+RetryPolarxOrderRequest::RetryPolarxOrderRequest() :
+	RpcServiceRequest("polardbx", "2020-02-02", "RetryPolarxOrder")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+RetryPolarxOrderRequest::~RetryPolarxOrderRequest()
+{}
+
+std::string RetryPolarxOrderRequest::getDBInstanceName()const
+{
+	return dBInstanceName_;
+}
+
+void RetryPolarxOrderRequest::setDBInstanceName(const std::string& dBInstanceName)
+{
+	dBInstanceName_ = dBInstanceName;
+	setParameter("DBInstanceName", dBInstanceName);
+}
+
+std::string RetryPolarxOrderRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void RetryPolarxOrderRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string RetryPolarxOrderRequest::getScaleOutToken()const
+{
+	return scaleOutToken_;
+}
+
+void RetryPolarxOrderRequest::setScaleOutToken(const std::string& scaleOutToken)
+{
+	scaleOutToken_ = scaleOutToken;
+	setParameter("ScaleOutToken", scaleOutToken);
+}
+

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

polardbx/src/model/UpdatePolarDBXInstanceNodeRequest.cc

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/polardbx/model/UpdatePolarDBXInstanceNodeRequest.h>
+
+using AlibabaCloud::Polardbx::Model::UpdatePolarDBXInstanceNodeRequest;
+
+UpdatePolarDBXInstanceNodeRequest::UpdatePolarDBXInstanceNodeRequest() :
+	RpcServiceRequest("polardbx", "2020-02-02", "UpdatePolarDBXInstanceNode")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+UpdatePolarDBXInstanceNodeRequest::~UpdatePolarDBXInstanceNodeRequest()
+{}
+
+std::string UpdatePolarDBXInstanceNodeRequest::getDBInstanceName()const
+{
+	return dBInstanceName_;
+}
+
+void UpdatePolarDBXInstanceNodeRequest::setDBInstanceName(const std::string& dBInstanceName)
+{
+	dBInstanceName_ = dBInstanceName;
+	setParameter("DBInstanceName", dBInstanceName);
+}
+
+std::string UpdatePolarDBXInstanceNodeRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void UpdatePolarDBXInstanceNodeRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string UpdatePolarDBXInstanceNodeRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void UpdatePolarDBXInstanceNodeRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string UpdatePolarDBXInstanceNodeRequest::getDbInstanceNodeCount()const
+{
+	return dbInstanceNodeCount_;
+}
+
+void UpdatePolarDBXInstanceNodeRequest::setDbInstanceNodeCount(const std::string& dbInstanceNodeCount)
+{
+	dbInstanceNodeCount_ = dbInstanceNodeCount;
+	setParameter("DbInstanceNodeCount", dbInstanceNodeCount);
+}
+

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