Generated 2019-09-01 for OceanBasePro.

VERSION

@@ -1 +1 @@
-1.36.1838
+1.36.1839

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

@@ -60,6 +60,10 @@ public:
 	void setAutoRenew(bool autoRenew);
 	std::string getSeries() const;
 	void setSeries(const std::string &series);
+	std::string getPrimaryInstance() const;
+	void setPrimaryInstance(const std::string &primaryInstance);
+	std::string getPrimaryRegion() const;
+	void setPrimaryRegion(const std::string &primaryRegion);
 	std::string getChargeType() const;
 	void setChargeType(const std::string &chargeType);
 	std::string getBid() const;
@@ -81,6 +85,8 @@ private:
 	std::string replicaMode_;
 	bool autoRenew_;
 	std::string series_;
+	std::string primaryInstance_;
+	std::string primaryRegion_;
 	std::string chargeType_;
 	std::string bid_;
 };

oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantUserResult.h

@@ -32,7 +32,7 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_OCEANBASEPRO_EXPORT CreateTenantUserResult : public ServiceResult
 			{
 			public:
-				struct Data
+				struct TenantUser
 				{
 					struct RolesItem
 					{
@@ -40,7 +40,7 @@ namespace AlibabaCloud
 						std::string database;
 					};
 					std::string userName;
-					std::vector<Data::RolesItem> roles;
+					std::vector<RolesItem> roles;
 					std::string userType;
 					std::string userStatus;
 				};
@@ -49,12 +49,12 @@ namespace AlibabaCloud
 				CreateTenantUserResult();
 				explicit CreateTenantUserResult(const std::string &payload);
 				~CreateTenantUserResult();
-				std::vector<Data> getTenantUser()const;
+				TenantUser getTenantUser()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::vector<Data> tenantUser_;
+				TenantUser tenantUser_;
 
 			};
 		}

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeAvailableSpecResult.h

@@ -50,6 +50,7 @@ namespace AlibabaCloud
 						};
 						std::vector<std::string> nodeNum;
 						DiskSizeRange diskSizeRange;
+						std::vector<std::string> diskTypes;
 						std::string instanceClass;
 						std::string spec;
 						LogDiskSizeRange logDiskSizeRange;

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

@@ -65,6 +65,7 @@ namespace AlibabaCloud
 						{
 							std::string maxLogAssignedPercent;
 							std::string logAssignedSize;
+							int originalTotalDiskSize;
 							std::vector<std::string> maxLogAssignedObServer;
 							long unitDiskSize;
 							long totalDiskSize;
@@ -97,8 +98,57 @@ namespace AlibabaCloud
 						long upperThreshold;
 						bool autoScale;
 					};
+					struct ReadOnlyResource
+					{
+						struct Cpu1
+						{
+							long unitCpu;
+							long totalCpu;
+							long usedCpu;
+							long originalTotalCpu;
+						};
+						struct Memory2
+						{
+							long usedMemory;
+							long unitMemory;
+							long totalMemory;
+							long originalTotalMemory;
+						};
+						struct DiskSize3
+						{
+							double dataUsedSize;
+							long originalTotalDiskSize;
+							long usedDiskSize;
+							double maxDiskUsedPercent;
+							double maxDiskSize;
+							long unitDiskSize;
+							long totalDiskSize;
+							std::vector<std::string> maxDiskUsedObServer6;
+						};
+						struct LogDiskSize4
+						{
+							std::string maxLogAssignedPercent;
+							std::string logAssignedSize;
+							long unitDiskSize;
+							long totalDiskSize;
+							std::vector<std::string> maxLogAssignedObServer7;
+						};
+						struct CapacityUnit5
+						{
+							std::string usedCapacityUnit;
+							int maxCapacityUnit;
+							int minCapacityUnit;
+						};
+						LogDiskSize4 logDiskSize4;
+						long unitCount;
+						Cpu1 cpu1;
+						DiskSize3 diskSize3;
+						CapacityUnit5 capacityUnit5;
+						Memory2 memory2;
+					};
 					std::string deployType;
 					std::string proxyServiceStatus;
+					ReadOnlyResource readOnlyResource;
 					std::string nodeNum;
 					bool enableIsolationOptimization;
 					std::string dataMergeTime;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceTopologyResult.h

@@ -44,6 +44,7 @@ namespace AlibabaCloud
 								long unitDataSize;
 								std::string unitId;
 								float unitMemory;
+								std::string replicaType;
 								bool enableMigrateUnit;
 								bool enableCancelMigrateUnit;
 								std::string nodeId;
