Support new feature.

VERSION

@@ -1 +1 @@
-1.36.1794
+1.36.1795

polardb/CMakeLists.txt

@@ -39,6 +39,8 @@ set(polardb_public_header_model
 	include/alibabacloud/polardb/model/CreateAccountResult.h
 	include/alibabacloud/polardb/model/CreateBackupRequest.h
 	include/alibabacloud/polardb/model/CreateBackupResult.h
+	include/alibabacloud/polardb/model/CreateColdStorageInstanceRequest.h
+	include/alibabacloud/polardb/model/CreateColdStorageInstanceResult.h
 	include/alibabacloud/polardb/model/CreateDBClusterRequest.h
 	include/alibabacloud/polardb/model/CreateDBClusterResult.h
 	include/alibabacloud/polardb/model/CreateDBClusterEndpointRequest.h
@@ -189,6 +191,10 @@ set(polardb_public_header_model
 	include/alibabacloud/polardb/model/DescribeUserEncryptionKeyListResult.h
 	include/alibabacloud/polardb/model/DescribeVSwitchesRequest.h
 	include/alibabacloud/polardb/model/DescribeVSwitchesResult.h
+	include/alibabacloud/polardb/model/DisableDBClusterServerlessRequest.h
+	include/alibabacloud/polardb/model/DisableDBClusterServerlessResult.h
+	include/alibabacloud/polardb/model/EnableDBClusterServerlessRequest.h
+	include/alibabacloud/polardb/model/EnableDBClusterServerlessResult.h
 	include/alibabacloud/polardb/model/EnableFirewallRulesRequest.h
 	include/alibabacloud/polardb/model/EnableFirewallRulesResult.h
 	include/alibabacloud/polardb/model/EvaluateRegionResourceRequest.h
@@ -320,6 +326,8 @@ set(polardb_src
 	src/model/CreateAccountResult.cc
 	src/model/CreateBackupRequest.cc
 	src/model/CreateBackupResult.cc
+	src/model/CreateColdStorageInstanceRequest.cc
+	src/model/CreateColdStorageInstanceResult.cc
 	src/model/CreateDBClusterRequest.cc
 	src/model/CreateDBClusterResult.cc
 	src/model/CreateDBClusterEndpointRequest.cc
@@ -470,6 +478,10 @@ set(polardb_src
 	src/model/DescribeUserEncryptionKeyListResult.cc
 	src/model/DescribeVSwitchesRequest.cc
 	src/model/DescribeVSwitchesResult.cc
+	src/model/DisableDBClusterServerlessRequest.cc
+	src/model/DisableDBClusterServerlessResult.cc
+	src/model/EnableDBClusterServerlessRequest.cc
+	src/model/EnableDBClusterServerlessResult.cc
 	src/model/EnableFirewallRulesRequest.cc
 	src/model/EnableFirewallRulesResult.cc
 	src/model/EvaluateRegionResourceRequest.cc

polardb/include/alibabacloud/polardb/PolardbClient.h

@@ -40,6 +40,8 @@
 #include "model/CreateAccountResult.h"
 #include "model/CreateBackupRequest.h"
 #include "model/CreateBackupResult.h"
+#include "model/CreateColdStorageInstanceRequest.h"
+#include "model/CreateColdStorageInstanceResult.h"
 #include "model/CreateDBClusterRequest.h"
 #include "model/CreateDBClusterResult.h"
 #include "model/CreateDBClusterEndpointRequest.h"
@@ -190,6 +192,10 @@
 #include "model/DescribeUserEncryptionKeyListResult.h"
 #include "model/DescribeVSwitchesRequest.h"
 #include "model/DescribeVSwitchesResult.h"
+#include "model/DisableDBClusterServerlessRequest.h"
+#include "model/DisableDBClusterServerlessResult.h"
+#include "model/EnableDBClusterServerlessRequest.h"
+#include "model/EnableDBClusterServerlessResult.h"
 #include "model/EnableFirewallRulesRequest.h"
 #include "model/EnableFirewallRulesResult.h"
 #include "model/EvaluateRegionResourceRequest.h"
@@ -336,6 +342,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateBackupResult> CreateBackupOutcome;
 			typedef std::future<CreateBackupOutcome> CreateBackupOutcomeCallable;
 			typedef std::function<void(const PolardbClient*, const Model::CreateBackupRequest&, const CreateBackupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateBackupAsyncHandler;
+			typedef Outcome<Error, Model::CreateColdStorageInstanceResult> CreateColdStorageInstanceOutcome;
+			typedef std::future<CreateColdStorageInstanceOutcome> CreateColdStorageInstanceOutcomeCallable;
+			typedef std::function<void(const PolardbClient*, const Model::CreateColdStorageInstanceRequest&, const CreateColdStorageInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateColdStorageInstanceAsyncHandler;
 			typedef Outcome<Error, Model::CreateDBClusterResult> CreateDBClusterOutcome;
 			typedef std::future<CreateDBClusterOutcome> CreateDBClusterOutcomeCallable;
 			typedef std::function<void(const PolardbClient*, const Model::CreateDBClusterRequest&, const CreateDBClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDBClusterAsyncHandler;
@@ -561,6 +570,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeVSwitchesResult> DescribeVSwitchesOutcome;
 			typedef std::future<DescribeVSwitchesOutcome> DescribeVSwitchesOutcomeCallable;
 			typedef std::function<void(const PolardbClient*, const Model::DescribeVSwitchesRequest&, const DescribeVSwitchesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVSwitchesAsyncHandler;
+			typedef Outcome<Error, Model::DisableDBClusterServerlessResult> DisableDBClusterServerlessOutcome;
+			typedef std::future<DisableDBClusterServerlessOutcome> DisableDBClusterServerlessOutcomeCallable;
+			typedef std::function<void(const PolardbClient*, const Model::DisableDBClusterServerlessRequest&, const DisableDBClusterServerlessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableDBClusterServerlessAsyncHandler;
+			typedef Outcome<Error, Model::EnableDBClusterServerlessResult> EnableDBClusterServerlessOutcome;
+			typedef std::future<EnableDBClusterServerlessOutcome> EnableDBClusterServerlessOutcomeCallable;
+			typedef std::function<void(const PolardbClient*, const Model::EnableDBClusterServerlessRequest&, const EnableDBClusterServerlessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableDBClusterServerlessAsyncHandler;
 			typedef Outcome<Error, Model::EnableFirewallRulesResult> EnableFirewallRulesOutcome;
 			typedef std::future<EnableFirewallRulesOutcome> EnableFirewallRulesOutcomeCallable;
 			typedef std::function<void(const PolardbClient*, const Model::EnableFirewallRulesRequest&, const EnableFirewallRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableFirewallRulesAsyncHandler;
@@ -758,6 +773,9 @@ namespace AlibabaCloud
 			CreateBackupOutcome createBackup(const Model::CreateBackupRequest &request)const;
 			void createBackupAsync(const Model::CreateBackupRequest& request, const CreateBackupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateBackupOutcomeCallable createBackupCallable(const Model::CreateBackupRequest& request) const;
+			CreateColdStorageInstanceOutcome createColdStorageInstance(const Model::CreateColdStorageInstanceRequest &request)const;
+			void createColdStorageInstanceAsync(const Model::CreateColdStorageInstanceRequest& request, const CreateColdStorageInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateColdStorageInstanceOutcomeCallable createColdStorageInstanceCallable(const Model::CreateColdStorageInstanceRequest& request) const;
 			CreateDBClusterOutcome createDBCluster(const Model::CreateDBClusterRequest &request)const;
 			void createDBClusterAsync(const Model::CreateDBClusterRequest& request, const CreateDBClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateDBClusterOutcomeCallable createDBClusterCallable(const Model::CreateDBClusterRequest& request) const;
@@ -983,6 +1001,12 @@ namespace AlibabaCloud
 			DescribeVSwitchesOutcome describeVSwitches(const Model::DescribeVSwitchesRequest &request)const;
 			void describeVSwitchesAsync(const Model::DescribeVSwitchesRequest& request, const DescribeVSwitchesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeVSwitchesOutcomeCallable describeVSwitchesCallable(const Model::DescribeVSwitchesRequest& request) const;
+			DisableDBClusterServerlessOutcome disableDBClusterServerless(const Model::DisableDBClusterServerlessRequest &request)const;
+			void disableDBClusterServerlessAsync(const Model::DisableDBClusterServerlessRequest& request, const DisableDBClusterServerlessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DisableDBClusterServerlessOutcomeCallable disableDBClusterServerlessCallable(const Model::DisableDBClusterServerlessRequest& request) const;
+			EnableDBClusterServerlessOutcome enableDBClusterServerless(const Model::EnableDBClusterServerlessRequest &request)const;
+			void enableDBClusterServerlessAsync(const Model::EnableDBClusterServerlessRequest& request, const EnableDBClusterServerlessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EnableDBClusterServerlessOutcomeCallable enableDBClusterServerlessCallable(const Model::EnableDBClusterServerlessRequest& request) const;
 			EnableFirewallRulesOutcome enableFirewallRules(const Model::EnableFirewallRulesRequest &request)const;
 			void enableFirewallRulesAsync(const Model::EnableFirewallRulesRequest& request, const EnableFirewallRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			EnableFirewallRulesOutcomeCallable enableFirewallRulesCallable(const Model::EnableFirewallRulesRequest& request) const;

polardb/include/alibabacloud/polardb/model/CreateColdStorageInstanceRequest.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_POLARDB_MODEL_CREATECOLDSTORAGEINSTANCEREQUEST_H_
+#define ALIBABACLOUD_POLARDB_MODEL_CREATECOLDSTORAGEINSTANCEREQUEST_H_
+
+#include <alibabacloud/polardb/PolardbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Polardb {
+namespace Model {
+class ALIBABACLOUD_POLARDB_EXPORT CreateColdStorageInstanceRequest : public RpcServiceRequest {
+public:
+	CreateColdStorageInstanceRequest();
+	~CreateColdStorageInstanceRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	std::string getColdStorageInstanceDescription() const;
+	void setColdStorageInstanceDescription(const std::string &coldStorageInstanceDescription);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	long resourceOwnerId_;
+	std::string clientToken_;
+	std::string accessKeyId_;
+	std::string resourceGroupId_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	std::string coldStorageInstanceDescription_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Polardb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_POLARDB_MODEL_CREATECOLDSTORAGEINSTANCEREQUEST_H_

polardb/include/alibabacloud/polardb/model/CreateColdStorageInstanceResult.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_POLARDB_MODEL_CREATECOLDSTORAGEINSTANCERESULT_H_
+#define ALIBABACLOUD_POLARDB_MODEL_CREATECOLDSTORAGEINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/polardb/PolardbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDB_EXPORT CreateColdStorageInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				CreateColdStorageInstanceResult();
+				explicit CreateColdStorageInstanceResult(const std::string &payload);
+				~CreateColdStorageInstanceResult();
+				std::string getColdStorageInstanceId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string coldStorageInstanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDB_MODEL_CREATECOLDSTORAGEINSTANCERESULT_H_

polardb/include/alibabacloud/polardb/model/CreateDBClusterEndpointRequest.h

@@ -54,8 +54,12 @@ public:
 	void setDBEndpointDescription(const std::string &dBEndpointDescription);
 	long getOwnerId() const;
 	void setOwnerId(long ownerId);
+	std::string getVSwitchId() const;
+	void setVSwitchId(const std::string &vSwitchId);
 	std::string getNodes() const;
 	void setNodes(const std::string &nodes);
+	std::string getVPCId() const;
+	void setVPCId(const std::string &vPCId);
 
 private:
 	std::string autoAddNewNodes_;
@@ -70,7 +74,9 @@ private:
 	std::string endpointConfig_;
 	std::string dBEndpointDescription_;
 	long ownerId_;
+	std::string vSwitchId_;
 	std::string nodes_;
+	std::string vPCId_;
 };
 } // namespace Model
 } // namespace Polardb

polardb/include/alibabacloud/polardb/model/CreateDBClusterRequest.h

@@ -72,6 +72,8 @@ public:
 	void setSecurityIPList(const std::string &securityIPList);
 	std::string getDBMinorVersion() const;
 	void setDBMinorVersion(const std::string &dBMinorVersion);
+	int getProvisionedIops() const;
+	void setProvisionedIops(int provisionedIops);
 	bool getAutoRenew() const;
 	void setAutoRenew(bool autoRenew);
 	std::string getHotStandbyCluster() const;
@@ -165,6 +167,7 @@ private:
 	std::string vSwitchId_;
 	std::string securityIPList_;
 	std::string dBMinorVersion_;
+	int provisionedIops_;
 	bool autoRenew_;
 	std::string hotStandbyCluster_;
 	std::string storagePayType_;

polardb/include/alibabacloud/polardb/model/DescribeDBClusterAttributeResult.h

@@ -43,6 +43,7 @@ namespace AlibabaCloud
 				};
 				struct DBNode
 				{
+					std::string memorySize;
 					std::string dBNodeStatus;
 					std::string zoneId;
 					int maxConnections;
@@ -54,6 +55,7 @@ namespace AlibabaCloud
 					std::string dBNodeClass;
 					std::string serverlessType;
 					std::string creationTime;
+					std::string cpuCores;
 					std::string sccMode;
 					std::string masterId;
 					int failoverPriority;
@@ -92,6 +94,7 @@ namespace AlibabaCloud
 				std::string getExpired()const;
 				std::string getPayType()const;
 				std::string getLockMode()const;
+				std::string getProvisionedIops()const;
 				long getStorageUsed()const;
 				long getInodeTotal()const;
 				std::string getCompressStorageMode()const;
@@ -111,6 +114,7 @@ namespace AlibabaCloud
 				std::string getZoneIds()const;
 				long getInodeUsed()const;
 				std::string getMaintainTime()const;
+				std::string getHotStandbyClusterStatus()const;
 				long getBlktagTotal()const;
 				std::string getDataSyncMode()const;
 				std::string getDBClusterStatus()const;
@@ -151,6 +155,7 @@ namespace AlibabaCloud
 				std::string expired_;
 				std::string payType_;
 				std::string lockMode_;
+				std::string provisionedIops_;
 				long storageUsed_;
 				long inodeTotal_;
 				std::string compressStorageMode_;
@@ -170,6 +175,7 @@ namespace AlibabaCloud
 				std::string zoneIds_;
 				long inodeUsed_;
 				std::string maintainTime_;
+				std::string hotStandbyClusterStatus_;
 				long blktagTotal_;
 				std::string dataSyncMode_;
 				std::string dBClusterStatus_;

polardb/include/alibabacloud/polardb/model/DescribeMetaListRequest.h

@@ -32,6 +32,8 @@ public:
 	~DescribeMetaListRequest();
 	long getResourceOwnerId() const;
 	void setResourceOwnerId(long resourceOwnerId);
+	std::string getRegionCode() const;
+	void setRegionCode(const std::string &regionCode);
 	int getPageNumber() const;
 	void setPageNumber(int pageNumber);
 	std::string getAccessKeyId() const;
@@ -57,6 +59,7 @@ public:
 
 private:
 	long resourceOwnerId_;
+	std::string regionCode_;
 	int pageNumber_;
 	std::string accessKeyId_;
 	std::string securityToken_;

polardb/include/alibabacloud/polardb/model/DisableDBClusterServerlessRequest.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_POLARDB_MODEL_DISABLEDBCLUSTERSERVERLESSREQUEST_H_
+#define ALIBABACLOUD_POLARDB_MODEL_DISABLEDBCLUSTERSERVERLESSREQUEST_H_
+
+#include <alibabacloud/polardb/PolardbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Polardb {
+namespace Model {
+class ALIBABACLOUD_POLARDB_EXPORT DisableDBClusterServerlessRequest : public RpcServiceRequest {
+public:
+	DisableDBClusterServerlessRequest();
+	~DisableDBClusterServerlessRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	long resourceOwnerId_;
+	std::string accessKeyId_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Polardb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_POLARDB_MODEL_DISABLEDBCLUSTERSERVERLESSREQUEST_H_

polardb/include/alibabacloud/polardb/model/DisableDBClusterServerlessResult.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_POLARDB_MODEL_DISABLEDBCLUSTERSERVERLESSRESULT_H_
+#define ALIBABACLOUD_POLARDB_MODEL_DISABLEDBCLUSTERSERVERLESSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/polardb/PolardbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDB_EXPORT DisableDBClusterServerlessResult : public ServiceResult
+			{
+			public:
+
+
+				DisableDBClusterServerlessResult();
+				explicit DisableDBClusterServerlessResult(const std::string &payload);
+				~DisableDBClusterServerlessResult();
+				std::string getDBClusterId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string dBClusterId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDB_MODEL_DISABLEDBCLUSTERSERVERLESSRESULT_H_

polardb/include/alibabacloud/polardb/model/EnableDBClusterServerlessRequest.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_POLARDB_MODEL_ENABLEDBCLUSTERSERVERLESSREQUEST_H_
+#define ALIBABACLOUD_POLARDB_MODEL_ENABLEDBCLUSTERSERVERLESSREQUEST_H_
+
+#include <alibabacloud/polardb/PolardbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Polardb {
+namespace Model {
+class ALIBABACLOUD_POLARDB_EXPORT EnableDBClusterServerlessRequest : public RpcServiceRequest {
+public:
+	EnableDBClusterServerlessRequest();
+	~EnableDBClusterServerlessRequest();
+	std::string getScaleRoNumMax() const;
+	void setScaleRoNumMax(const std::string &scaleRoNumMax);
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getScaleApRoNumMax() const;
+	void setScaleApRoNumMax(const std::string &scaleApRoNumMax);
+	std::string getScaleMax() const;
+	void setScaleMax(const std::string &scaleMax);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getScaleApRoNumMin() const;
+	void setScaleApRoNumMin(const std::string &scaleApRoNumMin);
+	std::string getScaleMin() const;
+	void setScaleMin(const std::string &scaleMin);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getDBClusterId() const;
+	void setDBClusterId(const std::string &dBClusterId);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getScaleRoNumMin() const;
+	void setScaleRoNumMin(const std::string &scaleRoNumMin);
+
+private:
+	std::string scaleRoNumMax_;
+	long resourceOwnerId_;
+	std::string scaleApRoNumMax_;
+	std::string scaleMax_;
+	std::string accessKeyId_;
+	std::string scaleApRoNumMin_;
+	std::string scaleMin_;
+	std::string resourceOwnerAccount_;
+	std::string dBClusterId_;
+	std::string ownerAccount_;
+	long ownerId_;
+	std::string scaleRoNumMin_;
+};
+} // namespace Model
+} // namespace Polardb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_POLARDB_MODEL_ENABLEDBCLUSTERSERVERLESSREQUEST_H_

polardb/include/alibabacloud/polardb/model/EnableDBClusterServerlessResult.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_POLARDB_MODEL_ENABLEDBCLUSTERSERVERLESSRESULT_H_
+#define ALIBABACLOUD_POLARDB_MODEL_ENABLEDBCLUSTERSERVERLESSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/polardb/PolardbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDB_EXPORT EnableDBClusterServerlessResult : public ServiceResult
+			{
+			public:
+
+
+				EnableDBClusterServerlessResult();
+				explicit EnableDBClusterServerlessResult(const std::string &payload);
+				~EnableDBClusterServerlessResult();
+				std::string getDBClusterId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string dBClusterId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDB_MODEL_ENABLEDBCLUSTERSERVERLESSRESULT_H_

polardb/include/alibabacloud/polardb/model/ModifyDBClusterPrimaryZoneRequest.h

@@ -54,6 +54,8 @@ public:
 	void setVPCId(const std::string &vPCId);
 	std::string getZoneId() const;
 	void setZoneId(const std::string &zoneId);
+	std::string getZoneType() const;
+	void setZoneType(const std::string &zoneType);
 	bool getFromTimeService() const;
 	void setFromTimeService(bool fromTimeService);
 
@@ -70,6 +72,7 @@ private:
 	std::string plannedStartTime_;
 	std::string vPCId_;
 	std::string zoneId_;
+	std::string zoneType_;
 	bool fromTimeService_;
 };
 } // namespace Model

polardb/include/alibabacloud/polardb/model/ModifyDBClusterServerlessConfRequest.h

@@ -38,6 +38,8 @@ public:
 	void setScaleApRoNumMax(const std::string &scaleApRoNumMax);
 	std::string getScaleMax() const;
 	void setScaleMax(const std::string &scaleMax);
+	std::string getPlannedEndTime() const;
+	void setPlannedEndTime(const std::string &plannedEndTime);
 	std::string getAccessKeyId() const;
 	void setAccessKeyId(const std::string &accessKeyId);
 	std::string getSecondsUntilAutoPause() const;
@@ -54,16 +56,21 @@ public:
 	void setOwnerAccount(const std::string &ownerAccount);
 	long getOwnerId() const;
 	void setOwnerId(long ownerId);
+	std::string getPlannedStartTime() const;
+	void setPlannedStartTime(const std::string &plannedStartTime);
 	std::string getScaleRoNumMin() const;
 	void setScaleRoNumMin(const std::string &scaleRoNumMin);
 	std::string getAllowShutDown() const;
 	void setAllowShutDown(const std::string &allowShutDown);
+	bool getFromTimeService() const;
+	void setFromTimeService(bool fromTimeService);
 
 private:
 	std::string scaleRoNumMax_;
 	long resourceOwnerId_;
 	std::string scaleApRoNumMax_;
 	std::string scaleMax_;
+	std::string plannedEndTime_;
 	std::string accessKeyId_;
 	std::string secondsUntilAutoPause_;
 	std::string scaleApRoNumMin_;
@@ -72,8 +79,10 @@ private:
 	std::string dBClusterId_;
 	std::string ownerAccount_;
 	long ownerId_;
+	std::string plannedStartTime_;
 	std::string scaleRoNumMin_;
 	std::string allowShutDown_;
+	bool fromTimeService_;
 };
 } // namespace Model
 } // namespace Polardb

polardb/include/alibabacloud/polardb/model/ModifyDBEndpointAddressRequest.h

@@ -50,10 +50,14 @@ public:
 	void setOwnerAccount(const std::string &ownerAccount);
 	long getOwnerId() const;
 	void setOwnerId(long ownerId);
+	std::string getVSwitchId() const;
+	void setVSwitchId(const std::string &vSwitchId);
 	std::string getPort() const;
 	void setPort(const std::string &port);
 	std::string getNetType() const;
 	void setNetType(const std::string &netType);
+	std::string getVPCId() const;
+	void setVPCId(const std::string &vPCId);
 
 private:
 	long resourceOwnerId_;
@@ -66,8 +70,10 @@ private:
 	std::string dBClusterId_;
 	std::string ownerAccount_;
 	long ownerId_;
+	std::string vSwitchId_;
 	std::string port_;
 	std::string netType_;
+	std::string vPCId_;
 };
 } // namespace Model
 } // namespace Polardb

polardb/src/PolardbClient.cc

@@ -375,6 +375,42 @@ PolardbClient::CreateBackupOutcomeCallable PolardbClient::createBackupCallable(c
 	return task->get_future();
 }
 
+PolardbClient::CreateColdStorageInstanceOutcome PolardbClient::createColdStorageInstance(const CreateColdStorageInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateColdStorageInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateColdStorageInstanceOutcome(CreateColdStorageInstanceResult(outcome.result()));
+	else
+		return CreateColdStorageInstanceOutcome(outcome.error());
+}
+
+void PolardbClient::createColdStorageInstanceAsync(const CreateColdStorageInstanceRequest& request, const CreateColdStorageInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createColdStorageInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PolardbClient::CreateColdStorageInstanceOutcomeCallable PolardbClient::createColdStorageInstanceCallable(const CreateColdStorageInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateColdStorageInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->createColdStorageInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 PolardbClient::CreateDBClusterOutcome PolardbClient::createDBCluster(const CreateDBClusterRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3075,6 +3111,78 @@ PolardbClient::DescribeVSwitchesOutcomeCallable PolardbClient::describeVSwitches
 	return task->get_future();
 }
 
+PolardbClient::DisableDBClusterServerlessOutcome PolardbClient::disableDBClusterServerless(const DisableDBClusterServerlessRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DisableDBClusterServerlessOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DisableDBClusterServerlessOutcome(DisableDBClusterServerlessResult(outcome.result()));
+	else
+		return DisableDBClusterServerlessOutcome(outcome.error());
+}
+
+void PolardbClient::disableDBClusterServerlessAsync(const DisableDBClusterServerlessRequest& request, const DisableDBClusterServerlessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, disableDBClusterServerless(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PolardbClient::DisableDBClusterServerlessOutcomeCallable PolardbClient::disableDBClusterServerlessCallable(const DisableDBClusterServerlessRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DisableDBClusterServerlessOutcome()>>(
+			[this, request]()
+			{
+			return this->disableDBClusterServerless(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PolardbClient::EnableDBClusterServerlessOutcome PolardbClient::enableDBClusterServerless(const EnableDBClusterServerlessRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EnableDBClusterServerlessOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EnableDBClusterServerlessOutcome(EnableDBClusterServerlessResult(outcome.result()));
+	else
+		return EnableDBClusterServerlessOutcome(outcome.error());
+}
+
+void PolardbClient::enableDBClusterServerlessAsync(const EnableDBClusterServerlessRequest& request, const EnableDBClusterServerlessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, enableDBClusterServerless(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PolardbClient::EnableDBClusterServerlessOutcomeCallable PolardbClient::enableDBClusterServerlessCallable(const EnableDBClusterServerlessRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EnableDBClusterServerlessOutcome()>>(
+			[this, request]()
+			{
+			return this->enableDBClusterServerless(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 PolardbClient::EnableFirewallRulesOutcome PolardbClient::enableFirewallRules(const EnableFirewallRulesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

polardb/src/model/CreateColdStorageInstanceRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/polardb/model/CreateColdStorageInstanceRequest.h>
+
+using AlibabaCloud::Polardb::Model::CreateColdStorageInstanceRequest;
+
+CreateColdStorageInstanceRequest::CreateColdStorageInstanceRequest()
+    : RpcServiceRequest("polardb", "2017-08-01", "CreateColdStorageInstance") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateColdStorageInstanceRequest::~CreateColdStorageInstanceRequest() {}
+
+long CreateColdStorageInstanceRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateColdStorageInstanceRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreateColdStorageInstanceRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreateColdStorageInstanceRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string CreateColdStorageInstanceRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void CreateColdStorageInstanceRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string CreateColdStorageInstanceRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void CreateColdStorageInstanceRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
+std::string CreateColdStorageInstanceRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreateColdStorageInstanceRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CreateColdStorageInstanceRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void CreateColdStorageInstanceRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+std::string CreateColdStorageInstanceRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreateColdStorageInstanceRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::string CreateColdStorageInstanceRequest::getColdStorageInstanceDescription() const {
+  return coldStorageInstanceDescription_;
+}
+
+void CreateColdStorageInstanceRequest::setColdStorageInstanceDescription(const std::string &coldStorageInstanceDescription) {
+  coldStorageInstanceDescription_ = coldStorageInstanceDescription;
+  setParameter(std::string("ColdStorageInstanceDescription"), coldStorageInstanceDescription);
+}
+
+long CreateColdStorageInstanceRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateColdStorageInstanceRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

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

polardb/src/model/CreateDBClusterEndpointRequest.cc

@@ -133,6 +133,15 @@ void CreateDBClusterEndpointRequest::setOwnerId(long ownerId) {
   setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
+std::string CreateDBClusterEndpointRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void CreateDBClusterEndpointRequest::setVSwitchId(const std::string &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  setParameter(std::string("VSwitchId"), vSwitchId);
+}
+
 std::string CreateDBClusterEndpointRequest::getNodes() const {
   return nodes_;
 }
@@ -142,3 +151,12 @@ void CreateDBClusterEndpointRequest::setNodes(const std::string &nodes) {
   setParameter(std::string("Nodes"), nodes);
 }
 
+std::string CreateDBClusterEndpointRequest::getVPCId() const {
+  return vPCId_;
+}
+
+void CreateDBClusterEndpointRequest::setVPCId(const std::string &vPCId) {
+  vPCId_ = vPCId;
+  setParameter(std::string("VPCId"), vPCId);
+}
+

polardb/src/model/CreateDBClusterRequest.cc

@@ -201,6 +201,15 @@ void CreateDBClusterRequest::setDBMinorVersion(const std::string &dBMinorVersion
   setParameter(std::string("DBMinorVersion"), dBMinorVersion);
 }
 
+int CreateDBClusterRequest::getProvisionedIops() const {
+  return provisionedIops_;
+}
+
+void CreateDBClusterRequest::setProvisionedIops(int provisionedIops) {
+  provisionedIops_ = provisionedIops;
+  setParameter(std::string("ProvisionedIops"), std::to_string(provisionedIops));
+}
+
 bool CreateDBClusterRequest::getAutoRenew() const {
   return autoRenew_;
 }

polardb/src/model/DescribeDBClusterAttributeResult.cc

@@ -51,6 +51,10 @@ void DescribeDBClusterAttributeResult::parse(const std::string &payload)
 			dBNodesObject.maxIOPS = std::stoi(valueDBNodesDBNode["MaxIOPS"].asString());
 		if(!valueDBNodesDBNode["DBNodeClass"].isNull())
 			dBNodesObject.dBNodeClass = valueDBNodesDBNode["DBNodeClass"].asString();
+		if(!valueDBNodesDBNode["CpuCores"].isNull())
+			dBNodesObject.cpuCores = valueDBNodesDBNode["CpuCores"].asString();
+		if(!valueDBNodesDBNode["MemorySize"].isNull())
+			dBNodesObject.memorySize = valueDBNodesDBNode["MemorySize"].asString();
 		if(!valueDBNodesDBNode["DBNodeRole"].isNull())
 			dBNodesObject.dBNodeRole = valueDBNodesDBNode["DBNodeRole"].asString();
 		if(!valueDBNodesDBNode["ZoneId"].isNull())
@@ -118,6 +122,8 @@ void DescribeDBClusterAttributeResult::parse(const std::string &payload)
 		isLatestVersion_ = value["IsLatestVersion"].asString() == "true";
 	if(!value["HasCompleteStandbyRes"].isNull())
 		hasCompleteStandbyRes_ = value["HasCompleteStandbyRes"].asString() == "true";
+	if(!value["HotStandbyClusterStatus"].isNull())
+		hotStandbyClusterStatus_ = value["HotStandbyClusterStatus"].asString();
 	if(!value["HotStandbyCluster"].isNull())
 		hotStandbyCluster_ = value["HotStandbyCluster"].asString();
 	if(!value["DataSyncMode"].isNull())
@@ -204,6 +210,8 @@ void DescribeDBClusterAttributeResult::parse(const std::string &payload)
 		architecture_ = value["Architecture"].asString();
 	if(!value["AiType"].isNull())
 		aiType_ = value["AiType"].asString();
+	if(!value["ProvisionedIops"].isNull())
+		provisionedIops_ = value["ProvisionedIops"].asString();
 
 }
 
@@ -317,6 +325,11 @@ std::string DescribeDBClusterAttributeResult::getLockMode()const
 	return lockMode_;
 }
 
+std::string DescribeDBClusterAttributeResult::getProvisionedIops()const
+{
+	return provisionedIops_;
+}
+
 long DescribeDBClusterAttributeResult::getStorageUsed()const
 {
 	return storageUsed_;
@@ -412,6 +425,11 @@ std::string DescribeDBClusterAttributeResult::getMaintainTime()const
 	return maintainTime_;
 }
 
+std::string DescribeDBClusterAttributeResult::getHotStandbyClusterStatus()const
+{
+	return hotStandbyClusterStatus_;
+}
+
 long DescribeDBClusterAttributeResult::getBlktagTotal()const
 {
 	return blktagTotal_;

polardb/src/model/DescribeMetaListRequest.cc

@@ -34,6 +34,15 @@ void DescribeMetaListRequest::setResourceOwnerId(long resourceOwnerId) {
   setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
+std::string DescribeMetaListRequest::getRegionCode() const {
+  return regionCode_;
+}
+
+void DescribeMetaListRequest::setRegionCode(const std::string &regionCode) {
+  regionCode_ = regionCode;
+  setParameter(std::string("RegionCode"), regionCode);
+}
+
 int DescribeMetaListRequest::getPageNumber() const {
   return pageNumber_;
 }

polardb/src/model/DisableDBClusterServerlessRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * 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/polardb/model/DisableDBClusterServerlessRequest.h>
+
+using AlibabaCloud::Polardb::Model::DisableDBClusterServerlessRequest;
+
+DisableDBClusterServerlessRequest::DisableDBClusterServerlessRequest()
+    : RpcServiceRequest("polardb", "2017-08-01", "DisableDBClusterServerless") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DisableDBClusterServerlessRequest::~DisableDBClusterServerlessRequest() {}
+
+long DisableDBClusterServerlessRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DisableDBClusterServerlessRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DisableDBClusterServerlessRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DisableDBClusterServerlessRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string DisableDBClusterServerlessRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DisableDBClusterServerlessRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DisableDBClusterServerlessRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void DisableDBClusterServerlessRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+std::string DisableDBClusterServerlessRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DisableDBClusterServerlessRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DisableDBClusterServerlessRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DisableDBClusterServerlessRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

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

polardb/src/model/EnableDBClusterServerlessRequest.cc

@@ -0,0 +1,135 @@
+/*
+ * 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/polardb/model/EnableDBClusterServerlessRequest.h>
+
+using AlibabaCloud::Polardb::Model::EnableDBClusterServerlessRequest;
+
+EnableDBClusterServerlessRequest::EnableDBClusterServerlessRequest()
+    : RpcServiceRequest("polardb", "2017-08-01", "EnableDBClusterServerless") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+EnableDBClusterServerlessRequest::~EnableDBClusterServerlessRequest() {}
+
+std::string EnableDBClusterServerlessRequest::getScaleRoNumMax() const {
+  return scaleRoNumMax_;
+}
+
+void EnableDBClusterServerlessRequest::setScaleRoNumMax(const std::string &scaleRoNumMax) {
+  scaleRoNumMax_ = scaleRoNumMax;
+  setParameter(std::string("ScaleRoNumMax"), scaleRoNumMax);
+}
+
+long EnableDBClusterServerlessRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void EnableDBClusterServerlessRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string EnableDBClusterServerlessRequest::getScaleApRoNumMax() const {
+  return scaleApRoNumMax_;
+}
+
+void EnableDBClusterServerlessRequest::setScaleApRoNumMax(const std::string &scaleApRoNumMax) {
+  scaleApRoNumMax_ = scaleApRoNumMax;
+  setParameter(std::string("ScaleApRoNumMax"), scaleApRoNumMax);
+}
+
+std::string EnableDBClusterServerlessRequest::getScaleMax() const {
+  return scaleMax_;
+}
+
+void EnableDBClusterServerlessRequest::setScaleMax(const std::string &scaleMax) {
+  scaleMax_ = scaleMax;
+  setParameter(std::string("ScaleMax"), scaleMax);
+}
+
+std::string EnableDBClusterServerlessRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void EnableDBClusterServerlessRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string EnableDBClusterServerlessRequest::getScaleApRoNumMin() const {
+  return scaleApRoNumMin_;
+}
+
+void EnableDBClusterServerlessRequest::setScaleApRoNumMin(const std::string &scaleApRoNumMin) {
+  scaleApRoNumMin_ = scaleApRoNumMin;
+  setParameter(std::string("ScaleApRoNumMin"), scaleApRoNumMin);
+}
+
+std::string EnableDBClusterServerlessRequest::getScaleMin() const {
+  return scaleMin_;
+}
+
+void EnableDBClusterServerlessRequest::setScaleMin(const std::string &scaleMin) {
+  scaleMin_ = scaleMin;
+  setParameter(std::string("ScaleMin"), scaleMin);
+}
+
+std::string EnableDBClusterServerlessRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void EnableDBClusterServerlessRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string EnableDBClusterServerlessRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void EnableDBClusterServerlessRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+std::string EnableDBClusterServerlessRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void EnableDBClusterServerlessRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long EnableDBClusterServerlessRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void EnableDBClusterServerlessRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string EnableDBClusterServerlessRequest::getScaleRoNumMin() const {
+  return scaleRoNumMin_;
+}
+
+void EnableDBClusterServerlessRequest::setScaleRoNumMin(const std::string &scaleRoNumMin) {
+  scaleRoNumMin_ = scaleRoNumMin;
+  setParameter(std::string("ScaleRoNumMin"), scaleRoNumMin);
+}
+

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

polardb/src/model/ModifyDBClusterPrimaryZoneRequest.cc

@@ -133,6 +133,15 @@ void ModifyDBClusterPrimaryZoneRequest::setZoneId(const std::string &zoneId) {
   setParameter(std::string("ZoneId"), zoneId);
 }
 
+std::string ModifyDBClusterPrimaryZoneRequest::getZoneType() const {
+  return zoneType_;
+}
+
+void ModifyDBClusterPrimaryZoneRequest::setZoneType(const std::string &zoneType) {
+  zoneType_ = zoneType;
+  setParameter(std::string("ZoneType"), zoneType);
+}
+
 bool ModifyDBClusterPrimaryZoneRequest::getFromTimeService() const {
   return fromTimeService_;
 }

polardb/src/model/ModifyDBClusterServerlessConfRequest.cc

@@ -61,6 +61,15 @@ void ModifyDBClusterServerlessConfRequest::setScaleMax(const std::string &scaleM
   setParameter(std::string("ScaleMax"), scaleMax);
 }
 
+std::string ModifyDBClusterServerlessConfRequest::getPlannedEndTime() const {
+  return plannedEndTime_;
+}
+
+void ModifyDBClusterServerlessConfRequest::setPlannedEndTime(const std::string &plannedEndTime) {
+  plannedEndTime_ = plannedEndTime;
+  setParameter(std::string("PlannedEndTime"), plannedEndTime);
+}
+
 std::string ModifyDBClusterServerlessConfRequest::getAccessKeyId() const {
   return accessKeyId_;
 }
@@ -133,6 +142,15 @@ void ModifyDBClusterServerlessConfRequest::setOwnerId(long ownerId) {
   setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
+std::string ModifyDBClusterServerlessConfRequest::getPlannedStartTime() const {
+  return plannedStartTime_;
+}
+
+void ModifyDBClusterServerlessConfRequest::setPlannedStartTime(const std::string &plannedStartTime) {
+  plannedStartTime_ = plannedStartTime;
+  setParameter(std::string("PlannedStartTime"), plannedStartTime);
+}
+
 std::string ModifyDBClusterServerlessConfRequest::getScaleRoNumMin() const {
   return scaleRoNumMin_;
 }
@@ -151,3 +169,12 @@ void ModifyDBClusterServerlessConfRequest::setAllowShutDown(const std::string &a
   setParameter(std::string("AllowShutDown"), allowShutDown);
 }
 
+bool ModifyDBClusterServerlessConfRequest::getFromTimeService() const {
+  return fromTimeService_;
+}
+
+void ModifyDBClusterServerlessConfRequest::setFromTimeService(bool fromTimeService) {
+  fromTimeService_ = fromTimeService;
+  setParameter(std::string("FromTimeService"), fromTimeService ? "true" : "false");
+}
+

polardb/src/model/ModifyDBEndpointAddressRequest.cc

@@ -115,6 +115,15 @@ void ModifyDBEndpointAddressRequest::setOwnerId(long ownerId) {
   setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
+std::string ModifyDBEndpointAddressRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void ModifyDBEndpointAddressRequest::setVSwitchId(const std::string &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  setParameter(std::string("VSwitchId"), vSwitchId);
+}
+
 std::string ModifyDBEndpointAddressRequest::getPort() const {
   return port_;
 }
@@ -133,3 +142,12 @@ void ModifyDBEndpointAddressRequest::setNetType(const std::string &netType) {
   setParameter(std::string("NetType"), netType);
 }
 
+std::string ModifyDBEndpointAddressRequest::getVPCId() const {
+  return vPCId_;
+}
+
+void ModifyDBEndpointAddressRequest::setVPCId(const std::string &vPCId) {
+  vPCId_ = vPCId;
+  setParameter(std::string("VPCId"), vPCId);
+}
+