Generated 2019-09-01 for OceanBasePro.

VERSION

@@ -1 +1 @@
-1.36.1826
+1.36.1827

oceanbasepro/CMakeLists.txt

@@ -69,6 +69,10 @@ set(oceanbasepro_public_header_model
 	include/alibabacloud/oceanbasepro/model/DescribeAvailableCpuResourceResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeAvailableMemResourceRequest.h
 	include/alibabacloud/oceanbasepro/model/DescribeAvailableMemResourceResult.h
+	include/alibabacloud/oceanbasepro/model/DescribeAvailableSpecRequest.h
+	include/alibabacloud/oceanbasepro/model/DescribeAvailableSpecResult.h
+	include/alibabacloud/oceanbasepro/model/DescribeAvailableZoneRequest.h
+	include/alibabacloud/oceanbasepro/model/DescribeAvailableZoneResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeCharsetRequest.h
 	include/alibabacloud/oceanbasepro/model/DescribeCharsetResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeDatabasesRequest.h
@@ -143,6 +147,8 @@ set(oceanbasepro_public_header_model
 	include/alibabacloud/oceanbasepro/model/DescribeSlowSQLListResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeTenantRequest.h
 	include/alibabacloud/oceanbasepro/model/DescribeTenantResult.h
+	include/alibabacloud/oceanbasepro/model/DescribeTenantEncryptionRequest.h
+	include/alibabacloud/oceanbasepro/model/DescribeTenantEncryptionResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeTenantMetricsRequest.h
 	include/alibabacloud/oceanbasepro/model/DescribeTenantMetricsResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeTenantSecurityConfigsRequest.h
@@ -191,6 +197,8 @@ set(oceanbasepro_public_header_model
 	include/alibabacloud/oceanbasepro/model/ModifyInstanceSpecResult.h
 	include/alibabacloud/oceanbasepro/model/ModifyInstanceTagsRequest.h
 	include/alibabacloud/oceanbasepro/model/ModifyInstanceTagsResult.h
+	include/alibabacloud/oceanbasepro/model/ModifyInstanceTemporaryCapacityRequest.h
+	include/alibabacloud/oceanbasepro/model/ModifyInstanceTemporaryCapacityResult.h
 	include/alibabacloud/oceanbasepro/model/ModifyParametersRequest.h
 	include/alibabacloud/oceanbasepro/model/ModifyParametersResult.h
 	include/alibabacloud/oceanbasepro/model/ModifySecurityIpsRequest.h
@@ -292,6 +300,10 @@ set(oceanbasepro_src
 	src/model/DescribeAvailableCpuResourceResult.cc
 	src/model/DescribeAvailableMemResourceRequest.cc
 	src/model/DescribeAvailableMemResourceResult.cc
+	src/model/DescribeAvailableSpecRequest.cc
+	src/model/DescribeAvailableSpecResult.cc
+	src/model/DescribeAvailableZoneRequest.cc
+	src/model/DescribeAvailableZoneResult.cc
 	src/model/DescribeCharsetRequest.cc
 	src/model/DescribeCharsetResult.cc
 	src/model/DescribeDatabasesRequest.cc
@@ -366,6 +378,8 @@ set(oceanbasepro_src
 	src/model/DescribeSlowSQLListResult.cc
 	src/model/DescribeTenantRequest.cc
 	src/model/DescribeTenantResult.cc
+	src/model/DescribeTenantEncryptionRequest.cc
+	src/model/DescribeTenantEncryptionResult.cc
 	src/model/DescribeTenantMetricsRequest.cc
 	src/model/DescribeTenantMetricsResult.cc
 	src/model/DescribeTenantSecurityConfigsRequest.cc
@@ -414,6 +428,8 @@ set(oceanbasepro_src
 	src/model/ModifyInstanceSpecResult.cc
 	src/model/ModifyInstanceTagsRequest.cc
 	src/model/ModifyInstanceTagsResult.cc
+	src/model/ModifyInstanceTemporaryCapacityRequest.cc
+	src/model/ModifyInstanceTemporaryCapacityResult.cc
 	src/model/ModifyParametersRequest.cc
 	src/model/ModifyParametersResult.cc
 	src/model/ModifySecurityIpsRequest.cc

oceanbasepro/include/alibabacloud/oceanbasepro/OceanBaseProClient.h

@@ -70,6 +70,10 @@
 #include "model/DescribeAvailableCpuResourceResult.h"
 #include "model/DescribeAvailableMemResourceRequest.h"
 #include "model/DescribeAvailableMemResourceResult.h"
+#include "model/DescribeAvailableSpecRequest.h"
+#include "model/DescribeAvailableSpecResult.h"
+#include "model/DescribeAvailableZoneRequest.h"
+#include "model/DescribeAvailableZoneResult.h"
 #include "model/DescribeCharsetRequest.h"
 #include "model/DescribeCharsetResult.h"
 #include "model/DescribeDatabasesRequest.h"
@@ -144,6 +148,8 @@
 #include "model/DescribeSlowSQLListResult.h"
 #include "model/DescribeTenantRequest.h"
 #include "model/DescribeTenantResult.h"
+#include "model/DescribeTenantEncryptionRequest.h"
+#include "model/DescribeTenantEncryptionResult.h"
 #include "model/DescribeTenantMetricsRequest.h"
 #include "model/DescribeTenantMetricsResult.h"
 #include "model/DescribeTenantSecurityConfigsRequest.h"
@@ -192,6 +198,8 @@
 #include "model/ModifyInstanceSpecResult.h"
 #include "model/ModifyInstanceTagsRequest.h"
 #include "model/ModifyInstanceTagsResult.h"
+#include "model/ModifyInstanceTemporaryCapacityRequest.h"
+#include "model/ModifyInstanceTemporaryCapacityResult.h"
 #include "model/ModifyParametersRequest.h"
 #include "model/ModifyParametersResult.h"
 #include "model/ModifySecurityIpsRequest.h"
@@ -323,6 +331,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeAvailableMemResourceResult> DescribeAvailableMemResourceOutcome;
 			typedef std::future<DescribeAvailableMemResourceOutcome> DescribeAvailableMemResourceOutcomeCallable;
 			typedef std::function<void(const OceanBaseProClient*, const Model::DescribeAvailableMemResourceRequest&, const DescribeAvailableMemResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAvailableMemResourceAsyncHandler;
+			typedef Outcome<Error, Model::DescribeAvailableSpecResult> DescribeAvailableSpecOutcome;
+			typedef std::future<DescribeAvailableSpecOutcome> DescribeAvailableSpecOutcomeCallable;
+			typedef std::function<void(const OceanBaseProClient*, const Model::DescribeAvailableSpecRequest&, const DescribeAvailableSpecOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAvailableSpecAsyncHandler;
+			typedef Outcome<Error, Model::DescribeAvailableZoneResult> DescribeAvailableZoneOutcome;
+			typedef std::future<DescribeAvailableZoneOutcome> DescribeAvailableZoneOutcomeCallable;
+			typedef std::function<void(const OceanBaseProClient*, const Model::DescribeAvailableZoneRequest&, const DescribeAvailableZoneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAvailableZoneAsyncHandler;
 			typedef Outcome<Error, Model::DescribeCharsetResult> DescribeCharsetOutcome;
 			typedef std::future<DescribeCharsetOutcome> DescribeCharsetOutcomeCallable;
 			typedef std::function<void(const OceanBaseProClient*, const Model::DescribeCharsetRequest&, const DescribeCharsetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCharsetAsyncHandler;
@@ -434,6 +448,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeTenantResult> DescribeTenantOutcome;
 			typedef std::future<DescribeTenantOutcome> DescribeTenantOutcomeCallable;
 			typedef std::function<void(const OceanBaseProClient*, const Model::DescribeTenantRequest&, const DescribeTenantOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTenantAsyncHandler;
+			typedef Outcome<Error, Model::DescribeTenantEncryptionResult> DescribeTenantEncryptionOutcome;
+			typedef std::future<DescribeTenantEncryptionOutcome> DescribeTenantEncryptionOutcomeCallable;
+			typedef std::function<void(const OceanBaseProClient*, const Model::DescribeTenantEncryptionRequest&, const DescribeTenantEncryptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTenantEncryptionAsyncHandler;
 			typedef Outcome<Error, Model::DescribeTenantMetricsResult> DescribeTenantMetricsOutcome;
 			typedef std::future<DescribeTenantMetricsOutcome> DescribeTenantMetricsOutcomeCallable;
 			typedef std::function<void(const OceanBaseProClient*, const Model::DescribeTenantMetricsRequest&, const DescribeTenantMetricsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTenantMetricsAsyncHandler;
@@ -506,6 +523,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ModifyInstanceTagsResult> ModifyInstanceTagsOutcome;
 			typedef std::future<ModifyInstanceTagsOutcome> ModifyInstanceTagsOutcomeCallable;
 			typedef std::function<void(const OceanBaseProClient*, const Model::ModifyInstanceTagsRequest&, const ModifyInstanceTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyInstanceTagsAsyncHandler;
+			typedef Outcome<Error, Model::ModifyInstanceTemporaryCapacityResult> ModifyInstanceTemporaryCapacityOutcome;
+			typedef std::future<ModifyInstanceTemporaryCapacityOutcome> ModifyInstanceTemporaryCapacityOutcomeCallable;
+			typedef std::function<void(const OceanBaseProClient*, const Model::ModifyInstanceTemporaryCapacityRequest&, const ModifyInstanceTemporaryCapacityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyInstanceTemporaryCapacityAsyncHandler;
 			typedef Outcome<Error, Model::ModifyParametersResult> ModifyParametersOutcome;
 			typedef std::future<ModifyParametersOutcome> ModifyParametersOutcomeCallable;
 			typedef std::function<void(const OceanBaseProClient*, const Model::ModifyParametersRequest&, const ModifyParametersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyParametersAsyncHandler;
@@ -658,6 +678,12 @@ namespace AlibabaCloud
 			DescribeAvailableMemResourceOutcome describeAvailableMemResource(const Model::DescribeAvailableMemResourceRequest &request)const;
 			void describeAvailableMemResourceAsync(const Model::DescribeAvailableMemResourceRequest& request, const DescribeAvailableMemResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeAvailableMemResourceOutcomeCallable describeAvailableMemResourceCallable(const Model::DescribeAvailableMemResourceRequest& request) const;
+			DescribeAvailableSpecOutcome describeAvailableSpec(const Model::DescribeAvailableSpecRequest &request)const;
+			void describeAvailableSpecAsync(const Model::DescribeAvailableSpecRequest& request, const DescribeAvailableSpecAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeAvailableSpecOutcomeCallable describeAvailableSpecCallable(const Model::DescribeAvailableSpecRequest& request) const;
+			DescribeAvailableZoneOutcome describeAvailableZone(const Model::DescribeAvailableZoneRequest &request)const;
+			void describeAvailableZoneAsync(const Model::DescribeAvailableZoneRequest& request, const DescribeAvailableZoneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeAvailableZoneOutcomeCallable describeAvailableZoneCallable(const Model::DescribeAvailableZoneRequest& request) const;
 			DescribeCharsetOutcome describeCharset(const Model::DescribeCharsetRequest &request)const;
 			void describeCharsetAsync(const Model::DescribeCharsetRequest& request, const DescribeCharsetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeCharsetOutcomeCallable describeCharsetCallable(const Model::DescribeCharsetRequest& request) const;
@@ -769,6 +795,9 @@ namespace AlibabaCloud
 			DescribeTenantOutcome describeTenant(const Model::DescribeTenantRequest &request)const;
 			void describeTenantAsync(const Model::DescribeTenantRequest& request, const DescribeTenantAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeTenantOutcomeCallable describeTenantCallable(const Model::DescribeTenantRequest& request) const;
+			DescribeTenantEncryptionOutcome describeTenantEncryption(const Model::DescribeTenantEncryptionRequest &request)const;
+			void describeTenantEncryptionAsync(const Model::DescribeTenantEncryptionRequest& request, const DescribeTenantEncryptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeTenantEncryptionOutcomeCallable describeTenantEncryptionCallable(const Model::DescribeTenantEncryptionRequest& request) const;
 			DescribeTenantMetricsOutcome describeTenantMetrics(const Model::DescribeTenantMetricsRequest &request)const;
 			void describeTenantMetricsAsync(const Model::DescribeTenantMetricsRequest& request, const DescribeTenantMetricsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeTenantMetricsOutcomeCallable describeTenantMetricsCallable(const Model::DescribeTenantMetricsRequest& request) const;
@@ -841,6 +870,9 @@ namespace AlibabaCloud
 			ModifyInstanceTagsOutcome modifyInstanceTags(const Model::ModifyInstanceTagsRequest &request)const;
 			void modifyInstanceTagsAsync(const Model::ModifyInstanceTagsRequest& request, const ModifyInstanceTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyInstanceTagsOutcomeCallable modifyInstanceTagsCallable(const Model::ModifyInstanceTagsRequest& request) const;
+			ModifyInstanceTemporaryCapacityOutcome modifyInstanceTemporaryCapacity(const Model::ModifyInstanceTemporaryCapacityRequest &request)const;
+			void modifyInstanceTemporaryCapacityAsync(const Model::ModifyInstanceTemporaryCapacityRequest& request, const ModifyInstanceTemporaryCapacityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyInstanceTemporaryCapacityOutcomeCallable modifyInstanceTemporaryCapacityCallable(const Model::ModifyInstanceTemporaryCapacityRequest& request) const;
 			ModifyParametersOutcome modifyParameters(const Model::ModifyParametersRequest &request)const;
 			void modifyParametersAsync(const Model::ModifyParametersRequest& request, const ModifyParametersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyParametersOutcomeCallable modifyParametersCallable(const Model::ModifyParametersRequest& request) const;

oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateInstanceRequest.h

@@ -30,6 +30,8 @@ class ALIBABACLOUD_OCEANBASEPRO_EXPORT CreateInstanceRequest : public RpcService
 public:
 	CreateInstanceRequest();
 	~CreateInstanceRequest();
+	std::string getIsolationOptimization() const;
+	void setIsolationOptimization(const std::string &isolationOptimization);
 	std::string getInstanceClass() const;
 	void setInstanceClass(const std::string &instanceClass);
 	std::string getResourceGroupId() const;
@@ -38,6 +40,8 @@ public:
 	void setAutoRenewPeriod(long autoRenewPeriod);
 	long getPeriod() const;
 	void setPeriod(long period);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
 	long getDiskSize() const;
 	void setDiskSize(long diskSize);
 	std::string getZones() const;
@@ -50,6 +54,8 @@ public:
 	void setPeriodUnit(const std::string &periodUnit);
 	std::string getInstanceName() const;
 	void setInstanceName(const std::string &instanceName);
+	std::string getReplicaMode() const;
+	void setReplicaMode(const std::string &replicaMode);
 	bool getAutoRenew() const;
 	void setAutoRenew(bool autoRenew);
 	std::string getSeries() const;
@@ -60,16 +66,19 @@ public:
 	void setBid(const std::string &bid);
 
 private:
+	std::string isolationOptimization_;
 	std::string instanceClass_;
 	std::string resourceGroupId_;
 	long autoRenewPeriod_;
 	long period_;
+	bool dryRun_;
 	long diskSize_;
 	std::string zones_;
 	std::string diskType_;
 	std::string obVersion_;
 	std::string periodUnit_;
 	std::string instanceName_;
+	std::string replicaMode_;
 	bool autoRenew_;
 	std::string series_;
 	std::string chargeType_;

oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateInstanceResult.h

@@ -37,6 +37,7 @@ namespace AlibabaCloud
 					std::string resourceGroupId;
 					std::string instanceId;
 					std::string orderId;
+					bool dryRunResult;
 				};
 
 

oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantRequest.h

@@ -36,6 +36,8 @@ public:
 	void setTenantMode(const std::string &tenantMode);
 	int getMemory() const;
 	void setMemory(int memory);
+	long getLogDisk() const;
+	void setLogDisk(long logDisk);
 	std::string getTimeZone() const;
 	void setTimeZone(const std::string &timeZone);
 	std::string getDescription() const;
@@ -54,11 +56,14 @@ public:
 	void setPrimaryZone(const std::string &primaryZone);
 	std::string getTenantName() const;
 	void setTenantName(const std::string &tenantName);
+	std::string getReadOnlyZoneList() const;
+	void setReadOnlyZoneList(const std::string &readOnlyZoneList);
 
 private:
 	std::string charset_;
 	std::string tenantMode_;
 	int memory_;
+	long logDisk_;
 	std::string timeZone_;
 	std::string description_;
 	std::string userVSwitchId_;
@@ -68,6 +73,7 @@ private:
 	std::string instanceId_;
 	std::string primaryZone_;
 	std::string tenantName_;
+	std::string readOnlyZoneList_;
 };
 } // namespace Model
 } // namespace OceanBasePro

oceanbasepro/include/alibabacloud/oceanbasepro/model/DeleteInstancesRequest.h

@@ -32,11 +32,14 @@ public:
 	~DeleteInstancesRequest();
 	std::string getBackupRetainMode() const;
 	void setBackupRetainMode(const std::string &backupRetainMode);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
 	std::string getInstanceIds() const;
 	void setInstanceIds(const std::string &instanceIds);
 
 private:
 	std::string backupRetainMode_;
+	bool dryRun_;
 	std::string instanceIds_;
 };
 } // namespace Model

oceanbasepro/include/alibabacloud/oceanbasepro/model/DeleteInstancesResult.h

@@ -32,15 +32,21 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_OCEANBASEPRO_EXPORT DeleteInstancesResult : public ServiceResult
 			{
 			public:
+				struct Data
+				{
+					bool dryRunResult;
+				};
 
 
 				DeleteInstancesResult();
 				explicit DeleteInstancesResult(const std::string &payload);
 				~DeleteInstancesResult();
+				Data getData()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				Data data_;
 
 			};
 		}

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableMemResourceResult.h

@@ -37,6 +37,7 @@ namespace AlibabaCloud
 					long maxMem;
 					long usedMem;
 					long minMem;
+					std::string safeMem;
 				};
 
 

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableSpecRequest.h

@@ -0,0 +1,48 @@
+/*
+ * 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_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLESPECREQUEST_H_
+#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLESPECREQUEST_H_
+
+#include <alibabacloud/oceanbasepro/OceanBaseProExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace OceanBasePro {
+namespace Model {
+class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeAvailableSpecRequest : public RpcServiceRequest {
+public:
+	DescribeAvailableSpecRequest();
+	~DescribeAvailableSpecRequest();
+	std::string getUpgradeType() const;
+	void setUpgradeType(const std::string &upgradeType);
+	std::string getSpec() const;
+	void setSpec(const std::string &spec);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+
+private:
+	std::string upgradeType_;
+	std::string spec_;
+	std::string instanceId_;
+};
+} // namespace Model
+} // namespace OceanBasePro
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLESPECREQUEST_H_

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableSpecResult.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_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLESPECRESULT_H_
+#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLESPECRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/oceanbasepro/OceanBaseProExport.h>
+
+namespace AlibabaCloud
+{
+	namespace OceanBasePro
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeAvailableSpecResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct AvailableSpecificationsItem
+					{
+						struct DiskSizeRange
+						{
+							long min;
+							long max;
+							long step;
+						};
+						struct LogDiskSizeRange
+						{
+							long min;
+							long max;
+							long step;
+						};
+						std::vector<std::string> nodeNum;
+						DiskSizeRange diskSizeRange;
+						std::string instanceClass;
+						std::string spec;
+						LogDiskSizeRange logDiskSizeRange;
+					};
+					std::vector<AvailableSpecificationsItem> availableSpecifications;
+				};
+
+
+				DescribeAvailableSpecResult();
+				explicit DescribeAvailableSpecResult(const std::string &payload);
+				~DescribeAvailableSpecResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLESPECRESULT_H_

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableZoneRequest.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_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLEZONEREQUEST_H_
+#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLEZONEREQUEST_H_
+
+#include <alibabacloud/oceanbasepro/OceanBaseProExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace OceanBasePro {
+namespace Model {
+class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeAvailableZoneRequest : public RpcServiceRequest {
+public:
+	DescribeAvailableZoneRequest();
+	~DescribeAvailableZoneRequest();
+	std::string getSpec() const;
+	void setSpec(const std::string &spec);
+	std::string getObVersion() const;
+	void setObVersion(const std::string &obVersion);
+	std::string getSeries() const;
+	void setSeries(const std::string &series);
+	std::string getInstanceType() const;
+	void setInstanceType(const std::string &instanceType);
+	std::string getDeployType() const;
+	void setDeployType(const std::string &deployType);
+
+private:
+	std::string spec_;
+	std::string obVersion_;
+	std::string series_;
+	std::string instanceType_;
+	std::string deployType_;
+};
+} // namespace Model
+} // namespace OceanBasePro
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLEZONEREQUEST_H_

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableZoneResult.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLEZONERESULT_H_
+#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLEZONERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/oceanbasepro/OceanBaseProExport.h>
+
+namespace AlibabaCloud
+{
+	namespace OceanBasePro
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeAvailableZoneResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct AvailableZonesItem
+					{
+						struct SupportSpecificationsItem
+						{
+							struct DiskSizeRange
+							{
+								long min;
+								long max;
+								long step;
+							};
+							struct SupportEngineVersionsItem
+							{
+								std::vector<std::string> supportReplicaModes;
+								std::string obVersion;
+								bool supportIsolationOptimization;
+							};
+							DiskSizeRange diskSizeRange;
+							std::vector<std::string> diskTypes;
+							std::vector<SupportSpecificationsItem::SupportEngineVersionsItem> supportEngineVersions;
+							std::string instanceClass;
+							std::string spec;
+						};
+						std::string deployType;
+						std::string series;
+						std::vector<AvailableZonesItem::SupportSpecificationsItem> supportSpecifications;
+						std::string channel;
+						std::string region;
+						std::string instanceType;
+						std::string zones;
+					};
+					std::vector<AvailableZonesItem> availableZones;
+				};
+
+
+				DescribeAvailableZoneResult();
+				explicit DescribeAvailableZoneResult(const std::string &payload);
+				~DescribeAvailableZoneResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEAVAILABLEZONERESULT_H_

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeDatabasesRequest.h

@@ -34,6 +34,8 @@ public:
 	void setSearchKey(const std::string &searchKey);
 	int getPageNumber() const;
 	void setPageNumber(int pageNumber);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
 	std::string getDatabaseName() const;
 	void setDatabaseName(const std::string &databaseName);
 	bool getWithTables() const;
@@ -46,6 +48,7 @@ public:
 private:
 	std::string searchKey_;
 	int pageNumber_;
+	std::string instanceId_;
 	std::string databaseName_;
 	bool withTables_;
 	std::string tenantId_;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeDatabasesResult.h

@@ -48,6 +48,7 @@ namespace AlibabaCloud
 					std::string status;
 					std::string description;
 					std::string instanceId;
+					std::string tenantName;
 					std::string createTime;
 					std::string databaseName;
 					std::string encoding;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceResult.h

@@ -63,6 +63,9 @@ namespace AlibabaCloud
 						};
 						struct LogDiskSize
 						{
+							std::string maxLogAssignedPercent;
+							std::string logAssignedSize;
+							std::vector<std::string> maxLogAssignedObServer;
 							long unitDiskSize;
 							long totalDiskSize;
 						};
@@ -95,17 +98,20 @@ namespace AlibabaCloud
 						bool autoScale;
 					};
 					std::string deployType;
+					std::string proxyServiceStatus;
 					std::string nodeNum;
 					bool enableIsolationOptimization;
 					std::string dataMergeTime;
 					bool inTempCapacityStatus;
 					bool isTrustEcs;
+					std::string proxyClusterId;
 					bool isLatestObVersion;
 					std::vector<std::string> availableZones;
 					std::vector<std::string> zones;
 					std::string diskType;
 					std::string deployMode;
 					std::string version;
+					std::string cpuArchitecture;
 					bool isolationOptimization;
 					std::string instanceRole;
 					std::string maintainTime;
@@ -119,6 +125,7 @@ namespace AlibabaCloud
 					std::string instanceClass;
 					std::string payType;
 					bool dataDiskAutoScale;
+					bool enableProxyService;
 					std::string instanceName;
 					std::string series;
 					DataDiskAutoScaleConfig dataDiskAutoScaleConfig;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSecurityConfigsRequest.h

@@ -32,9 +32,12 @@ public:
 	~DescribeInstanceSecurityConfigsRequest();
 	std::string getInstanceId() const;
 	void setInstanceId(const std::string &instanceId);
+	std::string getCheckId() const;
+	void setCheckId(const std::string &checkId);
 
 private:
 	std::string instanceId_;
+	std::string checkId_;
 };
 } // namespace Model
 } // namespace OceanBasePro

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSecurityConfigsResult.h

@@ -43,6 +43,9 @@ namespace AlibabaCloud
 						std::string configGroup;
 					};
 					std::vector<SecurityConfigsItem> securityConfigs;
+					std::string checkTime;
+					std::string checkId;
+					std::string instanceId;
 					int totalCheckCount;
 					int totalRiskCount;
 				};

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstancesResult.h

@@ -88,6 +88,7 @@ namespace AlibabaCloud
 					std::vector<std::string> availableZones;
 					std::string diskType;
 					std::string deployMode;
+					std::string cpuArchitecture;
 					std::string version;
 					std::string commodityCode;
 					std::string diskSize;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSQLSamplesResult.h

@@ -48,7 +48,7 @@ namespace AlibabaCloud
 					std::string sqlType;
 					double queueTime;
 					double blockIndexCacheHit;
-					double tableScan;
+					bool tableScan;
 					double waitCount;
 					std::string requestId;
 					std::string requestTime;
@@ -65,9 +65,9 @@ namespace AlibabaCloud
 					double memstoreReadRows;
 					double getPlanTime;
 					double elapsedTime;
-					double hitPlan;
+					bool hitPlan;
 					double returnRows;
-					double executorRpc;
+					bool executorRpc;
 					double blockCacheHit;
 					std::string dbName;
 					double netWaitTime;
@@ -75,6 +75,7 @@ namespace AlibabaCloud
 					std::string userName;
 					double netTime;
 					double rpcCount;
+					std::string fullSqlText;
 					std::string statement;
 					double planId;
 					double rowCacheHit;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantEncryptionRequest.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_OCEANBASEPRO_MODEL_DESCRIBETENANTENCRYPTIONREQUEST_H_
+#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBETENANTENCRYPTIONREQUEST_H_
+
+#include <alibabacloud/oceanbasepro/OceanBaseProExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace OceanBasePro {
+namespace Model {
+class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeTenantEncryptionRequest : public RpcServiceRequest {
+public:
+	DescribeTenantEncryptionRequest();
+	~DescribeTenantEncryptionRequest();
+	long getPageNumber() const;
+	void setPageNumber(long pageNumber);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getTenantId() const;
+	void setTenantId(const std::string &tenantId);
+	long getPageSize() const;
+	void setPageSize(long pageSize);
+	std::string getTenantName() const;
+	void setTenantName(const std::string &tenantName);
+
+private:
+	long pageNumber_;
+	std::string instanceId_;
+	std::string tenantId_;
+	long pageSize_;
+	std::string tenantName_;
+};
+} // namespace Model
+} // namespace OceanBasePro
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBETENANTENCRYPTIONREQUEST_H_

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantEncryptionResult.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBETENANTENCRYPTIONRESULT_H_
+#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBETENANTENCRYPTIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/oceanbasepro/OceanBaseProExport.h>
+
+namespace AlibabaCloud
+{
+	namespace OceanBasePro
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeTenantEncryptionResult : public ServiceResult
+			{
+			public:
+				struct TenantEncryptionsItem
+				{
+					std::string status;
+					std::string encryptionType;
+					std::string tenantId;
+					std::string tenantStatus;
+					std::string tenantName;
+					bool enableEncryption;
+					std::string tenantMode;
+					std::string encryptionKeyId;
+				};
+
+
+				DescribeTenantEncryptionResult();
+				explicit DescribeTenantEncryptionResult(const std::string &payload);
+				~DescribeTenantEncryptionResult();
+				int getTotalCount()const;
+				std::vector<TenantEncryptionsItem> getTenantEncryptions()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::vector<TenantEncryptionsItem> tenantEncryptions_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBETENANTENCRYPTIONRESULT_H_

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantResult.h

@@ -58,11 +58,17 @@ namespace AlibabaCloud
 							int maxCapacityUnit;
 							int minCapacityUnit;
 						};
+						struct LogDiskSize
+						{
+							int totalLogDisk;
+							int unitLogDisk;
+						};
 						CapacityUnit capacityUnit;
 						Memory memory;
 						int unitNum;
 						DiskSize diskSize;
 						Cpu cpu;
+						LogDiskSize logDiskSize;
 					};
 					struct TenantConnectionsItem
 					{
@@ -71,6 +77,7 @@ namespace AlibabaCloud
 						std::string internetAddress;
 						std::string intranetAddressSlaveZoneId;
 						std::string internetAddressStatus;
+						long maxConnectionNum;
 						std::string vSwitchId;
 						std::string tenantEndpointId;
 						std::string intranetAddressMasterZoneId;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantSecurityConfigsRequest.h

@@ -34,10 +34,13 @@ public:
 	void setInstanceId(const std::string &instanceId);
 	std::string getTenantId() const;
 	void setTenantId(const std::string &tenantId);
+	std::string getCheckId() const;
+	void setCheckId(const std::string &checkId);
 
 private:
 	std::string instanceId_;
 	std::string tenantId_;
+	std::string checkId_;
 };
 } // namespace Model
 } // namespace OceanBasePro

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantSecurityConfigsResult.h

@@ -49,6 +49,9 @@ namespace AlibabaCloud
 						std::string tenantName;
 						int riskCount;
 					};
+					std::string checkTime;
+					std::string checkId;
+					std::string instanceId;
 					int totalCheckCount;
 					std::vector<TenantSecurityConfigsItem> tenantSecurityConfigs;
 					int totalRiskCount;

oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceNodeNumRequest.h

@@ -30,12 +30,15 @@ class ALIBABACLOUD_OCEANBASEPRO_EXPORT ModifyInstanceNodeNumRequest : public Rpc
 public:
 	ModifyInstanceNodeNumRequest();
 	~ModifyInstanceNodeNumRequest();
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
 	std::string getNodeNum() const;
 	void setNodeNum(const std::string &nodeNum);
 	std::string getInstanceId() const;
 	void setInstanceId(const std::string &instanceId);
 
 private:
+	bool dryRun_;
 	std::string nodeNum_;
 	std::string instanceId_;
 };

oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceNodeNumResult.h

@@ -35,6 +35,7 @@ namespace AlibabaCloud
 				struct Data
 				{
 					std::string orderId;
+					bool dryRunResult;
 				};
 
 

oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSpecRequest.h

@@ -34,6 +34,8 @@ public:
 	void setAutoUseCoupon(bool autoUseCoupon);
 	std::string getInstanceClass() const;
 	void setInstanceClass(const std::string &instanceClass);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
 	long getDiskSize() const;
 	void setDiskSize(long diskSize);
 	std::string getInstanceId() const;
@@ -44,6 +46,7 @@ public:
 private:
 	bool autoUseCoupon_;
 	std::string instanceClass_;
+	bool dryRun_;
 	long diskSize_;
 	std::string instanceId_;
 	long logDiskSize_;

oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSpecResult.h

@@ -35,6 +35,7 @@ namespace AlibabaCloud
 				struct Data
 				{
 					std::string orderId;
+					bool dryRunResult;
 				};
 
 

oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceTemporaryCapacityRequest.h

@@ -0,0 +1,48 @@
+/*
+ * 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_OCEANBASEPRO_MODEL_MODIFYINSTANCETEMPORARYCAPACITYREQUEST_H_
+#define ALIBABACLOUD_OCEANBASEPRO_MODEL_MODIFYINSTANCETEMPORARYCAPACITYREQUEST_H_
+
+#include <alibabacloud/oceanbasepro/OceanBaseProExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace OceanBasePro {
+namespace Model {
+class ALIBABACLOUD_OCEANBASEPRO_EXPORT ModifyInstanceTemporaryCapacityRequest : public RpcServiceRequest {
+public:
+	ModifyInstanceTemporaryCapacityRequest();
+	~ModifyInstanceTemporaryCapacityRequest();
+	std::string getDiskSize() const;
+	void setDiskSize(const std::string &diskSize);
+	std::string getSpec() const;
+	void setSpec(const std::string &spec);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+
+private:
+	std::string diskSize_;
+	std::string spec_;
+	std::string instanceId_;
+};
+} // namespace Model
+} // namespace OceanBasePro
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_MODIFYINSTANCETEMPORARYCAPACITYREQUEST_H_

oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceTemporaryCapacityResult.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_OCEANBASEPRO_MODEL_MODIFYINSTANCETEMPORARYCAPACITYRESULT_H_
+#define ALIBABACLOUD_OCEANBASEPRO_MODEL_MODIFYINSTANCETEMPORARYCAPACITYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/oceanbasepro/OceanBaseProExport.h>
+
+namespace AlibabaCloud
+{
+	namespace OceanBasePro
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_OCEANBASEPRO_EXPORT ModifyInstanceTemporaryCapacityResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyInstanceTemporaryCapacityResult();
+				explicit ModifyInstanceTemporaryCapacityResult(const std::string &payload);
+				~ModifyInstanceTemporaryCapacityResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_MODIFYINSTANCETEMPORARYCAPACITYRESULT_H_

oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyTenantResourceRequest.h

@@ -32,18 +32,24 @@ public:
 	~ModifyTenantResourceRequest();
 	int getMemory() const;
 	void setMemory(int memory);
+	long getLogDisk() const;
+	void setLogDisk(long logDisk);
 	int getCpu() const;
 	void setCpu(int cpu);
 	std::string getInstanceId() const;
 	void setInstanceId(const std::string &instanceId);
 	std::string getTenantId() const;
 	void setTenantId(const std::string &tenantId);
+	std::string getReadOnlyZoneList() const;
+	void setReadOnlyZoneList(const std::string &readOnlyZoneList);
 
 private:
 	int memory_;
+	long logDisk_;
 	int cpu_;
 	std::string instanceId_;
 	std::string tenantId_;
+	std::string readOnlyZoneList_;
 };
 } // namespace Model
 } // namespace OceanBasePro

oceanbasepro/src/OceanBaseProClient.cc

@@ -915,6 +915,78 @@ OceanBaseProClient::DescribeAvailableMemResourceOutcomeCallable OceanBaseProClie
 	return task->get_future();
 }
 
+OceanBaseProClient::DescribeAvailableSpecOutcome OceanBaseProClient::describeAvailableSpec(const DescribeAvailableSpecRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeAvailableSpecOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeAvailableSpecOutcome(DescribeAvailableSpecResult(outcome.result()));
+	else
+		return DescribeAvailableSpecOutcome(outcome.error());
+}
+
+void OceanBaseProClient::describeAvailableSpecAsync(const DescribeAvailableSpecRequest& request, const DescribeAvailableSpecAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeAvailableSpec(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+OceanBaseProClient::DescribeAvailableSpecOutcomeCallable OceanBaseProClient::describeAvailableSpecCallable(const DescribeAvailableSpecRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeAvailableSpecOutcome()>>(
+			[this, request]()
+			{
+			return this->describeAvailableSpec(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+OceanBaseProClient::DescribeAvailableZoneOutcome OceanBaseProClient::describeAvailableZone(const DescribeAvailableZoneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeAvailableZoneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeAvailableZoneOutcome(DescribeAvailableZoneResult(outcome.result()));
+	else
+		return DescribeAvailableZoneOutcome(outcome.error());
+}
+
+void OceanBaseProClient::describeAvailableZoneAsync(const DescribeAvailableZoneRequest& request, const DescribeAvailableZoneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeAvailableZone(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+OceanBaseProClient::DescribeAvailableZoneOutcomeCallable OceanBaseProClient::describeAvailableZoneCallable(const DescribeAvailableZoneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeAvailableZoneOutcome()>>(
+			[this, request]()
+			{
+			return this->describeAvailableZone(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 OceanBaseProClient::DescribeCharsetOutcome OceanBaseProClient::describeCharset(const DescribeCharsetRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2247,6 +2319,42 @@ OceanBaseProClient::DescribeTenantOutcomeCallable OceanBaseProClient::describeTe
 	return task->get_future();
 }
 
+OceanBaseProClient::DescribeTenantEncryptionOutcome OceanBaseProClient::describeTenantEncryption(const DescribeTenantEncryptionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeTenantEncryptionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeTenantEncryptionOutcome(DescribeTenantEncryptionResult(outcome.result()));
+	else
+		return DescribeTenantEncryptionOutcome(outcome.error());
+}
+
+void OceanBaseProClient::describeTenantEncryptionAsync(const DescribeTenantEncryptionRequest& request, const DescribeTenantEncryptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeTenantEncryption(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+OceanBaseProClient::DescribeTenantEncryptionOutcomeCallable OceanBaseProClient::describeTenantEncryptionCallable(const DescribeTenantEncryptionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeTenantEncryptionOutcome()>>(
+			[this, request]()
+			{
+			return this->describeTenantEncryption(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 OceanBaseProClient::DescribeTenantMetricsOutcome OceanBaseProClient::describeTenantMetrics(const DescribeTenantMetricsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3111,6 +3219,42 @@ OceanBaseProClient::ModifyInstanceTagsOutcomeCallable OceanBaseProClient::modify
 	return task->get_future();
 }
 
+OceanBaseProClient::ModifyInstanceTemporaryCapacityOutcome OceanBaseProClient::modifyInstanceTemporaryCapacity(const ModifyInstanceTemporaryCapacityRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyInstanceTemporaryCapacityOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyInstanceTemporaryCapacityOutcome(ModifyInstanceTemporaryCapacityResult(outcome.result()));
+	else
+		return ModifyInstanceTemporaryCapacityOutcome(outcome.error());
+}
+
+void OceanBaseProClient::modifyInstanceTemporaryCapacityAsync(const ModifyInstanceTemporaryCapacityRequest& request, const ModifyInstanceTemporaryCapacityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyInstanceTemporaryCapacity(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+OceanBaseProClient::ModifyInstanceTemporaryCapacityOutcomeCallable OceanBaseProClient::modifyInstanceTemporaryCapacityCallable(const ModifyInstanceTemporaryCapacityRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyInstanceTemporaryCapacityOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyInstanceTemporaryCapacity(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 OceanBaseProClient::ModifyParametersOutcome OceanBaseProClient::modifyParameters(const ModifyParametersRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

oceanbasepro/src/model/CreateInstanceRequest.cc

@@ -25,6 +25,15 @@ CreateInstanceRequest::CreateInstanceRequest()
 
 CreateInstanceRequest::~CreateInstanceRequest() {}
 
+std::string CreateInstanceRequest::getIsolationOptimization() const {
+  return isolationOptimization_;
+}
+
+void CreateInstanceRequest::setIsolationOptimization(const std::string &isolationOptimization) {
+  isolationOptimization_ = isolationOptimization;
+  setBodyParameter(std::string("IsolationOptimization"), isolationOptimization);
+}
+
 std::string CreateInstanceRequest::getInstanceClass() const {
   return instanceClass_;
 }
@@ -61,6 +70,15 @@ void CreateInstanceRequest::setPeriod(long period) {
   setBodyParameter(std::string("Period"), std::to_string(period));
 }
 
+bool CreateInstanceRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void CreateInstanceRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setBodyParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
 long CreateInstanceRequest::getDiskSize() const {
   return diskSize_;
 }
@@ -115,6 +133,15 @@ void CreateInstanceRequest::setInstanceName(const std::string &instanceName) {
   setBodyParameter(std::string("InstanceName"), instanceName);
 }
 
+std::string CreateInstanceRequest::getReplicaMode() const {
+  return replicaMode_;
+}
+
+void CreateInstanceRequest::setReplicaMode(const std::string &replicaMode) {
+  replicaMode_ = replicaMode;
+  setBodyParameter(std::string("ReplicaMode"), replicaMode);
+}
+
 bool CreateInstanceRequest::getAutoRenew() const {
   return autoRenew_;
 }

oceanbasepro/src/model/CreateInstanceResult.cc

@@ -46,6 +46,8 @@ void CreateInstanceResult::parse(const std::string &payload)
 		data_.orderId = dataNode["OrderId"].asString();
 	if(!dataNode["ResourceGroupId"].isNull())
 		data_.resourceGroupId = dataNode["ResourceGroupId"].asString();
+	if(!dataNode["DryRunResult"].isNull())
+		data_.dryRunResult = dataNode["DryRunResult"].asString() == "true";
 
 }
 

oceanbasepro/src/model/CreateTenantRequest.cc

@@ -52,6 +52,15 @@ void CreateTenantRequest::setMemory(int memory) {
   setBodyParameter(std::string("Memory"), std::to_string(memory));
 }
 
+long CreateTenantRequest::getLogDisk() const {
+  return logDisk_;
+}
+
+void CreateTenantRequest::setLogDisk(long logDisk) {
+  logDisk_ = logDisk;
+  setBodyParameter(std::string("LogDisk"), std::to_string(logDisk));
+}
+
 std::string CreateTenantRequest::getTimeZone() const {
   return timeZone_;
 }
@@ -133,3 +142,12 @@ void CreateTenantRequest::setTenantName(const std::string &tenantName) {
   setBodyParameter(std::string("TenantName"), tenantName);
 }
 
+std::string CreateTenantRequest::getReadOnlyZoneList() const {
+  return readOnlyZoneList_;
+}
+
+void CreateTenantRequest::setReadOnlyZoneList(const std::string &readOnlyZoneList) {
+  readOnlyZoneList_ = readOnlyZoneList;
+  setBodyParameter(std::string("ReadOnlyZoneList"), readOnlyZoneList);
+}
+

oceanbasepro/src/model/DeleteInstancesRequest.cc

@@ -34,6 +34,15 @@ void DeleteInstancesRequest::setBackupRetainMode(const std::string &backupRetain
   setBodyParameter(std::string("BackupRetainMode"), backupRetainMode);
 }
 
+bool DeleteInstancesRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void DeleteInstancesRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setBodyParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
 std::string DeleteInstancesRequest::getInstanceIds() const {
   return instanceIds_;
 }

oceanbasepro/src/model/DeleteInstancesResult.cc

@@ -39,6 +39,14 @@ void DeleteInstancesResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["DryRunResult"].isNull())
+		data_.dryRunResult = dataNode["DryRunResult"].asString() == "true";
 
 }
 
+DeleteInstancesResult::Data DeleteInstancesResult::getData()const
+{
+	return data_;
+}
+

oceanbasepro/src/model/DescribeAvailableMemResourceResult.cc

@@ -46,6 +46,8 @@ void DescribeAvailableMemResourceResult::parse(const std::string &payload)
 		data_.maxMem = std::stol(dataNode["MaxMem"].asString());
 	if(!dataNode["UsedMem"].isNull())
 		data_.usedMem = std::stol(dataNode["UsedMem"].asString());
+	if(!dataNode["SafeMem"].isNull())
+		data_.safeMem = dataNode["SafeMem"].asString();
 
 }
 

oceanbasepro/src/model/DescribeAvailableSpecRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/oceanbasepro/model/DescribeAvailableSpecRequest.h>
+
+using AlibabaCloud::OceanBasePro::Model::DescribeAvailableSpecRequest;
+
+DescribeAvailableSpecRequest::DescribeAvailableSpecRequest()
+    : RpcServiceRequest("oceanbasepro", "2019-09-01", "DescribeAvailableSpec") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeAvailableSpecRequest::~DescribeAvailableSpecRequest() {}
+
+std::string DescribeAvailableSpecRequest::getUpgradeType() const {
+  return upgradeType_;
+}
+
+void DescribeAvailableSpecRequest::setUpgradeType(const std::string &upgradeType) {
+  upgradeType_ = upgradeType;
+  setBodyParameter(std::string("UpgradeType"), upgradeType);
+}
+
+std::string DescribeAvailableSpecRequest::getSpec() const {
+  return spec_;
+}
+
+void DescribeAvailableSpecRequest::setSpec(const std::string &spec) {
+  spec_ = spec;
+  setBodyParameter(std::string("Spec"), spec);
+}
+
+std::string DescribeAvailableSpecRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void DescribeAvailableSpecRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setBodyParameter(std::string("InstanceId"), instanceId);
+}
+

oceanbasepro/src/model/DescribeAvailableSpecResult.cc

@@ -0,0 +1,77 @@
+/*
+ * 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/oceanbasepro/model/DescribeAvailableSpecResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::OceanBasePro;
+using namespace AlibabaCloud::OceanBasePro::Model;
+
+DescribeAvailableSpecResult::DescribeAvailableSpecResult() :
+	ServiceResult()
+{}
+
+DescribeAvailableSpecResult::DescribeAvailableSpecResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeAvailableSpecResult::~DescribeAvailableSpecResult()
+{}
+
+void DescribeAvailableSpecResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto allAvailableSpecificationsNode = dataNode["AvailableSpecifications"]["AvailableSpecificationsItem"];
+	for (auto dataNodeAvailableSpecificationsAvailableSpecificationsItem : allAvailableSpecificationsNode)
+	{
+		Data::AvailableSpecificationsItem availableSpecificationsItemObject;
+		if(!dataNodeAvailableSpecificationsAvailableSpecificationsItem["Spec"].isNull())
+			availableSpecificationsItemObject.spec = dataNodeAvailableSpecificationsAvailableSpecificationsItem["Spec"].asString();
+		if(!dataNodeAvailableSpecificationsAvailableSpecificationsItem["InstanceClass"].isNull())
+			availableSpecificationsItemObject.instanceClass = dataNodeAvailableSpecificationsAvailableSpecificationsItem["InstanceClass"].asString();
+		auto diskSizeRangeNode = value["DiskSizeRange"];
+		if(!diskSizeRangeNode["Step"].isNull())
+			availableSpecificationsItemObject.diskSizeRange.step = std::stol(diskSizeRangeNode["Step"].asString());
+		if(!diskSizeRangeNode["Max"].isNull())
+			availableSpecificationsItemObject.diskSizeRange.max = std::stol(diskSizeRangeNode["Max"].asString());
+		if(!diskSizeRangeNode["Min"].isNull())
+			availableSpecificationsItemObject.diskSizeRange.min = std::stol(diskSizeRangeNode["Min"].asString());
+		auto logDiskSizeRangeNode = value["LogDiskSizeRange"];
+		if(!logDiskSizeRangeNode["Step"].isNull())
+			availableSpecificationsItemObject.logDiskSizeRange.step = std::stol(logDiskSizeRangeNode["Step"].asString());
+		if(!logDiskSizeRangeNode["Max"].isNull())
+			availableSpecificationsItemObject.logDiskSizeRange.max = std::stol(logDiskSizeRangeNode["Max"].asString());
+		if(!logDiskSizeRangeNode["Min"].isNull())
+			availableSpecificationsItemObject.logDiskSizeRange.min = std::stol(logDiskSizeRangeNode["Min"].asString());
+		auto allNodeNum = value["NodeNum"]["NodeNum"];
+		for (auto value : allNodeNum)
+			availableSpecificationsItemObject.nodeNum.push_back(value.asString());
+		data_.availableSpecifications.push_back(availableSpecificationsItemObject);
+	}
+
+}
+
+DescribeAvailableSpecResult::Data DescribeAvailableSpecResult::getData()const
+{
+	return data_;
+}
+

oceanbasepro/src/model/DescribeAvailableZoneRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/oceanbasepro/model/DescribeAvailableZoneRequest.h>
+
+using AlibabaCloud::OceanBasePro::Model::DescribeAvailableZoneRequest;
+
+DescribeAvailableZoneRequest::DescribeAvailableZoneRequest()
+    : RpcServiceRequest("oceanbasepro", "2019-09-01", "DescribeAvailableZone") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeAvailableZoneRequest::~DescribeAvailableZoneRequest() {}
+
+std::string DescribeAvailableZoneRequest::getSpec() const {
+  return spec_;
+}
+
+void DescribeAvailableZoneRequest::setSpec(const std::string &spec) {
+  spec_ = spec;
+  setBodyParameter(std::string("Spec"), spec);
+}
+
+std::string DescribeAvailableZoneRequest::getObVersion() const {
+  return obVersion_;
+}
+
+void DescribeAvailableZoneRequest::setObVersion(const std::string &obVersion) {
+  obVersion_ = obVersion;
+  setBodyParameter(std::string("ObVersion"), obVersion);
+}
+
+std::string DescribeAvailableZoneRequest::getSeries() const {
+  return series_;
+}
+
+void DescribeAvailableZoneRequest::setSeries(const std::string &series) {
+  series_ = series;
+  setBodyParameter(std::string("Series"), series);
+}
+
+std::string DescribeAvailableZoneRequest::getInstanceType() const {
+  return instanceType_;
+}
+
+void DescribeAvailableZoneRequest::setInstanceType(const std::string &instanceType) {
+  instanceType_ = instanceType;
+  setBodyParameter(std::string("InstanceType"), instanceType);
+}
+
+std::string DescribeAvailableZoneRequest::getDeployType() const {
+  return deployType_;
+}
+
+void DescribeAvailableZoneRequest::setDeployType(const std::string &deployType) {
+  deployType_ = deployType;
+  setBodyParameter(std::string("DeployType"), deployType);
+}
+

oceanbasepro/src/model/DescribeAvailableZoneResult.cc

@@ -0,0 +1,101 @@
+/*
+ * 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/oceanbasepro/model/DescribeAvailableZoneResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::OceanBasePro;
+using namespace AlibabaCloud::OceanBasePro::Model;
+
+DescribeAvailableZoneResult::DescribeAvailableZoneResult() :
+	ServiceResult()
+{}
+
+DescribeAvailableZoneResult::DescribeAvailableZoneResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeAvailableZoneResult::~DescribeAvailableZoneResult()
+{}
+
+void DescribeAvailableZoneResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto allAvailableZonesNode = dataNode["AvailableZones"]["AvailableZonesItem"];
+	for (auto dataNodeAvailableZonesAvailableZonesItem : allAvailableZonesNode)
+	{
+		Data::AvailableZonesItem availableZonesItemObject;
+		if(!dataNodeAvailableZonesAvailableZonesItem["Region"].isNull())
+			availableZonesItemObject.region = dataNodeAvailableZonesAvailableZonesItem["Region"].asString();
+		if(!dataNodeAvailableZonesAvailableZonesItem["Zones"].isNull())
+			availableZonesItemObject.zones = dataNodeAvailableZonesAvailableZonesItem["Zones"].asString();
+		if(!dataNodeAvailableZonesAvailableZonesItem["Channel"].isNull())
+			availableZonesItemObject.channel = dataNodeAvailableZonesAvailableZonesItem["Channel"].asString();
+		if(!dataNodeAvailableZonesAvailableZonesItem["DeployType"].isNull())
+			availableZonesItemObject.deployType = dataNodeAvailableZonesAvailableZonesItem["DeployType"].asString();
+		if(!dataNodeAvailableZonesAvailableZonesItem["InstanceType"].isNull())
+			availableZonesItemObject.instanceType = dataNodeAvailableZonesAvailableZonesItem["InstanceType"].asString();
+		if(!dataNodeAvailableZonesAvailableZonesItem["Series"].isNull())
+			availableZonesItemObject.series = dataNodeAvailableZonesAvailableZonesItem["Series"].asString();
+		auto allSupportSpecificationsNode = dataNodeAvailableZonesAvailableZonesItem["SupportSpecifications"]["SupportSpecificationsItem"];
+		for (auto dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItem : allSupportSpecificationsNode)
+		{
+			Data::AvailableZonesItem::SupportSpecificationsItem supportSpecificationsObject;
+			if(!dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItem["Spec"].isNull())
+				supportSpecificationsObject.spec = dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItem["Spec"].asString();
+			if(!dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItem["InstanceClass"].isNull())
+				supportSpecificationsObject.instanceClass = dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItem["InstanceClass"].asString();
+			auto allSupportEngineVersionsNode = dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItem["SupportEngineVersions"]["SupportEngineVersionsItem"];
+			for (auto dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItemSupportEngineVersionsSupportEngineVersionsItem : allSupportEngineVersionsNode)
+			{
+				Data::AvailableZonesItem::SupportSpecificationsItem::SupportEngineVersionsItem supportEngineVersionsObject;
+				if(!dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItemSupportEngineVersionsSupportEngineVersionsItem["ObVersion"].isNull())
+					supportEngineVersionsObject.obVersion = dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItemSupportEngineVersionsSupportEngineVersionsItem["ObVersion"].asString();
+				if(!dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItemSupportEngineVersionsSupportEngineVersionsItem["SupportIsolationOptimization"].isNull())
+					supportEngineVersionsObject.supportIsolationOptimization = dataNodeAvailableZonesAvailableZonesItemSupportSpecificationsSupportSpecificationsItemSupportEngineVersionsSupportEngineVersionsItem["SupportIsolationOptimization"].asString() == "true";
+				auto allSupportReplicaModes = value["SupportReplicaModes"]["SupportReplicaModes"];
+				for (auto value : allSupportReplicaModes)
+					supportEngineVersionsObject.supportReplicaModes.push_back(value.asString());
+				supportSpecificationsObject.supportEngineVersions.push_back(supportEngineVersionsObject);
+			}
+			auto diskSizeRangeNode = value["DiskSizeRange"];
+			if(!diskSizeRangeNode["Step"].isNull())
+				supportSpecificationsObject.diskSizeRange.step = std::stol(diskSizeRangeNode["Step"].asString());
+			if(!diskSizeRangeNode["Max"].isNull())
+				supportSpecificationsObject.diskSizeRange.max = std::stol(diskSizeRangeNode["Max"].asString());
+			if(!diskSizeRangeNode["Min"].isNull())
+				supportSpecificationsObject.diskSizeRange.min = std::stol(diskSizeRangeNode["Min"].asString());
+			auto allDiskTypes = value["DiskTypes"]["DiskTypes"];
+			for (auto value : allDiskTypes)
+				supportSpecificationsObject.diskTypes.push_back(value.asString());
+			availableZonesItemObject.supportSpecifications.push_back(supportSpecificationsObject);
+		}
+		data_.availableZones.push_back(availableZonesItemObject);
+	}
+
+}
+
+DescribeAvailableZoneResult::Data DescribeAvailableZoneResult::getData()const
+{
+	return data_;
+}
+

oceanbasepro/src/model/DescribeDatabasesRequest.cc

@@ -43,6 +43,15 @@ void DescribeDatabasesRequest::setPageNumber(int pageNumber) {
   setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber));
 }
 
+std::string DescribeDatabasesRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void DescribeDatabasesRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setBodyParameter(std::string("InstanceId"), instanceId);
+}
+
 std::string DescribeDatabasesRequest::getDatabaseName() const {
   return databaseName_;
 }

oceanbasepro/src/model/DescribeDatabasesResult.cc

@@ -65,6 +65,8 @@ void DescribeDatabasesResult::parse(const std::string &payload)
 			databasesObject.collation = valueDatabasesData["Collation"].asString();
 		if(!valueDatabasesData["InstanceId"].isNull())
 			databasesObject.instanceId = valueDatabasesData["InstanceId"].asString();
+		if(!valueDatabasesData["TenantName"].isNull())
+			databasesObject.tenantName = valueDatabasesData["TenantName"].asString();
 		auto allUsersNode = valueDatabasesData["Users"]["UsersItem"];
 		for (auto valueDatabasesDataUsersUsersItem : allUsersNode)
 		{

oceanbasepro/src/model/DescribeInstanceResult.cc

@@ -94,6 +94,14 @@ void DescribeInstanceResult::parse(const std::string &payload)
 		instance_.inTempCapacityStatus = instanceNode["InTempCapacityStatus"].asString() == "true";
 	if(!instanceNode["DataDiskAutoScale"].isNull())
 		instance_.dataDiskAutoScale = instanceNode["DataDiskAutoScale"].asString() == "true";
+	if(!instanceNode["EnableProxyService"].isNull())
+		instance_.enableProxyService = instanceNode["EnableProxyService"].asString() == "true";
+	if(!instanceNode["ProxyServiceStatus"].isNull())
+		instance_.proxyServiceStatus = instanceNode["ProxyServiceStatus"].asString();
+	if(!instanceNode["ProxyClusterId"].isNull())
+		instance_.proxyClusterId = instanceNode["ProxyClusterId"].asString();
+	if(!instanceNode["CpuArchitecture"].isNull())
+		instance_.cpuArchitecture = instanceNode["CpuArchitecture"].asString();
 	auto resourceNode = instanceNode["Resource"];
 	if(!resourceNode["UnitCount"].isNull())
 		instance_.resource.unitCount = std::stol(resourceNode["UnitCount"].asString());
@@ -138,6 +146,13 @@ void DescribeInstanceResult::parse(const std::string &payload)
 		instance_.resource.logDiskSize.totalDiskSize = std::stol(logDiskSizeNode["TotalDiskSize"].asString());
 	if(!logDiskSizeNode["UnitDiskSize"].isNull())
 		instance_.resource.logDiskSize.unitDiskSize = std::stol(logDiskSizeNode["UnitDiskSize"].asString());
+	if(!logDiskSizeNode["LogAssignedSize"].isNull())
+		instance_.resource.logDiskSize.logAssignedSize = logDiskSizeNode["LogAssignedSize"].asString();
+	if(!logDiskSizeNode["MaxLogAssignedPercent"].isNull())
+		instance_.resource.logDiskSize.maxLogAssignedPercent = logDiskSizeNode["MaxLogAssignedPercent"].asString();
+		auto allMaxLogAssignedObServer = logDiskSizeNode["MaxLogAssignedObServer"]["MaxLogAssignedObServer"];
+		for (auto value : allMaxLogAssignedObServer)
+			instance_.resource.logDiskSize.maxLogAssignedObServer.push_back(value.asString());
 	auto capacityUnitNode = resourceNode["CapacityUnit"];
 	if(!capacityUnitNode["MaxCapacityUnit"].isNull())
 		instance_.resource.capacityUnit.maxCapacityUnit = std::stoi(capacityUnitNode["MaxCapacityUnit"].asString());

oceanbasepro/src/model/DescribeInstanceSecurityConfigsRequest.cc

@@ -34,3 +34,12 @@ void DescribeInstanceSecurityConfigsRequest::setInstanceId(const std::string &in
   setBodyParameter(std::string("InstanceId"), instanceId);
 }
 
+std::string DescribeInstanceSecurityConfigsRequest::getCheckId() const {
+  return checkId_;
+}
+
+void DescribeInstanceSecurityConfigsRequest::setCheckId(const std::string &checkId) {
+  checkId_ = checkId;
+  setBodyParameter(std::string("CheckId"), checkId);
+}
+

oceanbasepro/src/model/DescribeInstanceSecurityConfigsResult.cc

@@ -44,6 +44,12 @@ void DescribeInstanceSecurityConfigsResult::parse(const std::string &payload)
 		instanceSecurityConfigs_.totalCheckCount = std::stoi(instanceSecurityConfigsNode["TotalCheckCount"].asString());
 	if(!instanceSecurityConfigsNode["TotalRiskCount"].isNull())
 		instanceSecurityConfigs_.totalRiskCount = std::stoi(instanceSecurityConfigsNode["TotalRiskCount"].asString());
+	if(!instanceSecurityConfigsNode["CheckTime"].isNull())
+		instanceSecurityConfigs_.checkTime = instanceSecurityConfigsNode["CheckTime"].asString();
+	if(!instanceSecurityConfigsNode["InstanceId"].isNull())
+		instanceSecurityConfigs_.instanceId = instanceSecurityConfigsNode["InstanceId"].asString();
+	if(!instanceSecurityConfigsNode["CheckId"].isNull())
+		instanceSecurityConfigs_.checkId = instanceSecurityConfigsNode["CheckId"].asString();
 	auto allSecurityConfigsNode = instanceSecurityConfigsNode["SecurityConfigs"]["SecurityConfigsItem"];
 	for (auto instanceSecurityConfigsNodeSecurityConfigsSecurityConfigsItem : allSecurityConfigsNode)
 	{

oceanbasepro/src/model/DescribeInstancesResult.cc

@@ -57,6 +57,8 @@ void DescribeInstancesResult::parse(const std::string &payload)
 			instancesObject.createTime = valueInstancesData["CreateTime"].asString();
 		if(!valueInstancesData["DeployMode"].isNull())
 			instancesObject.deployMode = valueInstancesData["DeployMode"].asString();
+		if(!valueInstancesData["CpuArchitecture"].isNull())
+			instancesObject.cpuArchitecture = valueInstancesData["CpuArchitecture"].asString();
 		if(!valueInstancesData["MaintainTime"].isNull())
 			instancesObject.maintainTime = valueInstancesData["MaintainTime"].asString();
 		if(!valueInstancesData["DeployType"].isNull())

oceanbasepro/src/model/DescribeSQLSamplesResult.cc

@@ -84,9 +84,9 @@ void DescribeSQLSamplesResult::parse(const std::string &payload)
 		if(!valueDataDataItem["Inner"].isNull())
 			dataObject.inner = valueDataDataItem["Inner"].asString() == "true";
 		if(!valueDataDataItem["ExecutorRpc"].isNull())
-			dataObject.executorRpc = valueDataDataItem["ExecutorRpc"].asString();
+			dataObject.executorRpc = valueDataDataItem["ExecutorRpc"].asString() == "true";
 		if(!valueDataDataItem["HitPlan"].isNull())
-			dataObject.hitPlan = valueDataDataItem["HitPlan"].asString();
+			dataObject.hitPlan = valueDataDataItem["HitPlan"].asString() == "true";
 		if(!valueDataDataItem["ElapsedTime"].isNull())
 			dataObject.elapsedTime = valueDataDataItem["ElapsedTime"].asString();
 		if(!valueDataDataItem["CpuTime"].isNull())
@@ -124,7 +124,7 @@ void DescribeSQLSamplesResult::parse(const std::string &payload)
 		if(!valueDataDataItem["RetryCount"].isNull())
 			dataObject.retryCount = valueDataDataItem["RetryCount"].asString();
 		if(!valueDataDataItem["TableScan"].isNull())
-			dataObject.tableScan = valueDataDataItem["TableScan"].asString();
+			dataObject.tableScan = valueDataDataItem["TableScan"].asString() == "true";
 		if(!valueDataDataItem["ConsistencyLevel"].isNull())
 			dataObject.consistencyLevel = valueDataDataItem["ConsistencyLevel"].asString();
 		if(!valueDataDataItem["MemstoreReadRows"].isNull())
@@ -145,6 +145,8 @@ void DescribeSQLSamplesResult::parse(const std::string &payload)
 			dataObject.statement = valueDataDataItem["Statement"].asString();
 		if(!valueDataDataItem["TransHash"].isNull())
 			dataObject.transHash = valueDataDataItem["TransHash"].asString();
+		if(!valueDataDataItem["FullSqlText"].isNull())
+			dataObject.fullSqlText = valueDataDataItem["FullSqlText"].asString();
 		data_.push_back(dataObject);
 	}
 

oceanbasepro/src/model/DescribeTenantEncryptionRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/oceanbasepro/model/DescribeTenantEncryptionRequest.h>
+
+using AlibabaCloud::OceanBasePro::Model::DescribeTenantEncryptionRequest;
+
+DescribeTenantEncryptionRequest::DescribeTenantEncryptionRequest()
+    : RpcServiceRequest("oceanbasepro", "2019-09-01", "DescribeTenantEncryption") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeTenantEncryptionRequest::~DescribeTenantEncryptionRequest() {}
+
+long DescribeTenantEncryptionRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeTenantEncryptionRequest::setPageNumber(long pageNumber) {
+  pageNumber_ = pageNumber;
+  setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string DescribeTenantEncryptionRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void DescribeTenantEncryptionRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setBodyParameter(std::string("InstanceId"), instanceId);
+}
+
+std::string DescribeTenantEncryptionRequest::getTenantId() const {
+  return tenantId_;
+}
+
+void DescribeTenantEncryptionRequest::setTenantId(const std::string &tenantId) {
+  tenantId_ = tenantId;
+  setBodyParameter(std::string("TenantId"), tenantId);
+}
+
+long DescribeTenantEncryptionRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeTenantEncryptionRequest::setPageSize(long pageSize) {
+  pageSize_ = pageSize;
+  setBodyParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string DescribeTenantEncryptionRequest::getTenantName() const {
+  return tenantName_;
+}
+
+void DescribeTenantEncryptionRequest::setTenantName(const std::string &tenantName) {
+  tenantName_ = tenantName;
+  setBodyParameter(std::string("TenantName"), tenantName);
+}
+

oceanbasepro/src/model/DescribeTenantEncryptionResult.cc

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/oceanbasepro/model/DescribeTenantEncryptionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::OceanBasePro;
+using namespace AlibabaCloud::OceanBasePro::Model;
+
+DescribeTenantEncryptionResult::DescribeTenantEncryptionResult() :
+	ServiceResult()
+{}
+
+DescribeTenantEncryptionResult::DescribeTenantEncryptionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeTenantEncryptionResult::~DescribeTenantEncryptionResult()
+{}
+
+void DescribeTenantEncryptionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTenantEncryptionsNode = value["TenantEncryptions"]["TenantEncryptionsItem"];
+	for (auto valueTenantEncryptionsTenantEncryptionsItem : allTenantEncryptionsNode)
+	{
+		TenantEncryptionsItem tenantEncryptionsObject;
+		if(!valueTenantEncryptionsTenantEncryptionsItem["TenantId"].isNull())
+			tenantEncryptionsObject.tenantId = valueTenantEncryptionsTenantEncryptionsItem["TenantId"].asString();
+		if(!valueTenantEncryptionsTenantEncryptionsItem["TenantMode"].isNull())
+			tenantEncryptionsObject.tenantMode = valueTenantEncryptionsTenantEncryptionsItem["TenantMode"].asString();
+		if(!valueTenantEncryptionsTenantEncryptionsItem["TenantName"].isNull())
+			tenantEncryptionsObject.tenantName = valueTenantEncryptionsTenantEncryptionsItem["TenantName"].asString();
+		if(!valueTenantEncryptionsTenantEncryptionsItem["EnableEncryption"].isNull())
+			tenantEncryptionsObject.enableEncryption = valueTenantEncryptionsTenantEncryptionsItem["EnableEncryption"].asString() == "true";
+		if(!valueTenantEncryptionsTenantEncryptionsItem["TenantStatus"].isNull())
+			tenantEncryptionsObject.tenantStatus = valueTenantEncryptionsTenantEncryptionsItem["TenantStatus"].asString();
+		if(!valueTenantEncryptionsTenantEncryptionsItem["Status"].isNull())
+			tenantEncryptionsObject.status = valueTenantEncryptionsTenantEncryptionsItem["Status"].asString();
+		if(!valueTenantEncryptionsTenantEncryptionsItem["EncryptionType"].isNull())
+			tenantEncryptionsObject.encryptionType = valueTenantEncryptionsTenantEncryptionsItem["EncryptionType"].asString();
+		if(!valueTenantEncryptionsTenantEncryptionsItem["EncryptionKeyId"].isNull())
+			tenantEncryptionsObject.encryptionKeyId = valueTenantEncryptionsTenantEncryptionsItem["EncryptionKeyId"].asString();
+		tenantEncryptions_.push_back(tenantEncryptionsObject);
+	}
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+int DescribeTenantEncryptionResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::vector<DescribeTenantEncryptionResult::TenantEncryptionsItem> DescribeTenantEncryptionResult::getTenantEncryptions()const
+{
+	return tenantEncryptions_;
+}
+

oceanbasepro/src/model/DescribeTenantResult.cc

@@ -126,6 +126,8 @@ void DescribeTenantResult::parse(const std::string &payload)
 			tenantConnectionsItemObject.parallelQueryDegree = std::stol(tenantNodeTenantConnectionsTenantConnectionsItem["ParallelQueryDegree"].asString());
 		if(!tenantNodeTenantConnectionsTenantConnectionsItem["TenantEndpointId"].isNull())
 			tenantConnectionsItemObject.tenantEndpointId = tenantNodeTenantConnectionsTenantConnectionsItem["TenantEndpointId"].asString();
+		if(!tenantNodeTenantConnectionsTenantConnectionsItem["MaxConnectionNum"].isNull())
+			tenantConnectionsItemObject.maxConnectionNum = std::stol(tenantNodeTenantConnectionsTenantConnectionsItem["MaxConnectionNum"].asString());
 		auto allConnectionZones = value["ConnectionZones"]["ConnectionZones"];
 		for (auto value : allConnectionZones)
 			tenantConnectionsItemObject.connectionZones.push_back(value.asString());
@@ -170,6 +172,11 @@ void DescribeTenantResult::parse(const std::string &payload)
 		tenant_.tenantResource.capacityUnit.minCapacityUnit = std::stoi(capacityUnitNode["MinCapacityUnit"].asString());
 	if(!capacityUnitNode["UsedCapacit"].isNull())
 		tenant_.tenantResource.capacityUnit.usedCapacit = std::stoi(capacityUnitNode["UsedCapacit"].asString());
+	auto logDiskSizeNode = tenantResourceNode["LogDiskSize"];
+	if(!logDiskSizeNode["TotalLogDisk"].isNull())
+		tenant_.tenantResource.logDiskSize.totalLogDisk = std::stoi(logDiskSizeNode["TotalLogDisk"].asString());
+	if(!logDiskSizeNode["UnitLogDisk"].isNull())
+		tenant_.tenantResource.logDiskSize.unitLogDisk = std::stoi(logDiskSizeNode["UnitLogDisk"].asString());
 		auto allAvailableZones = tenantNode["AvailableZones"]["AvailableZones"];
 		for (auto value : allAvailableZones)
 			tenant_.availableZones.push_back(value.asString());

oceanbasepro/src/model/DescribeTenantSecurityConfigsRequest.cc

@@ -43,3 +43,12 @@ void DescribeTenantSecurityConfigsRequest::setTenantId(const std::string &tenant
   setBodyParameter(std::string("TenantId"), tenantId);
 }
 
+std::string DescribeTenantSecurityConfigsRequest::getCheckId() const {
+  return checkId_;
+}
+
+void DescribeTenantSecurityConfigsRequest::setCheckId(const std::string &checkId) {
+  checkId_ = checkId;
+  setBodyParameter(std::string("CheckId"), checkId);
+}
+

oceanbasepro/src/model/DescribeTenantSecurityConfigsResult.cc

@@ -44,6 +44,12 @@ void DescribeTenantSecurityConfigsResult::parse(const std::string &payload)
 		configs_.totalCheckCount = std::stoi(configsNode["TotalCheckCount"].asString());
 	if(!configsNode["TotalRiskCount"].isNull())
 		configs_.totalRiskCount = std::stoi(configsNode["TotalRiskCount"].asString());
+	if(!configsNode["CheckId"].isNull())
+		configs_.checkId = configsNode["CheckId"].asString();
+	if(!configsNode["InstanceId"].isNull())
+		configs_.instanceId = configsNode["InstanceId"].asString();
+	if(!configsNode["CheckTime"].isNull())
+		configs_.checkTime = configsNode["CheckTime"].asString();
 	auto allTenantSecurityConfigsNode = configsNode["TenantSecurityConfigs"]["TenantSecurityConfigsItem"];
 	for (auto configsNodeTenantSecurityConfigsTenantSecurityConfigsItem : allTenantSecurityConfigsNode)
 	{

oceanbasepro/src/model/ModifyInstanceNodeNumRequest.cc

@@ -25,6 +25,15 @@ ModifyInstanceNodeNumRequest::ModifyInstanceNodeNumRequest()
 
 ModifyInstanceNodeNumRequest::~ModifyInstanceNodeNumRequest() {}
 
+bool ModifyInstanceNodeNumRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void ModifyInstanceNodeNumRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setBodyParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
 std::string ModifyInstanceNodeNumRequest::getNodeNum() const {
   return nodeNum_;
 }

oceanbasepro/src/model/ModifyInstanceNodeNumResult.cc

@@ -42,6 +42,8 @@ void ModifyInstanceNodeNumResult::parse(const std::string &payload)
 	auto dataNode = value["Data"];
 	if(!dataNode["OrderId"].isNull())
 		data_.orderId = dataNode["OrderId"].asString();
+	if(!dataNode["DryRunResult"].isNull())
+		data_.dryRunResult = dataNode["DryRunResult"].asString() == "true";
 
 }
 

oceanbasepro/src/model/ModifyInstanceSpecRequest.cc

@@ -43,6 +43,15 @@ void ModifyInstanceSpecRequest::setInstanceClass(const std::string &instanceClas
   setBodyParameter(std::string("InstanceClass"), instanceClass);
 }
 
+bool ModifyInstanceSpecRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void ModifyInstanceSpecRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setBodyParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
 long ModifyInstanceSpecRequest::getDiskSize() const {
   return diskSize_;
 }

oceanbasepro/src/model/ModifyInstanceSpecResult.cc

@@ -42,6 +42,8 @@ void ModifyInstanceSpecResult::parse(const std::string &payload)
 	auto dataNode = value["Data"];
 	if(!dataNode["OrderId"].isNull())
 		data_.orderId = dataNode["OrderId"].asString();
+	if(!dataNode["DryRunResult"].isNull())
+		data_.dryRunResult = dataNode["DryRunResult"].asString() == "true";
 
 }
 

oceanbasepro/src/model/ModifyInstanceTemporaryCapacityRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/oceanbasepro/model/ModifyInstanceTemporaryCapacityRequest.h>
+
+using AlibabaCloud::OceanBasePro::Model::ModifyInstanceTemporaryCapacityRequest;
+
+ModifyInstanceTemporaryCapacityRequest::ModifyInstanceTemporaryCapacityRequest()
+    : RpcServiceRequest("oceanbasepro", "2019-09-01", "ModifyInstanceTemporaryCapacity") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ModifyInstanceTemporaryCapacityRequest::~ModifyInstanceTemporaryCapacityRequest() {}
+
+std::string ModifyInstanceTemporaryCapacityRequest::getDiskSize() const {
+  return diskSize_;
+}
+
+void ModifyInstanceTemporaryCapacityRequest::setDiskSize(const std::string &diskSize) {
+  diskSize_ = diskSize;
+  setBodyParameter(std::string("DiskSize"), diskSize);
+}
+
+std::string ModifyInstanceTemporaryCapacityRequest::getSpec() const {
+  return spec_;
+}
+
+void ModifyInstanceTemporaryCapacityRequest::setSpec(const std::string &spec) {
+  spec_ = spec;
+  setBodyParameter(std::string("Spec"), spec);
+}
+
+std::string ModifyInstanceTemporaryCapacityRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void ModifyInstanceTemporaryCapacityRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setBodyParameter(std::string("InstanceId"), instanceId);
+}
+

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

oceanbasepro/src/model/ModifyTenantResourceRequest.cc

@@ -34,6 +34,15 @@ void ModifyTenantResourceRequest::setMemory(int memory) {
   setBodyParameter(std::string("Memory"), std::to_string(memory));
 }
 
+long ModifyTenantResourceRequest::getLogDisk() const {
+  return logDisk_;
+}
+
+void ModifyTenantResourceRequest::setLogDisk(long logDisk) {
+  logDisk_ = logDisk;
+  setBodyParameter(std::string("LogDisk"), std::to_string(logDisk));
+}
+
 int ModifyTenantResourceRequest::getCpu() const {
   return cpu_;
 }
@@ -61,3 +70,12 @@ void ModifyTenantResourceRequest::setTenantId(const std::string &tenantId) {
   setBodyParameter(std::string("TenantId"), tenantId);
 }
 
+std::string ModifyTenantResourceRequest::getReadOnlyZoneList() const {
+  return readOnlyZoneList_;
+}
+
+void ModifyTenantResourceRequest::setReadOnlyZoneList(const std::string &readOnlyZoneList) {
+  readOnlyZoneList_ = readOnlyZoneList;
+  setBodyParameter(std::string("ReadOnlyZoneList"), readOnlyZoneList);
+}
+