@@ -101,8 +102,11 @@ namespace AlibabaCloud
 								Cpu cpu;
 							};
 							std::vector<NodesItem::NodeResourceItem> nodeResource;
+							std::string replicaType;
 							std::string nodeId;
+							long readOnlyCopyId;
 							std::string nodeStatus;
+							long fullCopyId;
 							long nodeCopyId;
 						};
 						std::string zoneId;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeMetricsDataRequest.h

@@ -40,6 +40,8 @@ public:
 	void setSortOrder(const std::string &sortOrder);
 	std::string getSortMetricKey() const;
 	void setSortMetricKey(const std::string &sortMetricKey);
+	std::string getReplicaType() const;
+	void setReplicaType(const std::string &replicaType);
 	std::string getEndTime() const;
 	void setEndTime(const std::string &endTime);
 	std::string getLabels() const;
@@ -55,6 +57,7 @@ private:
 	std::string limit_;
 	std::string sortOrder_;
 	std::string sortMetricKey_;
+	std::string replicaType_;
 	std::string endTime_;
 	std::string labels_;
 	std::string instanceId_;

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

@@ -70,11 +70,48 @@ namespace AlibabaCloud
 						Cpu cpu;
 						LogDiskSize logDiskSize;
 					};
+					struct ReadOnlyResource
+					{
+						struct Cpu1
+						{
+							float unitCpu;
+							float totalCpu;
+							float usedCpu;
+						};
+						struct Memory2
+						{
+							float usedMemory;
+							float unitMemory;
+							float totalMemory;
+						};
+						struct DiskSize3
+						{
+							float usedDiskSize;
+						};
+						struct CapacityUnit4
+						{
+							int usedCapacit;
+							int maxCapacityUnit;
+							int minCapacityUnit;
+						};
+						struct LogDiskSize5
+						{
+							int totalLogDisk;
+							int unitLogDisk;
+						};
+						LogDiskSize5 logDiskSize5;
+						int unitNum;
+						Cpu1 cpu1;
+						DiskSize3 diskSize3;
+						CapacityUnit4 capacityUnit4;
+						Memory2 memory2;
+					};
 					struct TenantConnectionsItem
 					{
 						std::string intranetAddressStatus;
 						std::vector<std::string> connectionZones;
 						std::string internetAddress;
+						std::string connectionReplicaType;
 						std::string intranetAddressSlaveZoneId;
 						std::string internetAddressStatus;
 						long maxConnectionNum;
@@ -92,13 +129,25 @@ namespace AlibabaCloud
 					};
 					struct TenantZonesItem
 					{
+						struct TenantZoneReplicasItem
+						{
+							std::string zoneNodes;
+							int zoneCopyId;
+							std::string logicZoneName;
+							std::string readOnlyCopyId;
+							std::string zoneReplicaType;
+							int fullCopyId;
+						};
 						std::string tenantZoneRole;
+						std::vector<TenantZonesItem::TenantZoneReplicasItem> tenantZoneReplicas;
 						std::string tenantZoneId;
 						std::string region;
 					};
 					std::string deployType;
+					ReadOnlyResource readOnlyResource;
 					std::string description;
 					long maxParallelQueryDegree;
+					std::string dataMergeTime;
 					std::string masterIntranetAddressZone;
 					std::vector<std::string> availableZones;
 					std::string diskType;

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

@@ -38,6 +38,8 @@ public:
 	void setDryRun(bool dryRun);
 	long getDiskSize() const;
 	void setDiskSize(long diskSize);
+	std::string getDiskType() const;
+	void setDiskType(const std::string &diskType);
 	std::string getInstanceId() const;
 	void setInstanceId(const std::string &instanceId);
 	long getLogDiskSize() const;
@@ -48,6 +50,7 @@ private:
 	std::string instanceClass_;
 	bool dryRun_;
 	long diskSize_;
+	std::string diskType_;
 	std::string instanceId_;
 	long logDiskSize_;
 };

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

@@ -36,11 +36,14 @@ public:
 	void setSpec(const std::string &spec);
 	std::string getInstanceId() const;
 	void setInstanceId(const std::string &instanceId);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
 
 private:
 	std::string diskSize_;
 	std::string spec_;
 	std::string instanceId_;
+	std::string acceptLanguage_;
 };
 } // namespace Model
 } // namespace OceanBasePro

oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyTenantPrimaryZoneRequest.h

@@ -30,6 +30,8 @@ class ALIBABACLOUD_OCEANBASEPRO_EXPORT ModifyTenantPrimaryZoneRequest : public R
 public:
 	ModifyTenantPrimaryZoneRequest();
 	~ModifyTenantPrimaryZoneRequest();
+	std::string getTenantEndpointDirectId() const;
+	void setTenantEndpointDirectId(const std::string &tenantEndpointDirectId);
 	std::string getUserVSwitchId() const;
 	void setUserVSwitchId(const std::string &userVSwitchId);
 	std::string getMasterIntranetAddressZone() const;
@@ -42,14 +44,18 @@ public:
 	void setInstanceId(const std::string &instanceId);
 	std::string getPrimaryZone() const;
 	void setPrimaryZone(const std::string &primaryZone);
+	std::string getUserDirectVSwitchId() const;
+	void setUserDirectVSwitchId(const std::string &userDirectVSwitchId);
 
 private:
+	std::string tenantEndpointDirectId_;
 	std::string userVSwitchId_;
 	std::string masterIntranetAddressZone_;
 	std::string tenantId_;
 	std::string tenantEndpointId_;
 	std::string instanceId_;
 	std::string primaryZone_;
+	std::string userDirectVSwitchId_;
 };
 } // namespace Model
 } // namespace OceanBasePro

oceanbasepro/src/model/CreateInstanceRequest.cc

@@ -160,6 +160,24 @@ void CreateInstanceRequest::setSeries(const std::string &series) {
   setBodyParameter(std::string("Series"), series);
 }
 
+std::string CreateInstanceRequest::getPrimaryInstance() const {
+  return primaryInstance_;
+}
+
+void CreateInstanceRequest::setPrimaryInstance(const std::string &primaryInstance) {
+  primaryInstance_ = primaryInstance;
+  setBodyParameter(std::string("PrimaryInstance"), primaryInstance);
+}
+
+std::string CreateInstanceRequest::getPrimaryRegion() const {
+  return primaryRegion_;
+}
+
+void CreateInstanceRequest::setPrimaryRegion(const std::string &primaryRegion) {
+  primaryRegion_ = primaryRegion;
+  setBodyParameter(std::string("PrimaryRegion"), primaryRegion);
+}
+
 std::string CreateInstanceRequest::getChargeType() const {
   return chargeType_;
 }

oceanbasepro/src/model/CreateTenantUserResult.cc

@@ -39,32 +39,27 @@ void CreateTenantUserResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	auto allTenantUserNode = value["TenantUser"]["Data"];
-	for (auto valueTenantUserData : allTenantUserNode)
+	auto tenantUserNode = value["TenantUser"];
+	if(!tenantUserNode["UserType"].isNull())
+		tenantUser_.userType = tenantUserNode["UserType"].asString();
+	if(!tenantUserNode["UserStatus"].isNull())
+		tenantUser_.userStatus = tenantUserNode["UserStatus"].asString();
+	if(!tenantUserNode["UserName"].isNull())
+		tenantUser_.userName = tenantUserNode["UserName"].asString();
+	auto allRolesNode = tenantUserNode["Roles"]["RolesItem"];
+	for (auto tenantUserNodeRolesRolesItem : allRolesNode)
 	{
-		Data tenantUserObject;
-		if(!valueTenantUserData["UserType"].isNull())
-			tenantUserObject.userType = valueTenantUserData["UserType"].asString();
-		if(!valueTenantUserData["UserStatus"].isNull())
-			tenantUserObject.userStatus = valueTenantUserData["UserStatus"].asString();
-		if(!valueTenantUserData["UserName"].isNull())
-			tenantUserObject.userName = valueTenantUserData["UserName"].asString();
-		auto allRolesNode = valueTenantUserData["Roles"]["RolesItem"];
-		for (auto valueTenantUserDataRolesRolesItem : allRolesNode)
-		{
-			Data::RolesItem rolesObject;
-			if(!valueTenantUserDataRolesRolesItem["Database"].isNull())
-				rolesObject.database = valueTenantUserDataRolesRolesItem["Database"].asString();
-			if(!valueTenantUserDataRolesRolesItem["Role"].isNull())
-				rolesObject.role = valueTenantUserDataRolesRolesItem["Role"].asString();
-			tenantUserObject.roles.push_back(rolesObject);
-		}
-		tenantUser_.push_back(tenantUserObject);
+		TenantUser::RolesItem rolesItemObject;
+		if(!tenantUserNodeRolesRolesItem["Database"].isNull())
+			rolesItemObject.database = tenantUserNodeRolesRolesItem["Database"].asString();
+		if(!tenantUserNodeRolesRolesItem["Role"].isNull())
+			rolesItemObject.role = tenantUserNodeRolesRolesItem["Role"].asString();
+		tenantUser_.roles.push_back(rolesItemObject);
 	}
 
 }
 
-std::vector<CreateTenantUserResult::Data> CreateTenantUserResult::getTenantUser()const
+CreateTenantUserResult::TenantUser CreateTenantUserResult::getTenantUser()const
 {
 	return tenantUser_;
 }

oceanbasepro/src/model/DescribeAvailableSpecResult.cc

@@ -65,6 +65,9 @@ void DescribeAvailableSpecResult::parse(const std::string &payload)
 		auto allNodeNum = value["NodeNum"]["NodeNum"];
 		for (auto value : allNodeNum)
 			availableSpecificationsItemObject.nodeNum.push_back(value.asString());
+		auto allDiskTypes = value["DiskTypes"]["DiskTypes"];
+		for (auto value : allDiskTypes)
+			availableSpecificationsItemObject.diskTypes.push_back(value.asString());
 		data_.availableSpecifications.push_back(availableSpecificationsItemObject);
 	}
 

oceanbasepro/src/model/DescribeInstanceResult.cc

@@ -150,6 +150,8 @@ void DescribeInstanceResult::parse(const std::string &payload)
 		instance_.resource.logDiskSize.logAssignedSize = logDiskSizeNode["LogAssignedSize"].asString();
 	if(!logDiskSizeNode["MaxLogAssignedPercent"].isNull())
 		instance_.resource.logDiskSize.maxLogAssignedPercent = logDiskSizeNode["MaxLogAssignedPercent"].asString();
+	if(!logDiskSizeNode["OriginalTotalDiskSize"].isNull())
+		instance_.resource.logDiskSize.originalTotalDiskSize = std::stoi(logDiskSizeNode["OriginalTotalDiskSize"].asString());
 		auto allMaxLogAssignedObServer = logDiskSizeNode["MaxLogAssignedObServer"]["MaxLogAssignedObServer"];
 		for (auto value : allMaxLogAssignedObServer)
 			instance_.resource.logDiskSize.maxLogAssignedObServer.push_back(value.asString());
@@ -180,6 +182,64 @@ void DescribeInstanceResult::parse(const std::string &payload)
 		instance_.dataDiskAutoScaleConfig.scaleStepInNormal = std::stol(dataDiskAutoScaleConfigNode["ScaleStepInNormal"].asString());
 	if(!dataDiskAutoScaleConfigNode["ScaleStepInMerge"].isNull())
 		instance_.dataDiskAutoScaleConfig.scaleStepInMerge = std::stol(dataDiskAutoScaleConfigNode["ScaleStepInMerge"].asString());
+	auto readOnlyResourceNode = instanceNode["ReadOnlyResource"];
+	if(!readOnlyResourceNode["UnitCount"].isNull())
+		instance_.readOnlyResource.unitCount = std::stol(readOnlyResourceNode["UnitCount"].asString());
+	auto cpu1Node = readOnlyResourceNode["Cpu"];
+	if(!cpu1Node["TotalCpu"].isNull())
+		instance_.readOnlyResource.cpu1.totalCpu = std::stol(cpu1Node["TotalCpu"].asString());
+	if(!cpu1Node["UsedCpu"].isNull())
+		instance_.readOnlyResource.cpu1.usedCpu = std::stol(cpu1Node["UsedCpu"].asString());
+	if(!cpu1Node["UnitCpu"].isNull())
+		instance_.readOnlyResource.cpu1.unitCpu = std::stol(cpu1Node["UnitCpu"].asString());
+	if(!cpu1Node["OriginalTotalCpu"].isNull())
+		instance_.readOnlyResource.cpu1.originalTotalCpu = std::stol(cpu1Node["OriginalTotalCpu"].asString());
+	auto memory2Node = readOnlyResourceNode["Memory"];
+	if(!memory2Node["TotalMemory"].isNull())
+		instance_.readOnlyResource.memory2.totalMemory = std::stol(memory2Node["TotalMemory"].asString());
+	if(!memory2Node["UsedMemory"].isNull())
+		instance_.readOnlyResource.memory2.usedMemory = std::stol(memory2Node["UsedMemory"].asString());
+	if(!memory2Node["UnitMemory"].isNull())
+		instance_.readOnlyResource.memory2.unitMemory = std::stol(memory2Node["UnitMemory"].asString());
+	if(!memory2Node["OriginalTotalMemory"].isNull())
+		instance_.readOnlyResource.memory2.originalTotalMemory = std::stol(memory2Node["OriginalTotalMemory"].asString());
+	auto diskSize3Node = readOnlyResourceNode["DiskSize"];
+	if(!diskSize3Node["TotalDiskSize"].isNull())
+		instance_.readOnlyResource.diskSize3.totalDiskSize = std::stol(diskSize3Node["TotalDiskSize"].asString());
+	if(!diskSize3Node["UsedDiskSize"].isNull())
+		instance_.readOnlyResource.diskSize3.usedDiskSize = std::stol(diskSize3Node["UsedDiskSize"].asString());
+	if(!diskSize3Node["UnitDiskSize"].isNull())
+		instance_.readOnlyResource.diskSize3.unitDiskSize = std::stol(diskSize3Node["UnitDiskSize"].asString());
+	if(!diskSize3Node["DataUsedSize"].isNull())
+		instance_.readOnlyResource.diskSize3.dataUsedSize = diskSize3Node["DataUsedSize"].asString();
+	if(!diskSize3Node["MaxDiskUsedPercent"].isNull())
+		instance_.readOnlyResource.diskSize3.maxDiskUsedPercent = diskSize3Node["MaxDiskUsedPercent"].asString();
+	if(!diskSize3Node["OriginalTotalDiskSize"].isNull())
+		instance_.readOnlyResource.diskSize3.originalTotalDiskSize = std::stol(diskSize3Node["OriginalTotalDiskSize"].asString());
+	if(!diskSize3Node["MaxDiskSize"].isNull())
+		instance_.readOnlyResource.diskSize3.maxDiskSize = diskSize3Node["MaxDiskSize"].asString();
+		auto allMaxDiskUsedObServer6 = diskSize3Node["MaxDiskUsedObServer"]["MaxDiskUsedObServer"];
+		for (auto value : allMaxDiskUsedObServer6)
+			instance_.readOnlyResource.diskSize3.maxDiskUsedObServer6.push_back(value.asString());
+	auto logDiskSize4Node = readOnlyResourceNode["LogDiskSize"];
+	if(!logDiskSize4Node["TotalDiskSize"].isNull())
+		instance_.readOnlyResource.logDiskSize4.totalDiskSize = std::stol(logDiskSize4Node["TotalDiskSize"].asString());
+	if(!logDiskSize4Node["UnitDiskSize"].isNull())
+		instance_.readOnlyResource.logDiskSize4.unitDiskSize = std::stol(logDiskSize4Node["UnitDiskSize"].asString());
+	if(!logDiskSize4Node["LogAssignedSize"].isNull())
+		instance_.readOnlyResource.logDiskSize4.logAssignedSize = logDiskSize4Node["LogAssignedSize"].asString();
+	if(!logDiskSize4Node["MaxLogAssignedPercent"].isNull())
+		instance_.readOnlyResource.logDiskSize4.maxLogAssignedPercent = logDiskSize4Node["MaxLogAssignedPercent"].asString();
+		auto allMaxLogAssignedObServer7 = logDiskSize4Node["MaxLogAssignedObServer"]["MaxLogAssignedObServer"];
+		for (auto value : allMaxLogAssignedObServer7)
+			instance_.readOnlyResource.logDiskSize4.maxLogAssignedObServer7.push_back(value.asString());
+	auto capacityUnit5Node = readOnlyResourceNode["CapacityUnit"];
+	if(!capacityUnit5Node["MaxCapacityUnit"].isNull())
+		instance_.readOnlyResource.capacityUnit5.maxCapacityUnit = std::stoi(capacityUnit5Node["MaxCapacityUnit"].asString());
+	if(!capacityUnit5Node["MinCapacityUnit"].isNull())
+		instance_.readOnlyResource.capacityUnit5.minCapacityUnit = std::stoi(capacityUnit5Node["MinCapacityUnit"].asString());
+	if(!capacityUnit5Node["UsedCapacityUnit"].isNull())
+		instance_.readOnlyResource.capacityUnit5.usedCapacityUnit = capacityUnit5Node["UsedCapacityUnit"].asString();
 		auto allAvailableZones = instanceNode["AvailableZones"]["AvailableZones"];
 		for (auto value : allAvailableZones)
 			instance_.availableZones.push_back(value.asString());

oceanbasepro/src/model/DescribeInstanceTopologyResult.cc

@@ -94,6 +94,8 @@ void DescribeInstanceTopologyResult::parse(const std::string &payload)
 					unitsObject.enableCancelMigrateUnit = instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItemUnitsUnitsItem["EnableCancelMigrateUnit"].asString() == "true";
 				if(!instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItemUnitsUnitsItem["UnitDataSize"].isNull())
 					unitsObject.unitDataSize = std::stol(instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItemUnitsUnitsItem["UnitDataSize"].asString());
+				if(!instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItemUnitsUnitsItem["ReplicaType"].isNull())
+					unitsObject.replicaType = instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItemUnitsUnitsItem["ReplicaType"].asString();
 				tenantZonesObject.units.push_back(unitsObject);
 			}
 			tenantsItemObject.tenantZones.push_back(tenantZonesObject);
@@ -120,6 +122,12 @@ void DescribeInstanceTopologyResult::parse(const std::string &payload)
 				nodesObject.nodeCopyId = std::stol(instanceTopologyNodeZonesZonesItemNodesNodesItem["NodeCopyId"].asString());
 			if(!instanceTopologyNodeZonesZonesItemNodesNodesItem["NodeStatus"].isNull())
 				nodesObject.nodeStatus = instanceTopologyNodeZonesZonesItemNodesNodesItem["NodeStatus"].asString();
+			if(!instanceTopologyNodeZonesZonesItemNodesNodesItem["ReplicaType"].isNull())
+				nodesObject.replicaType = instanceTopologyNodeZonesZonesItemNodesNodesItem["ReplicaType"].asString();
+			if(!instanceTopologyNodeZonesZonesItemNodesNodesItem["FullCopyId"].isNull())
+				nodesObject.fullCopyId = std::stol(instanceTopologyNodeZonesZonesItemNodesNodesItem["FullCopyId"].asString());
+			if(!instanceTopologyNodeZonesZonesItemNodesNodesItem["ReadOnlyCopyId"].isNull())
+				nodesObject.readOnlyCopyId = std::stol(instanceTopologyNodeZonesZonesItemNodesNodesItem["ReadOnlyCopyId"].asString());
 			auto allNodeResourceNode = instanceTopologyNodeZonesZonesItemNodesNodesItem["NodeResource"]["NodeResourceItem"];
 			for (auto instanceTopologyNodeZonesZonesItemNodesNodesItemNodeResourceNodeResourceItem : allNodeResourceNode)
 			{

oceanbasepro/src/model/DescribeMetricsDataRequest.cc

@@ -70,6 +70,15 @@ void DescribeMetricsDataRequest::setSortMetricKey(const std::string &sortMetricK
   setParameter(std::string("SortMetricKey"), sortMetricKey);
 }
 
+std::string DescribeMetricsDataRequest::getReplicaType() const {
+  return replicaType_;
+}
+
+void DescribeMetricsDataRequest::setReplicaType(const std::string &replicaType) {
+  replicaType_ = replicaType;
+  setBodyParameter(std::string("ReplicaType"), replicaType);
+}
+
 std::string DescribeMetricsDataRequest::getEndTime() const {
   return endTime_;
 }

oceanbasepro/src/model/DescribeTenantResult.cc

@@ -92,6 +92,8 @@ void DescribeTenantResult::parse(const std::string &payload)
 		tenant_.enableBinlogService = tenantNode["EnableBinlogService"].asString() == "true";
 	if(!tenantNode["TimeZone"].isNull())
 		tenant_.timeZone = tenantNode["TimeZone"].asString();
+	if(!tenantNode["DataMergeTime"].isNull())
+		tenant_.dataMergeTime = tenantNode["DataMergeTime"].asString();
 	auto allTenantConnectionsNode = tenantNode["TenantConnections"]["TenantConnectionsItem"];
 	for (auto tenantNodeTenantConnectionsTenantConnectionsItem : allTenantConnectionsNode)
 	{
@@ -128,6 +130,8 @@ void DescribeTenantResult::parse(const std::string &payload)
 			tenantConnectionsItemObject.tenantEndpointId = tenantNodeTenantConnectionsTenantConnectionsItem["TenantEndpointId"].asString();
 		if(!tenantNodeTenantConnectionsTenantConnectionsItem["MaxConnectionNum"].isNull())
 			tenantConnectionsItemObject.maxConnectionNum = std::stol(tenantNodeTenantConnectionsTenantConnectionsItem["MaxConnectionNum"].asString());
+		if(!tenantNodeTenantConnectionsTenantConnectionsItem["ConnectionReplicaType"].isNull())
+			tenantConnectionsItemObject.connectionReplicaType = tenantNodeTenantConnectionsTenantConnectionsItem["ConnectionReplicaType"].asString();
 		auto allConnectionZones = value["ConnectionZones"]["ConnectionZones"];
 		for (auto value : allConnectionZones)
 			tenantConnectionsItemObject.connectionZones.push_back(value.asString());
@@ -143,6 +147,24 @@ void DescribeTenantResult::parse(const std::string &payload)
 			tenantZonesItemObject.region = tenantNodeTenantZonesTenantZonesItem["Region"].asString();
 		if(!tenantNodeTenantZonesTenantZonesItem["TenantZoneRole"].isNull())
 			tenantZonesItemObject.tenantZoneRole = tenantNodeTenantZonesTenantZonesItem["TenantZoneRole"].asString();
+		auto allTenantZoneReplicasNode = tenantNodeTenantZonesTenantZonesItem["TenantZoneReplicas"]["TenantZoneReplicasItem"];
+		for (auto tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem : allTenantZoneReplicasNode)
+		{
+			Tenant::TenantZonesItem::TenantZoneReplicasItem tenantZoneReplicasObject;
+			if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneReplicaType"].isNull())
+				tenantZoneReplicasObject.zoneReplicaType = tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneReplicaType"].asString();
+			if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneNodes"].isNull())
+				tenantZoneReplicasObject.zoneNodes = tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneNodes"].asString();
+			if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["LogicZoneName"].isNull())
+				tenantZoneReplicasObject.logicZoneName = tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["LogicZoneName"].asString();
+			if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneCopyId"].isNull())
+				tenantZoneReplicasObject.zoneCopyId = std::stoi(tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneCopyId"].asString());
+			if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["FullCopyId"].isNull())
+				tenantZoneReplicasObject.fullCopyId = std::stoi(tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["FullCopyId"].asString());
+			if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ReadOnlyCopyId"].isNull())
+				tenantZoneReplicasObject.readOnlyCopyId = tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ReadOnlyCopyId"].asString();
+			tenantZonesItemObject.tenantZoneReplicas.push_back(tenantZoneReplicasObject);
+		}
 		tenant_.tenantZones.push_back(tenantZonesItemObject);
 	}
 	auto tenantResourceNode = tenantNode["TenantResource"];
@@ -177,6 +199,38 @@ void DescribeTenantResult::parse(const std::string &payload)
 		tenant_.tenantResource.logDiskSize.totalLogDisk = std::stoi(logDiskSizeNode["TotalLogDisk"].asString());
 	if(!logDiskSizeNode["UnitLogDisk"].isNull())
 		tenant_.tenantResource.logDiskSize.unitLogDisk = std::stoi(logDiskSizeNode["UnitLogDisk"].asString());
+	auto readOnlyResourceNode = tenantNode["ReadOnlyResource"];
+	if(!readOnlyResourceNode["UnitNum"].isNull())
+		tenant_.readOnlyResource.unitNum = std::stoi(readOnlyResourceNode["UnitNum"].asString());
+	auto cpu1Node = readOnlyResourceNode["Cpu"];
+	if(!cpu1Node["UsedCpu"].isNull())
+		tenant_.readOnlyResource.cpu1.usedCpu = std::stof(cpu1Node["UsedCpu"].asString());
+	if(!cpu1Node["TotalCpu"].isNull())
+		tenant_.readOnlyResource.cpu1.totalCpu = std::stof(cpu1Node["TotalCpu"].asString());
+	if(!cpu1Node["UnitCpu"].isNull())
+		tenant_.readOnlyResource.cpu1.unitCpu = std::stof(cpu1Node["UnitCpu"].asString());
+	auto memory2Node = readOnlyResourceNode["Memory"];
+	if(!memory2Node["UsedMemory"].isNull())
+		tenant_.readOnlyResource.memory2.usedMemory = std::stof(memory2Node["UsedMemory"].asString());
+	if(!memory2Node["TotalMemory"].isNull())
+		tenant_.readOnlyResource.memory2.totalMemory = std::stof(memory2Node["TotalMemory"].asString());
+	if(!memory2Node["UnitMemory"].isNull())
+		tenant_.readOnlyResource.memory2.unitMemory = std::stof(memory2Node["UnitMemory"].asString());
+	auto diskSize3Node = readOnlyResourceNode["DiskSize"];
+	if(!diskSize3Node["UsedDiskSize"].isNull())
+		tenant_.readOnlyResource.diskSize3.usedDiskSize = std::stof(diskSize3Node["UsedDiskSize"].asString());
+	auto capacityUnit4Node = readOnlyResourceNode["CapacityUnit"];
+	if(!capacityUnit4Node["MaxCapacityUnit"].isNull())
+		tenant_.readOnlyResource.capacityUnit4.maxCapacityUnit = std::stoi(capacityUnit4Node["MaxCapacityUnit"].asString());
+	if(!capacityUnit4Node["MinCapacityUnit"].isNull())
+		tenant_.readOnlyResource.capacityUnit4.minCapacityUnit = std::stoi(capacityUnit4Node["MinCapacityUnit"].asString());
+	if(!capacityUnit4Node["UsedCapacit"].isNull())
+		tenant_.readOnlyResource.capacityUnit4.usedCapacit = std::stoi(capacityUnit4Node["UsedCapacit"].asString());
+	auto logDiskSize5Node = readOnlyResourceNode["LogDiskSize"];
+	if(!logDiskSize5Node["TotalLogDisk"].isNull())
+		tenant_.readOnlyResource.logDiskSize5.totalLogDisk = std::stoi(logDiskSize5Node["TotalLogDisk"].asString());
+	if(!logDiskSize5Node["UnitLogDisk"].isNull())
+		tenant_.readOnlyResource.logDiskSize5.unitLogDisk = std::stoi(logDiskSize5Node["UnitLogDisk"].asString());
 		auto allAvailableZones = tenantNode["AvailableZones"]["AvailableZones"];
 		for (auto value : allAvailableZones)
 			tenant_.availableZones.push_back(value.asString());

oceanbasepro/src/model/ModifyInstanceSpecRequest.cc

@@ -61,6 +61,15 @@ void ModifyInstanceSpecRequest::setDiskSize(long diskSize) {
   setBodyParameter(std::string("DiskSize"), std::to_string(diskSize));
 }
 
+std::string ModifyInstanceSpecRequest::getDiskType() const {
+  return diskType_;
+}
+
+void ModifyInstanceSpecRequest::setDiskType(const std::string &diskType) {
+  diskType_ = diskType;
+  setBodyParameter(std::string("DiskType"), diskType);
+}
+
 std::string ModifyInstanceSpecRequest::getInstanceId() const {
   return instanceId_;
 }

oceanbasepro/src/model/ModifyInstanceTemporaryCapacityRequest.cc

@@ -52,3 +52,12 @@ void ModifyInstanceTemporaryCapacityRequest::setInstanceId(const std::string &in
   setBodyParameter(std::string("InstanceId"), instanceId);
 }
 
+std::string ModifyInstanceTemporaryCapacityRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void ModifyInstanceTemporaryCapacityRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setBodyParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+

oceanbasepro/src/model/ModifyTenantPrimaryZoneRequest.cc

@@ -25,6 +25,15 @@ ModifyTenantPrimaryZoneRequest::ModifyTenantPrimaryZoneRequest()
 
 ModifyTenantPrimaryZoneRequest::~ModifyTenantPrimaryZoneRequest() {}
 
+std::string ModifyTenantPrimaryZoneRequest::getTenantEndpointDirectId() const {
+  return tenantEndpointDirectId_;
+}
+
+void ModifyTenantPrimaryZoneRequest::setTenantEndpointDirectId(const std::string &tenantEndpointDirectId) {
+  tenantEndpointDirectId_ = tenantEndpointDirectId;
+  setBodyParameter(std::string("TenantEndpointDirectId"), tenantEndpointDirectId);
+}
+
 std::string ModifyTenantPrimaryZoneRequest::getUserVSwitchId() const {
   return userVSwitchId_;
 }
@@ -79,3 +88,12 @@ void ModifyTenantPrimaryZoneRequest::setPrimaryZone(const std::string &primaryZo
   setBodyParameter(std::string("PrimaryZone"), primaryZone);
 }
 
+std::string ModifyTenantPrimaryZoneRequest::getUserDirectVSwitchId() const {
+  return userDirectVSwitchId_;
+}
+
+void ModifyTenantPrimaryZoneRequest::setUserDirectVSwitchId(const std::string &userDirectVSwitchId) {
+  userDirectVSwitchId_ = userDirectVSwitchId;
+  setBodyParameter(std::string("UserDirectVSwitchId"), userDirectVSwitchId);
+}
+