@alicloud/polardbx20200202 1.0.4 → 1.0.7

package/src/client.ts

@@ -155,23 +155,26 @@ export class CancelActiveOperationTasksResponse extends $tea.Model {
   }
 }
 
-export class CancelPolarxOrderRequest extends $tea.Model {
-  DBInstanceName?: string;
+export class ChangeResourceGroupRequest extends $tea.Model {
+  newResourceGroupId?: string;
   regionId?: string;
-  scaleOutToken?: string;
+  resourceId?: string;
+  resourceType?: string;
   static names(): { [key: string]: string } {
     return {
-      DBInstanceName: 'DBInstanceName',
+      newResourceGroupId: 'NewResourceGroupId',
       regionId: 'RegionId',
-      scaleOutToken: 'ScaleOutToken',
+      resourceId: 'ResourceId',
+      resourceType: 'ResourceType',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      DBInstanceName: 'string',
+      newResourceGroupId: 'string',
       regionId: 'string',
-      scaleOutToken: 'string',
+      resourceId: 'string',
+      resourceType: 'string',
     };
   }
 
@@ -180,7 +183,7 @@ export class CancelPolarxOrderRequest extends $tea.Model {
   }
 }
 
-export class CancelPolarxOrderResponseBody extends $tea.Model {
+export class ChangeResourceGroupResponseBody extends $tea.Model {
   requestId?: string;
   static names(): { [key: string]: string } {
     return {
@@ -199,9 +202,9 @@ export class CancelPolarxOrderResponseBody extends $tea.Model {
   }
 }
 
-export class CancelPolarxOrderResponse extends $tea.Model {
+export class ChangeResourceGroupResponse extends $tea.Model {
   headers: { [key: string]: string };
-  body: CancelPolarxOrderResponseBody;
+  body: ChangeResourceGroupResponseBody;
   static names(): { [key: string]: string } {
     return {
       headers: 'headers',
@@ -212,7 +215,7 @@ export class CancelPolarxOrderResponse extends $tea.Model {
   static types(): { [key: string]: any } {
     return {
       headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
-      body: CancelPolarxOrderResponseBody,
+      body: ChangeResourceGroupResponseBody,
     };
   }
 
@@ -556,8 +559,12 @@ export class CreateDBInstanceRequest extends $tea.Model {
   payType?: string;
   period?: string;
   primaryDBInstanceName?: string;
+  primaryZone?: string;
   regionId?: string;
   resourceGroupId?: string;
+  secondaryZone?: string;
+  tertiaryZone?: string;
+  topologyType?: string;
   usedTime?: number;
   VPCId?: string;
   vSwitchId?: string;
@@ -574,8 +581,12 @@ export class CreateDBInstanceRequest extends $tea.Model {
       payType: 'PayType',
       period: 'Period',
       primaryDBInstanceName: 'PrimaryDBInstanceName',
+      primaryZone: 'PrimaryZone',
       regionId: 'RegionId',
       resourceGroupId: 'ResourceGroupId',
+      secondaryZone: 'SecondaryZone',
+      tertiaryZone: 'TertiaryZone',
+      topologyType: 'TopologyType',
       usedTime: 'UsedTime',
       VPCId: 'VPCId',
       vSwitchId: 'VSwitchId',
@@ -595,8 +606,12 @@ export class CreateDBInstanceRequest extends $tea.Model {
       payType: 'string',
       period: 'string',
       primaryDBInstanceName: 'string',
+      primaryZone: 'string',
       regionId: 'string',
       resourceGroupId: 'string',
+      secondaryZone: 'string',
+      tertiaryZone: 'string',
+      topologyType: 'string',
       usedTime: 'number',
       VPCId: 'string',
       vSwitchId: 'string',
@@ -656,75 +671,6 @@ export class CreateDBInstanceResponse extends $tea.Model {
   }
 }
 
-export class CreatePolarxOrderRequest extends $tea.Model {
-  DBInstanceName?: string;
-  nodeCount?: string;
-  regionId?: string;
-  static names(): { [key: string]: string } {
-    return {
-      DBInstanceName: 'DBInstanceName',
-      nodeCount: 'NodeCount',
-      regionId: 'RegionId',
-    };
-  }
-
-  static types(): { [key: string]: any } {
-    return {
-      DBInstanceName: 'string',
-      nodeCount: 'string',
-      regionId: 'string',
-    };
-  }
-
-  constructor(map?: { [key: string]: any }) {
-    super(map);
-  }
-}
-
-export class CreatePolarxOrderResponseBody extends $tea.Model {
-  orderResultList?: CreatePolarxOrderResponseBodyOrderResultList[];
-  requestId?: string;
-  static names(): { [key: string]: string } {
-    return {
-      orderResultList: 'OrderResultList',
-      requestId: 'RequestId',
-    };
-  }
-
-  static types(): { [key: string]: any } {
-    return {
-      orderResultList: { 'type': 'array', 'itemType': CreatePolarxOrderResponseBodyOrderResultList },
-      requestId: 'string',
-    };
-  }
-
-  constructor(map?: { [key: string]: any }) {
-    super(map);
-  }
-}
-
-export class CreatePolarxOrderResponse extends $tea.Model {
-  headers: { [key: string]: string };
-  body: CreatePolarxOrderResponseBody;
-  static names(): { [key: string]: string } {
-    return {
-      headers: 'headers',
-      body: 'body',
-    };
-  }
-
-  static types(): { [key: string]: any } {
-    return {
-      headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
-      body: CreatePolarxOrderResponseBody,
-    };
-  }
-
-  constructor(map?: { [key: string]: any }) {
-    super(map);
-  }
-}
-
 export class CreateSuperAccountRequest extends $tea.Model {
   accountDescription?: string;
   accountName?: string;
@@ -1232,6 +1178,111 @@ export class DescribeActiveOperationTaskCountResponse extends $tea.Model {
   }
 }
 
+export class DescribeActiveOperationTasksRequest extends $tea.Model {
+  allowCancel?: number;
+  allowChange?: number;
+  changeLevel?: string;
+  dbType?: string;
+  insName?: string;
+  pageNumber?: number;
+  pageSize?: number;
+  productId?: string;
+  region?: string;
+  regionId?: string;
+  status?: number;
+  taskType?: string;
+  static names(): { [key: string]: string } {
+    return {
+      allowCancel: 'AllowCancel',
+      allowChange: 'AllowChange',
+      changeLevel: 'ChangeLevel',
+      dbType: 'DbType',
+      insName: 'InsName',
+      pageNumber: 'PageNumber',
+      pageSize: 'PageSize',
+      productId: 'ProductId',
+      region: 'Region',
+      regionId: 'RegionId',
+      status: 'Status',
+      taskType: 'TaskType',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      allowCancel: 'number',
+      allowChange: 'number',
+      changeLevel: 'string',
+      dbType: 'string',
+      insName: 'string',
+      pageNumber: 'number',
+      pageSize: 'number',
+      productId: 'string',
+      region: 'string',
+      regionId: 'string',
+      status: 'number',
+      taskType: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class DescribeActiveOperationTasksResponseBody extends $tea.Model {
+  items?: DescribeActiveOperationTasksResponseBodyItems[];
+  pageNumber?: number;
+  pageSize?: number;
+  requestId?: string;
+  totalRecordCount?: number;
+  static names(): { [key: string]: string } {
+    return {
+      items: 'Items',
+      pageNumber: 'PageNumber',
+      pageSize: 'PageSize',
+      requestId: 'RequestId',
+      totalRecordCount: 'TotalRecordCount',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      items: { 'type': 'array', 'itemType': DescribeActiveOperationTasksResponseBodyItems },
+      pageNumber: 'number',
+      pageSize: 'number',
+      requestId: 'string',
+      totalRecordCount: 'number',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class DescribeActiveOperationTasksResponse extends $tea.Model {
+  headers: { [key: string]: string };
+  body: DescribeActiveOperationTasksResponseBody;
+  static names(): { [key: string]: string } {
+    return {
+      headers: 'headers',
+      body: 'body',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+      body: DescribeActiveOperationTasksResponseBody,
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
 export class DescribeBackupPolicyRequest extends $tea.Model {
   DBInstanceName?: string;
   regionId?: string;
@@ -1550,10 +1601,12 @@ export class DescribeCharacterSetResponse extends $tea.Model {
 export class DescribeDBInstanceAttributeRequest extends $tea.Model {
   DBInstanceName?: string;
   regionId?: string;
+  resourceGroupId?: string;
   static names(): { [key: string]: string } {
     return {
       DBInstanceName: 'DBInstanceName',
       regionId: 'RegionId',
+      resourceGroupId: 'ResourceGroupId',
     };
   }
 
@@ -1561,6 +1614,7 @@ export class DescribeDBInstanceAttributeRequest extends $tea.Model {
     return {
       DBInstanceName: 'string',
       regionId: 'string',
+      resourceGroupId: 'string',
     };
   }
 
@@ -1881,22 +1935,31 @@ export class DescribeDBInstanceTopologyResponse extends $tea.Model {
 }
 
 export class DescribeDBInstancesRequest extends $tea.Model {
+  instanceId?: string;
   pageNumber?: number;
   pageSize?: number;
   regionId?: string;
+  resourceGroupId?: string;
+  tags?: string;
   static names(): { [key: string]: string } {
     return {
+      instanceId: 'InstanceId',
       pageNumber: 'PageNumber',
       pageSize: 'PageSize',
       regionId: 'RegionId',
+      resourceGroupId: 'ResourceGroupId',
+      tags: 'Tags',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
+      instanceId: 'string',
       pageNumber: 'number',
       pageSize: 'number',
       regionId: 'string',
+      resourceGroupId: 'string',
+      tags: 'string',
     };
   }
 
@@ -2423,54 +2486,32 @@ export class DescribeParametersResponse extends $tea.Model {
   }
 }
 
-export class DescribePolarxDataNodesRequest extends $tea.Model {
-  pageNumber?: number;
-  pageSize?: number;
-  regionId?: string;
-  static names(): { [key: string]: string } {
-    return {
-      pageNumber: 'PageNumber',
-      pageSize: 'PageSize',
-      regionId: 'RegionId',
-    };
-  }
-
-  static types(): { [key: string]: any } {
-    return {
-      pageNumber: 'number',
-      pageSize: 'number',
-      regionId: 'string',
-    };
-  }
-
-  constructor(map?: { [key: string]: any }) {
-    super(map);
-  }
-}
-
-export class DescribePolarxDataNodesResponseBody extends $tea.Model {
-  DBInstanceDataNodes?: DescribePolarxDataNodesResponseBodyDBInstanceDataNodes[];
-  pageNumber?: number;
-  pageSize?: number;
+export class DescribeRegionsResponseBody extends $tea.Model {
+  code?: number;
+  errorCode?: number;
+  message?: string;
+  regions?: DescribeRegionsResponseBodyRegions;
   requestId?: string;
-  totalNumber?: number;
+  success?: boolean;
   static names(): { [key: string]: string } {
     return {
-      DBInstanceDataNodes: 'DBInstanceDataNodes',
-      pageNumber: 'PageNumber',
-      pageSize: 'PageSize',
+      code: 'Code',
+      errorCode: 'ErrorCode',
+      message: 'Message',
+      regions: 'Regions',
       requestId: 'RequestId',
-      totalNumber: 'TotalNumber',
+      success: 'Success',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      DBInstanceDataNodes: { 'type': 'array', 'itemType': DescribePolarxDataNodesResponseBodyDBInstanceDataNodes },
-      pageNumber: 'number',
-      pageSize: 'number',
+      code: 'number',
+      errorCode: 'number',
+      message: 'string',
+      regions: DescribeRegionsResponseBodyRegions,
       requestId: 'string',
-      totalNumber: 'number',
+      success: 'boolean',
     };
   }
 
@@ -2479,9 +2520,9 @@ export class DescribePolarxDataNodesResponseBody extends $tea.Model {
   }
 }
 
-export class DescribePolarxDataNodesResponse extends $tea.Model {
+export class DescribeRegionsResponse extends $tea.Model {
   headers: { [key: string]: string };
-  body: DescribePolarxDataNodesResponseBody;
+  body: DescribeRegionsResponseBody;
   static names(): { [key: string]: string } {
     return {
       headers: 'headers',
@@ -2492,7 +2533,7 @@ export class DescribePolarxDataNodesResponse extends $tea.Model {
   static types(): { [key: string]: any } {
     return {
       headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
-      body: DescribePolarxDataNodesResponseBody,
+      body: DescribeRegionsResponseBody,
     };
   }
 
@@ -2501,26 +2542,29 @@ export class DescribePolarxDataNodesResponse extends $tea.Model {
   }
 }
 
-export class DescribePolarxDbInstancesRequest extends $tea.Model {
-  dbName?: string;
-  drdsInstanceId?: string;
-  pageNumber?: number;
-  pageSize?: number;
+export class DescribeScaleOutMigrateTaskListRequest extends $tea.Model {
+  DBInstanceName?: string;
+  ownerAccount?: string;
+  ownerId?: number;
+  resourceOwnerAccount?: string;
+  resourceOwnerId?: number;
   static names(): { [key: string]: string } {
     return {
-      dbName: 'DbName',
-      drdsInstanceId: 'DrdsInstanceId',
-      pageNumber: 'PageNumber',
-      pageSize: 'PageSize',
+      DBInstanceName: 'DBInstanceName',
+      ownerAccount: 'OwnerAccount',
+      ownerId: 'OwnerId',
+      resourceOwnerAccount: 'ResourceOwnerAccount',
+      resourceOwnerId: 'ResourceOwnerId',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      dbName: 'string',
-      drdsInstanceId: 'string',
-      pageNumber: 'number',
-      pageSize: 'number',
+      DBInstanceName: 'string',
+      ownerAccount: 'string',
+      ownerId: 'number',
+      resourceOwnerAccount: 'string',
+      resourceOwnerId: 'number',
     };
   }
 
@@ -2529,32 +2573,20 @@ export class DescribePolarxDbInstancesRequest extends $tea.Model {
   }
 }
 
-export class DescribePolarxDbInstancesResponseBody extends $tea.Model {
-  dbInstances?: DescribePolarxDbInstancesResponseBodyDbInstances;
-  pageNumber?: string;
-  pageSize?: string;
+export class DescribeScaleOutMigrateTaskListResponseBody extends $tea.Model {
+  progress?: number;
   requestId?: string;
-  success?: boolean;
-  total?: string;
   static names(): { [key: string]: string } {
     return {
-      dbInstances: 'DbInstances',
-      pageNumber: 'PageNumber',
-      pageSize: 'PageSize',
+      progress: 'Progress',
       requestId: 'RequestId',
-      success: 'Success',
-      total: 'Total',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      dbInstances: DescribePolarxDbInstancesResponseBodyDbInstances,
-      pageNumber: 'string',
-      pageSize: 'string',
+      progress: 'number',
       requestId: 'string',
-      success: 'boolean',
-      total: 'string',
     };
   }
 
@@ -2563,9 +2595,9 @@ export class DescribePolarxDbInstancesResponseBody extends $tea.Model {
   }
 }
 
-export class DescribePolarxDbInstancesResponse extends $tea.Model {
+export class DescribeScaleOutMigrateTaskListResponse extends $tea.Model {
   headers: { [key: string]: string };
-  body: DescribePolarxDbInstancesResponseBody;
+  body: DescribeScaleOutMigrateTaskListResponseBody;
   static names(): { [key: string]: string } {
     return {
       headers: 'headers',
@@ -2576,7 +2608,7 @@ export class DescribePolarxDbInstancesResponse extends $tea.Model {
   static types(): { [key: string]: any } {
     return {
       headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
-      body: DescribePolarxDbInstancesResponseBody,
+      body: DescribeScaleOutMigrateTaskListResponseBody,
     };
   }
 
@@ -2585,30 +2617,46 @@ export class DescribePolarxDbInstancesResponse extends $tea.Model {
   }
 }
 
-export class DescribeRegionsResponseBody extends $tea.Model {
-  code?: number;
-  errorCode?: number;
-  message?: string;
-  regions?: DescribeRegionsResponseBodyRegions;
-  requestId?: string;
-  success?: boolean;
+export class DescribeSecurityIpsRequest extends $tea.Model {
+  DBInstanceName?: string;
+  regionId?: string;
   static names(): { [key: string]: string } {
     return {
-      code: 'Code',
-      errorCode: 'ErrorCode',
-      message: 'Message',
-      regions: 'Regions',
-      requestId: 'RequestId',
-      success: 'Success',
+      DBInstanceName: 'DBInstanceName',
+      regionId: 'RegionId',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      code: 'number',
-      errorCode: 'number',
+      DBInstanceName: 'string',
+      regionId: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class DescribeSecurityIpsResponseBody extends $tea.Model {
+  data?: DescribeSecurityIpsResponseBodyData;
+  message?: string;
+  requestId?: string;
+  success?: boolean;
+  static names(): { [key: string]: string } {
+    return {
+      data: 'Data',
+      message: 'Message',
+      requestId: 'RequestId',
+      success: 'Success',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      data: DescribeSecurityIpsResponseBodyData,
       message: 'string',
-      regions: DescribeRegionsResponseBodyRegions,
       requestId: 'string',
       success: 'boolean',
     };
@@ -2619,9 +2667,9 @@ export class DescribeRegionsResponseBody extends $tea.Model {
   }
 }
 
-export class DescribeRegionsResponse extends $tea.Model {
+export class DescribeSecurityIpsResponse extends $tea.Model {
   headers: { [key: string]: string };
-  body: DescribeRegionsResponseBody;
+  body: DescribeSecurityIpsResponseBody;
   static names(): { [key: string]: string } {
     return {
       headers: 'headers',
@@ -2632,7 +2680,7 @@ export class DescribeRegionsResponse extends $tea.Model {
   static types(): { [key: string]: any } {
     return {
       headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
-      body: DescribeRegionsResponseBody,
+      body: DescribeSecurityIpsResponseBody,
     };
   }
 
@@ -2641,29 +2689,32 @@ export class DescribeRegionsResponse extends $tea.Model {
   }
 }
 
-export class DescribeScaleOutMigrateTaskListRequest extends $tea.Model {
-  DBInstanceName?: string;
-  ownerAccount?: string;
-  ownerId?: number;
-  resourceOwnerAccount?: string;
-  resourceOwnerId?: number;
+export class DescribeSlinkTaskInfoRequest extends $tea.Model {
+  failPageNumber?: number;
+  failPageSize?: number;
+  regionId?: string;
+  slinkTaskId?: string;
+  successPageNumber?: number;
+  successPageSize?: number;
   static names(): { [key: string]: string } {
     return {
-      DBInstanceName: 'DBInstanceName',
-      ownerAccount: 'OwnerAccount',
-      ownerId: 'OwnerId',
-      resourceOwnerAccount: 'ResourceOwnerAccount',
-      resourceOwnerId: 'ResourceOwnerId',
+      failPageNumber: 'FailPageNumber',
+      failPageSize: 'FailPageSize',
+      regionId: 'RegionId',
+      slinkTaskId: 'SlinkTaskId',
+      successPageNumber: 'SuccessPageNumber',
+      successPageSize: 'SuccessPageSize',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      DBInstanceName: 'string',
-      ownerAccount: 'string',
-      ownerId: 'number',
-      resourceOwnerAccount: 'string',
-      resourceOwnerId: 'number',
+      failPageNumber: 'number',
+      failPageSize: 'number',
+      regionId: 'string',
+      slinkTaskId: 'string',
+      successPageNumber: 'number',
+      successPageSize: 'number',
     };
   }
 
@@ -2672,20 +2723,26 @@ export class DescribeScaleOutMigrateTaskListRequest extends $tea.Model {
   }
 }
 
-export class DescribeScaleOutMigrateTaskListResponseBody extends $tea.Model {
-  progress?: number;
-  requestId?: string;
+export class DescribeSlinkTaskInfoResponseBody extends $tea.Model {
+  code?: number;
+  data?: DescribeSlinkTaskInfoResponseBodyData;
+  message?: string;
+  success?: string;
   static names(): { [key: string]: string } {
     return {
-      progress: 'Progress',
-      requestId: 'RequestId',
+      code: 'Code',
+      data: 'Data',
+      message: 'Message',
+      success: 'Success',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      progress: 'number',
-      requestId: 'string',
+      code: 'number',
+      data: DescribeSlinkTaskInfoResponseBodyData,
+      message: 'string',
+      success: 'string',
     };
   }
 
@@ -2694,9 +2751,9 @@ export class DescribeScaleOutMigrateTaskListResponseBody extends $tea.Model {
   }
 }
 
-export class DescribeScaleOutMigrateTaskListResponse extends $tea.Model {
+export class DescribeSlinkTaskInfoResponse extends $tea.Model {
   headers: { [key: string]: string };
-  body: DescribeScaleOutMigrateTaskListResponseBody;
+  body: DescribeSlinkTaskInfoResponseBody;
   static names(): { [key: string]: string } {
     return {
       headers: 'headers',
@@ -2707,7 +2764,7 @@ export class DescribeScaleOutMigrateTaskListResponse extends $tea.Model {
   static types(): { [key: string]: any } {
     return {
       headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
-      body: DescribeScaleOutMigrateTaskListResponseBody,
+      body: DescribeSlinkTaskInfoResponseBody,
     };
   }
 
@@ -2716,13 +2773,15 @@ export class DescribeScaleOutMigrateTaskListResponse extends $tea.Model {
   }
 }
 
-export class DescribeSecurityIpsRequest extends $tea.Model {
+export class DescribeTagsRequest extends $tea.Model {
   DBInstanceName?: string;
   regionId?: string;
+  tagKey?: string;
   static names(): { [key: string]: string } {
     return {
       DBInstanceName: 'DBInstanceName',
       regionId: 'RegionId',
+      tagKey: 'TagKey',
     };
   }
 
@@ -2730,6 +2789,7 @@ export class DescribeSecurityIpsRequest extends $tea.Model {
     return {
       DBInstanceName: 'string',
       regionId: 'string',
+      tagKey: 'string',
     };
   }
 
@@ -2738,26 +2798,20 @@ export class DescribeSecurityIpsRequest extends $tea.Model {
   }
 }
 
-export class DescribeSecurityIpsResponseBody extends $tea.Model {
-  data?: DescribeSecurityIpsResponseBodyData;
-  message?: string;
+export class DescribeTagsResponseBody extends $tea.Model {
   requestId?: string;
-  success?: boolean;
+  tagInfos?: DescribeTagsResponseBodyTagInfos[];
   static names(): { [key: string]: string } {
     return {
-      data: 'Data',
-      message: 'Message',
       requestId: 'RequestId',
-      success: 'Success',
+      tagInfos: 'TagInfos',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      data: DescribeSecurityIpsResponseBodyData,
-      message: 'string',
       requestId: 'string',
-      success: 'boolean',
+      tagInfos: { 'type': 'array', 'itemType': DescribeTagsResponseBodyTagInfos },
     };
   }
 
@@ -2766,9 +2820,9 @@ export class DescribeSecurityIpsResponseBody extends $tea.Model {
   }
 }
 
-export class DescribeSecurityIpsResponse extends $tea.Model {
+export class DescribeTagsResponse extends $tea.Model {
   headers: { [key: string]: string };
-  body: DescribeSecurityIpsResponseBody;
+  body: DescribeTagsResponseBody;
   static names(): { [key: string]: string } {
     return {
       headers: 'headers',
@@ -2779,7 +2833,7 @@ export class DescribeSecurityIpsResponse extends $tea.Model {
   static types(): { [key: string]: any } {
     return {
       headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
-      body: DescribeSecurityIpsResponseBody,
+      body: DescribeTagsResponseBody,
     };
   }
 
@@ -2953,14 +3007,12 @@ export class DescribeUserEncryptionKeyListResponse extends $tea.Model {
   }
 }
 
-export class GetPolarxCommodityRequest extends $tea.Model {
+export class InitDBInstanceResourceGroupIdRequest extends $tea.Model {
   DBInstanceName?: string;
-  orderType?: string;
   regionId?: string;
   static names(): { [key: string]: string } {
     return {
       DBInstanceName: 'DBInstanceName',
-      orderType: 'OrderType',
       regionId: 'RegionId',
     };
   }
@@ -2968,7 +3020,6 @@ export class GetPolarxCommodityRequest extends $tea.Model {
   static types(): { [key: string]: any } {
     return {
       DBInstanceName: 'string',
-      orderType: 'string',
       regionId: 'string',
     };
   }
@@ -2978,22 +3029,16 @@ export class GetPolarxCommodityRequest extends $tea.Model {
   }
 }
 
-export class GetPolarxCommodityResponseBody extends $tea.Model {
-  componentList?: GetPolarxCommodityResponseBodyComponentList[];
-  DBInstance?: GetPolarxCommodityResponseBodyDBInstance;
+export class InitDBInstanceResourceGroupIdResponseBody extends $tea.Model {
   requestId?: string;
   static names(): { [key: string]: string } {
     return {
-      componentList: 'ComponentList',
-      DBInstance: 'DBInstance',
       requestId: 'RequestId',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      componentList: { 'type': 'array', 'itemType': GetPolarxCommodityResponseBodyComponentList },
-      DBInstance: GetPolarxCommodityResponseBodyDBInstance,
       requestId: 'string',
     };
   }
@@ -3003,9 +3048,87 @@ export class GetPolarxCommodityResponseBody extends $tea.Model {
   }
 }
 
-export class GetPolarxCommodityResponse extends $tea.Model {
+export class InitDBInstanceResourceGroupIdResponse extends $tea.Model {
+  headers: { [key: string]: string };
+  body: InitDBInstanceResourceGroupIdResponseBody;
+  static names(): { [key: string]: string } {
+    return {
+      headers: 'headers',
+      body: 'body',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+      body: InitDBInstanceResourceGroupIdResponseBody,
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class ListTagResourcesRequest extends $tea.Model {
+  nextToken?: string;
+  regionId?: string;
+  resourceId?: string[];
+  resourceType?: string;
+  tag?: ListTagResourcesRequestTag[];
+  static names(): { [key: string]: string } {
+    return {
+      nextToken: 'NextToken',
+      regionId: 'RegionId',
+      resourceId: 'ResourceId',
+      resourceType: 'ResourceType',
+      tag: 'Tag',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      nextToken: 'string',
+      regionId: 'string',
+      resourceId: { 'type': 'array', 'itemType': 'string' },
+      resourceType: 'string',
+      tag: { 'type': 'array', 'itemType': ListTagResourcesRequestTag },
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class ListTagResourcesResponseBody extends $tea.Model {
+  nextToken?: string;
+  requestId?: string;
+  tagResources?: ListTagResourcesResponseBodyTagResources;
+  static names(): { [key: string]: string } {
+    return {
+      nextToken: 'NextToken',
+      requestId: 'RequestId',
+      tagResources: 'TagResources',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      nextToken: 'string',
+      requestId: 'string',
+      tagResources: ListTagResourcesResponseBodyTagResources,
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class ListTagResourcesResponse extends $tea.Model {
   headers: { [key: string]: string };
-  body: GetPolarxCommodityResponseBody;
+  body: ListTagResourcesResponseBody;
   static names(): { [key: string]: string } {
     return {
       headers: 'headers',
@@ -3016,7 +3139,7 @@ export class GetPolarxCommodityResponse extends $tea.Model {
   static types(): { [key: string]: any } {
     return {
       headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
-      body: GetPolarxCommodityResponseBody,
+      body: ListTagResourcesResponseBody,
     };
   }
 
@@ -3388,6 +3511,87 @@ export class ModifyDBInstanceConfigResponse extends $tea.Model {
   }
 }
 
+export class ModifyDBInstanceConnectionStringRequest extends $tea.Model {
+  connectionString?: string;
+  DBInstanceName?: string;
+  newPort?: string;
+  newPrefix?: string;
+  regionId?: string;
+  static names(): { [key: string]: string } {
+    return {
+      connectionString: 'ConnectionString',
+      DBInstanceName: 'DBInstanceName',
+      newPort: 'NewPort',
+      newPrefix: 'NewPrefix',
+      regionId: 'RegionId',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      connectionString: 'string',
+      DBInstanceName: 'string',
+      newPort: 'string',
+      newPrefix: 'string',
+      regionId: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class ModifyDBInstanceConnectionStringResponseBody extends $tea.Model {
+  code?: number;
+  data?: ModifyDBInstanceConnectionStringResponseBodyData;
+  message?: string;
+  requestId?: string;
+  static names(): { [key: string]: string } {
+    return {
+      code: 'Code',
+      data: 'Data',
+      message: 'Message',
+      requestId: 'RequestId',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      code: 'number',
+      data: ModifyDBInstanceConnectionStringResponseBodyData,
+      message: 'string',
+      requestId: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class ModifyDBInstanceConnectionStringResponse extends $tea.Model {
+  headers: { [key: string]: string };
+  body: ModifyDBInstanceConnectionStringResponseBody;
+  static names(): { [key: string]: string } {
+    return {
+      headers: 'headers',
+      body: 'body',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+      body: ModifyDBInstanceConnectionStringResponseBody,
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
 export class ModifyDBInstanceDescriptionRequest extends $tea.Model {
   DBInstanceDescription?: string;
   DBInstanceName?: string;
@@ -3820,50 +4024,26 @@ export class RestartDBInstanceResponse extends $tea.Model {
   }
 }
 
-export class UpdateBackupPolicyRequest extends $tea.Model {
-  backupPeriod?: string;
-  backupPlanBegin?: string;
-  backupSetRetention?: number;
-  backupType?: string;
-  backupWay?: string;
-  DBInstanceName?: string;
-  forceCleanOnHighSpaceUsage?: number;
-  isEnabled?: number;
-  localLogRetention?: number;
-  logLocalRetentionSpace?: number;
+export class TagResourcesRequest extends $tea.Model {
   regionId?: string;
-  removeLogRetention?: number;
+  resourceId?: string[];
+  resourceType?: string;
+  tag?: TagResourcesRequestTag[];
   static names(): { [key: string]: string } {
     return {
-      backupPeriod: 'BackupPeriod',
-      backupPlanBegin: 'BackupPlanBegin',
-      backupSetRetention: 'BackupSetRetention',
-      backupType: 'BackupType',
-      backupWay: 'BackupWay',
-      DBInstanceName: 'DBInstanceName',
-      forceCleanOnHighSpaceUsage: 'ForceCleanOnHighSpaceUsage',
-      isEnabled: 'IsEnabled',
-      localLogRetention: 'LocalLogRetention',
-      logLocalRetentionSpace: 'LogLocalRetentionSpace',
       regionId: 'RegionId',
-      removeLogRetention: 'RemoveLogRetention',
+      resourceId: 'ResourceId',
+      resourceType: 'ResourceType',
+      tag: 'Tag',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      backupPeriod: 'string',
-      backupPlanBegin: 'string',
-      backupSetRetention: 'number',
-      backupType: 'string',
-      backupWay: 'string',
-      DBInstanceName: 'string',
-      forceCleanOnHighSpaceUsage: 'number',
-      isEnabled: 'number',
-      localLogRetention: 'number',
-      logLocalRetentionSpace: 'number',
       regionId: 'string',
-      removeLogRetention: 'number',
+      resourceId: { 'type': 'array', 'itemType': 'string' },
+      resourceType: 'string',
+      tag: { 'type': 'array', 'itemType': TagResourcesRequestTag },
     };
   }
 
@@ -3872,14 +4052,179 @@ export class UpdateBackupPolicyRequest extends $tea.Model {
   }
 }
 
-export class UpdateBackupPolicyResponseBody extends $tea.Model {
-  data?: UpdateBackupPolicyResponseBodyData[];
-  message?: string;
+export class TagResourcesResponseBody extends $tea.Model {
   requestId?: string;
-  success?: boolean;
   static names(): { [key: string]: string } {
     return {
-      data: 'Data',
+      requestId: 'RequestId',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      requestId: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class TagResourcesResponse extends $tea.Model {
+  headers: { [key: string]: string };
+  body: TagResourcesResponseBody;
+  static names(): { [key: string]: string } {
+    return {
+      headers: 'headers',
+      body: 'body',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+      body: TagResourcesResponseBody,
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class UntagResourcesRequest extends $tea.Model {
+  all?: boolean;
+  regionId?: string;
+  resourceId?: string[];
+  resourceType?: string;
+  tagKey?: string[];
+  static names(): { [key: string]: string } {
+    return {
+      all: 'All',
+      regionId: 'RegionId',
+      resourceId: 'ResourceId',
+      resourceType: 'ResourceType',
+      tagKey: 'TagKey',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      all: 'boolean',
+      regionId: 'string',
+      resourceId: { 'type': 'array', 'itemType': 'string' },
+      resourceType: 'string',
+      tagKey: { 'type': 'array', 'itemType': 'string' },
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class UntagResourcesResponseBody extends $tea.Model {
+  requestId?: string;
+  static names(): { [key: string]: string } {
+    return {
+      requestId: 'RequestId',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      requestId: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class UntagResourcesResponse extends $tea.Model {
+  headers: { [key: string]: string };
+  body: UntagResourcesResponseBody;
+  static names(): { [key: string]: string } {
+    return {
+      headers: 'headers',
+      body: 'body',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+      body: UntagResourcesResponseBody,
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class UpdateBackupPolicyRequest extends $tea.Model {
+  backupPeriod?: string;
+  backupPlanBegin?: string;
+  backupSetRetention?: number;
+  backupType?: string;
+  backupWay?: string;
+  DBInstanceName?: string;
+  forceCleanOnHighSpaceUsage?: number;
+  isEnabled?: number;
+  localLogRetention?: number;
+  logLocalRetentionSpace?: number;
+  regionId?: string;
+  removeLogRetention?: number;
+  static names(): { [key: string]: string } {
+    return {
+      backupPeriod: 'BackupPeriod',
+      backupPlanBegin: 'BackupPlanBegin',
+      backupSetRetention: 'BackupSetRetention',
+      backupType: 'BackupType',
+      backupWay: 'BackupWay',
+      DBInstanceName: 'DBInstanceName',
+      forceCleanOnHighSpaceUsage: 'ForceCleanOnHighSpaceUsage',
+      isEnabled: 'IsEnabled',
+      localLogRetention: 'LocalLogRetention',
+      logLocalRetentionSpace: 'LogLocalRetentionSpace',
+      regionId: 'RegionId',
+      removeLogRetention: 'RemoveLogRetention',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      backupPeriod: 'string',
+      backupPlanBegin: 'string',
+      backupSetRetention: 'number',
+      backupType: 'string',
+      backupWay: 'string',
+      DBInstanceName: 'string',
+      forceCleanOnHighSpaceUsage: 'number',
+      isEnabled: 'number',
+      localLogRetention: 'number',
+      logLocalRetentionSpace: 'number',
+      regionId: 'string',
+      removeLogRetention: 'number',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class UpdateBackupPolicyResponseBody extends $tea.Model {
+  data?: UpdateBackupPolicyResponseBodyData[];
+  message?: string;
+  requestId?: string;
+  success?: boolean;
+  static names(): { [key: string]: string } {
+    return {
+      data: 'Data',
       message: 'Message',
       requestId: 'RequestId',
       success: 'Success',
@@ -4144,10 +4489,12 @@ export class UpdatePolarDBXInstanceNodeResponse extends $tea.Model {
 export class UpgradeDBInstanceKernelVersionRequest extends $tea.Model {
   DBInstanceName?: string;
   regionId?: string;
+  switchMode?: string;
   static names(): { [key: string]: string } {
     return {
       DBInstanceName: 'DBInstanceName',
       regionId: 'RegionId',
+      switchMode: 'SwitchMode',
     };
   }
 
@@ -4155,6 +4502,7 @@ export class UpgradeDBInstanceKernelVersionRequest extends $tea.Model {
     return {
       DBInstanceName: 'string',
       regionId: 'string',
+      switchMode: 'string',
     };
   }
 
@@ -4254,28 +4602,6 @@ export class CreateBackupResponseBodyData extends $tea.Model {
   }
 }
 
-export class CreatePolarxOrderResponseBodyOrderResultList extends $tea.Model {
-  DBInstanceName?: string;
-  orderId?: number;
-  static names(): { [key: string]: string } {
-    return {
-      DBInstanceName: 'DBInstanceName',
-      orderId: 'OrderId',
-    };
-  }
-
-  static types(): { [key: string]: any } {
-    return {
-      DBInstanceName: 'string',
-      orderId: 'number',
-    };
-  }
-
-  constructor(map?: { [key: string]: any }) {
-    super(map);
-  }
-}
-
 export class DescribeAccountListResponseBodyData extends $tea.Model {
   accountDescription?: string;
   accountName?: string;
@@ -4350,6 +4676,103 @@ export class DescribeActiveOperationMaintainConfResponseBodyConfig extends $tea.
   }
 }
 
+export class DescribeActiveOperationTasksResponseBodyItems extends $tea.Model {
+  allowCancel?: string;
+  allowChange?: string;
+  changeLevel?: string;
+  changeLevelEn?: string;
+  changeLevelZh?: string;
+  createdTime?: string;
+  currentAVZ?: string;
+  dbType?: string;
+  dbVersion?: string;
+  deadline?: string;
+  id?: number;
+  impact?: string;
+  impactEn?: string;
+  impactZh?: string;
+  insComment?: string;
+  insName?: string;
+  modifiedTime?: string;
+  prepareInterval?: string;
+  region?: string;
+  resultInfo?: string;
+  startTime?: string;
+  status?: number;
+  subInsNames?: string[];
+  switchTime?: string;
+  taskType?: string;
+  taskTypeEn?: string;
+  taskTypeZh?: string;
+  static names(): { [key: string]: string } {
+    return {
+      allowCancel: 'AllowCancel',
+      allowChange: 'AllowChange',
+      changeLevel: 'ChangeLevel',
+      changeLevelEn: 'ChangeLevelEn',
+      changeLevelZh: 'ChangeLevelZh',
+      createdTime: 'CreatedTime',
+      currentAVZ: 'CurrentAVZ',
+      dbType: 'DbType',
+      dbVersion: 'DbVersion',
+      deadline: 'Deadline',
+      id: 'Id',
+      impact: 'Impact',
+      impactEn: 'ImpactEn',
+      impactZh: 'ImpactZh',
+      insComment: 'InsComment',
+      insName: 'InsName',
+      modifiedTime: 'ModifiedTime',
+      prepareInterval: 'PrepareInterval',
+      region: 'Region',
+      resultInfo: 'ResultInfo',
+      startTime: 'StartTime',
+      status: 'Status',
+      subInsNames: 'SubInsNames',
+      switchTime: 'SwitchTime',
+      taskType: 'TaskType',
+      taskTypeEn: 'TaskTypeEn',
+      taskTypeZh: 'TaskTypeZh',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      allowCancel: 'string',
+      allowChange: 'string',
+      changeLevel: 'string',
+      changeLevelEn: 'string',
+      changeLevelZh: 'string',
+      createdTime: 'string',
+      currentAVZ: 'string',
+      dbType: 'string',
+      dbVersion: 'string',
+      deadline: 'string',
+      id: 'number',
+      impact: 'string',
+      impactEn: 'string',
+      impactZh: 'string',
+      insComment: 'string',
+      insName: 'string',
+      modifiedTime: 'string',
+      prepareInterval: 'string',
+      region: 'string',
+      resultInfo: 'string',
+      startTime: 'string',
+      status: 'number',
+      subInsNames: { 'type': 'array', 'itemType': 'string' },
+      switchTime: 'string',
+      taskType: 'string',
+      taskTypeEn: 'string',
+      taskTypeZh: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
 export class DescribeBackupPolicyResponseBodyData extends $tea.Model {
   backupPeriod?: string;
   backupPlanBegin?: string;
@@ -4572,6 +4995,28 @@ export class DescribeDBInstanceAttributeResponseBodyDBInstanceDBNodes extends $t
   }
 }
 
+export class DescribeDBInstanceAttributeResponseBodyDBInstanceTagSet extends $tea.Model {
+  key?: string;
+  value?: string;
+  static names(): { [key: string]: string } {
+    return {
+      key: 'Key',
+      value: 'Value',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      key: 'string',
+      value: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
 export class DescribeDBInstanceAttributeResponseBodyDBInstance extends $tea.Model {
   commodityCode?: string;
   connAddrs?: DescribeDBInstanceAttributeResponseBodyDBInstanceConnAddrs[];
@@ -4599,10 +5044,12 @@ export class DescribeDBInstanceAttributeResponseBodyDBInstance extends $tea.Mode
   port?: string;
   readDBInstances?: string[];
   regionId?: string;
+  resourceGroupId?: string;
   rightsSeparationEnabled?: boolean;
   rightsSeparationStatus?: string;
   status?: string;
   storageUsed?: number;
+  tagSet?: DescribeDBInstanceAttributeResponseBodyDBInstanceTagSet[];
   type?: string;
   VPCId?: string;
   vSwitchId?: string;
@@ -4635,10 +5082,12 @@ export class DescribeDBInstanceAttributeResponseBodyDBInstance extends $tea.Mode
       port: 'Port',
       readDBInstances: 'ReadDBInstances',
       regionId: 'RegionId',
+      resourceGroupId: 'ResourceGroupId',
       rightsSeparationEnabled: 'RightsSeparationEnabled',
       rightsSeparationStatus: 'RightsSeparationStatus',
       status: 'Status',
       storageUsed: 'StorageUsed',
+      tagSet: 'TagSet',
       type: 'Type',
       VPCId: 'VPCId',
       vSwitchId: 'VSwitchId',
@@ -4674,10 +5123,12 @@ export class DescribeDBInstanceAttributeResponseBodyDBInstance extends $tea.Mode
       port: 'string',
       readDBInstances: { 'type': 'array', 'itemType': 'string' },
       regionId: 'string',
+      resourceGroupId: 'string',
       rightsSeparationEnabled: 'boolean',
       rightsSeparationStatus: 'string',
       status: 'string',
       storageUsed: 'number',
+      tagSet: { 'type': 'array', 'itemType': DescribeDBInstanceAttributeResponseBodyDBInstanceTagSet },
       type: 'string',
       VPCId: 'string',
       vSwitchId: 'string',
@@ -4759,6 +5210,28 @@ export class DescribeDBInstanceTDEResponseBodyData extends $tea.Model {
   }
 }
 
+export class DescribeDBInstanceTopologyResponseBodyDataLogicInstanceTopologyItemsAzoneRoleList extends $tea.Model {
+  azone?: string;
+  role?: string;
+  static names(): { [key: string]: string } {
+    return {
+      azone: 'Azone',
+      role: 'Role',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      azone: 'string',
+      role: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
 export class DescribeDBInstanceTopologyResponseBodyDataLogicInstanceTopologyItemsConnectionIp extends $tea.Model {
   connectionString?: string;
   DBInstanceNetType?: number;
@@ -4785,6 +5258,9 @@ export class DescribeDBInstanceTopologyResponseBodyDataLogicInstanceTopologyItem
 }
 
 export class DescribeDBInstanceTopologyResponseBodyDataLogicInstanceTopologyItems extends $tea.Model {
+  activated?: boolean;
+  azone?: string;
+  azoneRoleList?: DescribeDBInstanceTopologyResponseBodyDataLogicInstanceTopologyItemsAzoneRoleList[];
   characterType?: string;
   connectionIp?: DescribeDBInstanceTopologyResponseBodyDataLogicInstanceTopologyItemsConnectionIp[];
   DBInstanceConnType?: number;
@@ -4803,8 +5279,13 @@ export class DescribeDBInstanceTopologyResponseBodyDataLogicInstanceTopologyItem
   maintainStartTime?: string;
   maxConnections?: number;
   maxIops?: number;
+  region?: string;
+  role?: string;
   static names(): { [key: string]: string } {
     return {
+      activated: 'Activated',
+      azone: 'Azone',
+      azoneRoleList: 'AzoneRoleList',
       characterType: 'CharacterType',
       connectionIp: 'ConnectionIp',
       DBInstanceConnType: 'DBInstanceConnType',
@@ -4823,11 +5304,16 @@ export class DescribeDBInstanceTopologyResponseBodyDataLogicInstanceTopologyItem
       maintainStartTime: 'MaintainStartTime',
       maxConnections: 'MaxConnections',
       maxIops: 'MaxIops',
+      region: 'Region',
+      role: 'Role',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
+      activated: 'boolean',
+      azone: 'string',
+      azoneRoleList: { 'type': 'array', 'itemType': DescribeDBInstanceTopologyResponseBodyDataLogicInstanceTopologyItemsAzoneRoleList },
       characterType: 'string',
       connectionIp: { 'type': 'array', 'itemType': DescribeDBInstanceTopologyResponseBodyDataLogicInstanceTopologyItemsConnectionIp },
       DBInstanceConnType: 'number',
@@ -4846,6 +5332,8 @@ export class DescribeDBInstanceTopologyResponseBodyDataLogicInstanceTopologyItem
       maintainStartTime: 'string',
       maxConnections: 'number',
       maxIops: 'number',
+      region: 'string',
+      role: 'string',
     };
   }
 
@@ -4962,17 +5450,40 @@ export class DescribeDBInstancesResponseBodyDBInstancesNodes extends $tea.Model
   }
 }
 
-export class DescribeDBInstancesResponseBodyDBInstances extends $tea.Model {
-  commodityCode?: string;
-  createTime?: string;
-  DBType?: string;
-  DBVersion?: string;
-  description?: string;
-  engine?: string;
-  expireTime?: string;
-  expired?: boolean;
-  id?: string;
-  lockMode?: string;
+export class DescribeDBInstancesResponseBodyDBInstancesTagSet extends $tea.Model {
+  key?: string;
+  value?: string;
+  static names(): { [key: string]: string } {
+    return {
+      key: 'Key',
+      value: 'Value',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      key: 'string',
+      value: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class DescribeDBInstancesResponseBodyDBInstances extends $tea.Model {
+  commodityCode?: string;
+  createTime?: string;
+  DBInstanceName?: string;
+  DBType?: string;
+  DBVersion?: string;
+  description?: string;
+  engine?: string;
+  expireTime?: string;
+  expired?: boolean;
+  id?: string;
+  lockMode?: string;
   lockReason?: string;
   minorVersion?: string;
   network?: string;
@@ -4982,8 +5493,10 @@ export class DescribeDBInstancesResponseBodyDBInstances extends $tea.Model {
   payType?: string;
   readDBInstances?: string[];
   regionId?: string;
+  resourceGroupId?: string;
   status?: string;
   storageUsed?: number;
+  tagSet?: DescribeDBInstancesResponseBodyDBInstancesTagSet[];
   type?: string;
   VPCId?: string;
   zoneId?: string;
@@ -4991,6 +5504,7 @@ export class DescribeDBInstancesResponseBodyDBInstances extends $tea.Model {
     return {
       commodityCode: 'CommodityCode',
       createTime: 'CreateTime',
+      DBInstanceName: 'DBInstanceName',
       DBType: 'DBType',
       DBVersion: 'DBVersion',
       description: 'Description',
@@ -5008,8 +5522,10 @@ export class DescribeDBInstancesResponseBodyDBInstances extends $tea.Model {
       payType: 'PayType',
       readDBInstances: 'ReadDBInstances',
       regionId: 'RegionId',
+      resourceGroupId: 'ResourceGroupId',
       status: 'Status',
       storageUsed: 'StorageUsed',
+      tagSet: 'TagSet',
       type: 'Type',
       VPCId: 'VPCId',
       zoneId: 'ZoneId',
@@ -5020,6 +5536,7 @@ export class DescribeDBInstancesResponseBodyDBInstances extends $tea.Model {
     return {
       commodityCode: 'string',
       createTime: 'string',
+      DBInstanceName: 'string',
       DBType: 'string',
       DBVersion: 'string',
       description: 'string',
@@ -5037,8 +5554,10 @@ export class DescribeDBInstancesResponseBodyDBInstances extends $tea.Model {
       payType: 'string',
       readDBInstances: { 'type': 'array', 'itemType': 'string' },
       regionId: 'string',
+      resourceGroupId: 'string',
       status: 'string',
       storageUsed: 'number',
+      tagSet: { 'type': 'array', 'itemType': DescribeDBInstancesResponseBodyDBInstancesTagSet },
       type: 'string',
       VPCId: 'string',
       zoneId: 'string',
@@ -5427,23 +5946,20 @@ export class DescribeParametersResponseBodyData extends $tea.Model {
   }
 }
 
-export class DescribePolarxDataNodesResponseBodyDBInstanceDataNodes extends $tea.Model {
-  DBInstanceDescription?: string;
-  DBInstanceId?: string;
-  DBInstanceName?: string;
+export class DescribeRegionsResponseBodyRegionsRegionZonesZone extends $tea.Model {
+  vpcEnabled?: boolean;
+  zoneId?: string;
   static names(): { [key: string]: string } {
     return {
-      DBInstanceDescription: 'DBInstanceDescription',
-      DBInstanceId: 'DBInstanceId',
-      DBInstanceName: 'DBInstanceName',
+      vpcEnabled: 'VpcEnabled',
+      zoneId: 'ZoneId',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      DBInstanceDescription: 'string',
-      DBInstanceId: 'string',
-      DBInstanceName: 'string',
+      vpcEnabled: 'boolean',
+      zoneId: 'string',
     };
   }
 
@@ -5452,71 +5968,45 @@ export class DescribePolarxDataNodesResponseBodyDBInstanceDataNodes extends $tea
   }
 }
 
-export class DescribePolarxDbInstancesResponseBodyDbInstancesDbInstance extends $tea.Model {
-  createTime?: string;
-  DBInstanceId?: string;
-  DBType?: string;
-  DBVersion?: string;
-  description?: string;
-  engine?: string;
-  expireTime?: string;
-  lockMode?: string;
-  network?: string;
-  nodeClass?: string;
-  nodeCount?: number;
-  payType?: string;
+export class DescribeRegionsResponseBodyRegionsRegionZones extends $tea.Model {
+  zone?: DescribeRegionsResponseBodyRegionsRegionZonesZone[];
+  static names(): { [key: string]: string } {
+    return {
+      zone: 'Zone',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      zone: { 'type': 'array', 'itemType': DescribeRegionsResponseBodyRegionsRegionZonesZone },
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class DescribeRegionsResponseBodyRegionsRegion extends $tea.Model {
   regionId?: string;
-  status?: string;
-  statusDesc?: string;
-  storageUsed?: number;
-  VPCId?: string;
-  zoneId?: string;
-  lockReason?: string;
+  supportPolarx10?: boolean;
+  supportPolarx20?: boolean;
+  zones?: DescribeRegionsResponseBodyRegionsRegionZones;
   static names(): { [key: string]: string } {
     return {
-      createTime: 'CreateTime',
-      DBInstanceId: 'DBInstanceId',
-      DBType: 'DBType',
-      DBVersion: 'DBVersion',
-      description: 'Description',
-      engine: 'Engine',
-      expireTime: 'ExpireTime',
-      lockMode: 'LockMode',
-      network: 'Network',
-      nodeClass: 'NodeClass',
-      nodeCount: 'NodeCount',
-      payType: 'PayType',
       regionId: 'RegionId',
-      status: 'Status',
-      statusDesc: 'StatusDesc',
-      storageUsed: 'StorageUsed',
-      VPCId: 'VPCId',
-      zoneId: 'ZoneId',
-      lockReason: 'lockReason',
+      supportPolarx10: 'SupportPolarx10',
+      supportPolarx20: 'SupportPolarx20',
+      zones: 'Zones',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      createTime: 'string',
-      DBInstanceId: 'string',
-      DBType: 'string',
-      DBVersion: 'string',
-      description: 'string',
-      engine: 'string',
-      expireTime: 'string',
-      lockMode: 'string',
-      network: 'string',
-      nodeClass: 'string',
-      nodeCount: 'number',
-      payType: 'string',
       regionId: 'string',
-      status: 'string',
-      statusDesc: 'string',
-      storageUsed: 'number',
-      VPCId: 'string',
-      zoneId: 'string',
-      lockReason: 'string',
+      supportPolarx10: 'boolean',
+      supportPolarx20: 'boolean',
+      zones: DescribeRegionsResponseBodyRegionsRegionZones,
     };
   }
 
@@ -5525,17 +6015,17 @@ export class DescribePolarxDbInstancesResponseBodyDbInstancesDbInstance extends
   }
 }
 
-export class DescribePolarxDbInstancesResponseBodyDbInstances extends $tea.Model {
-  dbInstance?: DescribePolarxDbInstancesResponseBodyDbInstancesDbInstance[];
+export class DescribeRegionsResponseBodyRegions extends $tea.Model {
+  region?: DescribeRegionsResponseBodyRegionsRegion[];
   static names(): { [key: string]: string } {
     return {
-      dbInstance: 'DbInstance',
+      region: 'Region',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      dbInstance: { 'type': 'array', 'itemType': DescribePolarxDbInstancesResponseBodyDbInstancesDbInstance },
+      region: { 'type': 'array', 'itemType': DescribeRegionsResponseBodyRegionsRegion },
     };
   }
 
@@ -5544,20 +6034,20 @@ export class DescribePolarxDbInstancesResponseBodyDbInstances extends $tea.Model
   }
 }
 
-export class DescribeRegionsResponseBodyRegionsRegionZonesZone extends $tea.Model {
-  vpcEnabled?: boolean;
-  zoneId?: string;
+export class DescribeSecurityIpsResponseBodyDataGroupItems extends $tea.Model {
+  groupName?: string;
+  securityIPList?: string;
   static names(): { [key: string]: string } {
     return {
-      vpcEnabled: 'VpcEnabled',
-      zoneId: 'ZoneId',
+      groupName: 'GroupName',
+      securityIPList: 'SecurityIPList',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      vpcEnabled: 'boolean',
-      zoneId: 'string',
+      groupName: 'string',
+      securityIPList: 'string',
     };
   }
 
@@ -5566,17 +6056,20 @@ export class DescribeRegionsResponseBodyRegionsRegionZonesZone extends $tea.Mode
   }
 }
 
-export class DescribeRegionsResponseBodyRegionsRegionZones extends $tea.Model {
-  zone?: DescribeRegionsResponseBodyRegionsRegionZonesZone[];
+export class DescribeSecurityIpsResponseBodyData extends $tea.Model {
+  DBInstanceName?: string;
+  groupItems?: DescribeSecurityIpsResponseBodyDataGroupItems[];
   static names(): { [key: string]: string } {
     return {
-      zone: 'Zone',
+      DBInstanceName: 'DBInstanceName',
+      groupItems: 'GroupItems',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      zone: { 'type': 'array', 'itemType': DescribeRegionsResponseBodyRegionsRegionZonesZone },
+      DBInstanceName: 'string',
+      groupItems: { 'type': 'array', 'itemType': DescribeSecurityIpsResponseBodyDataGroupItems },
     };
   }
 
@@ -5585,26 +6078,38 @@ export class DescribeRegionsResponseBodyRegionsRegionZones extends $tea.Model {
   }
 }
 
-export class DescribeRegionsResponseBodyRegionsRegion extends $tea.Model {
-  regionId?: string;
-  supportPolarx10?: boolean;
-  supportPolarx20?: boolean;
-  zones?: DescribeRegionsResponseBodyRegionsRegionZones;
+export class DescribeSlinkTaskInfoResponseBodyDataDataImportTaskDetailInfoServiceDetailListTaskDetailList extends $tea.Model {
+  delay?: number;
+  lastError?: string;
+  physicalDbName?: string;
+  progress?: number;
+  statistics?: string;
+  status?: string;
+  taskId?: number;
+  type?: string;
   static names(): { [key: string]: string } {
     return {
-      regionId: 'RegionId',
-      supportPolarx10: 'SupportPolarx10',
-      supportPolarx20: 'SupportPolarx20',
-      zones: 'Zones',
+      delay: 'Delay',
+      lastError: 'LastError',
+      physicalDbName: 'PhysicalDbName',
+      progress: 'Progress',
+      statistics: 'Statistics',
+      status: 'Status',
+      taskId: 'TaskId',
+      type: 'Type',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      regionId: 'string',
-      supportPolarx10: 'boolean',
-      supportPolarx20: 'boolean',
-      zones: DescribeRegionsResponseBodyRegionsRegionZones,
+      delay: 'number',
+      lastError: 'string',
+      physicalDbName: 'string',
+      progress: 'number',
+      statistics: 'string',
+      status: 'string',
+      taskId: 'number',
+      type: 'string',
     };
   }
 
@@ -5613,17 +6118,26 @@ export class DescribeRegionsResponseBodyRegionsRegion extends $tea.Model {
   }
 }
 
-export class DescribeRegionsResponseBodyRegions extends $tea.Model {
-  region?: DescribeRegionsResponseBodyRegionsRegion[];
+export class DescribeSlinkTaskInfoResponseBodyDataDataImportTaskDetailInfoServiceDetailList extends $tea.Model {
+  id?: number;
+  status?: string;
+  taskDetailList?: DescribeSlinkTaskInfoResponseBodyDataDataImportTaskDetailInfoServiceDetailListTaskDetailList[];
+  type?: string;
   static names(): { [key: string]: string } {
     return {
-      region: 'Region',
+      id: 'Id',
+      status: 'Status',
+      taskDetailList: 'TaskDetailList',
+      type: 'Type',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      region: { 'type': 'array', 'itemType': DescribeRegionsResponseBodyRegionsRegion },
+      id: 'number',
+      status: 'string',
+      taskDetailList: { 'type': 'array', 'itemType': DescribeSlinkTaskInfoResponseBodyDataDataImportTaskDetailInfoServiceDetailListTaskDetailList },
+      type: 'string',
     };
   }
 
@@ -5632,20 +6146,26 @@ export class DescribeRegionsResponseBodyRegions extends $tea.Model {
   }
 }
 
-export class DescribeSecurityIpsResponseBodyDataGroupItems extends $tea.Model {
-  groupName?: string;
-  securityIPList?: string;
+export class DescribeSlinkTaskInfoResponseBodyDataDataImportTaskDetailInfo extends $tea.Model {
+  fsmId?: number;
+  fsmState?: string;
+  fsmStatus?: string;
+  serviceDetailList?: DescribeSlinkTaskInfoResponseBodyDataDataImportTaskDetailInfoServiceDetailList[];
   static names(): { [key: string]: string } {
     return {
-      groupName: 'GroupName',
-      securityIPList: 'SecurityIPList',
+      fsmId: 'FsmId',
+      fsmState: 'FsmState',
+      fsmStatus: 'FsmStatus',
+      serviceDetailList: 'ServiceDetailList',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      groupName: 'string',
-      securityIPList: 'string',
+      fsmId: 'number',
+      fsmState: 'string',
+      fsmStatus: 'string',
+      serviceDetailList: { 'type': 'array', 'itemType': DescribeSlinkTaskInfoResponseBodyDataDataImportTaskDetailInfoServiceDetailList },
     };
   }
 
@@ -5654,20 +6174,42 @@ export class DescribeSecurityIpsResponseBodyDataGroupItems extends $tea.Model {
   }
 }
 
-export class DescribeSecurityIpsResponseBodyData extends $tea.Model {
-  DBInstanceName?: string;
-  groupItems?: DescribeSecurityIpsResponseBodyDataGroupItems[];
+export class DescribeSlinkTaskInfoResponseBodyData extends $tea.Model {
+  dataImportTaskDetailInfo?: DescribeSlinkTaskInfoResponseBodyDataDataImportTaskDetailInfo;
   static names(): { [key: string]: string } {
     return {
-      DBInstanceName: 'DBInstanceName',
-      groupItems: 'GroupItems',
+      dataImportTaskDetailInfo: 'DataImportTaskDetailInfo',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      DBInstanceName: 'string',
-      groupItems: { 'type': 'array', 'itemType': DescribeSecurityIpsResponseBodyDataGroupItems },
+      dataImportTaskDetailInfo: DescribeSlinkTaskInfoResponseBodyDataDataImportTaskDetailInfo,
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class DescribeTagsResponseBodyTagInfos extends $tea.Model {
+  DBInstanceIds?: string[];
+  tagKey?: string;
+  tagValue?: string;
+  static names(): { [key: string]: string } {
+    return {
+      DBInstanceIds: 'DBInstanceIds',
+      tagKey: 'TagKey',
+      tagValue: 'TagValue',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      DBInstanceIds: { 'type': 'array', 'itemType': 'string' },
+      tagKey: 'string',
+      tagValue: 'string',
     };
   }
 
@@ -5744,23 +6286,20 @@ export class DescribeUserEncryptionKeyListResponseBodyData extends $tea.Model {
   }
 }
 
-export class GetPolarxCommodityResponseBodyComponentList extends $tea.Model {
-  name?: string;
-  type?: string;
-  values?: string[];
+export class ListTagResourcesRequestTag extends $tea.Model {
+  key?: string;
+  value?: string;
   static names(): { [key: string]: string } {
     return {
-      name: 'Name',
-      type: 'Type',
-      values: 'Values',
+      key: 'Key',
+      value: 'Value',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      name: 'string',
-      type: 'string',
-      values: { 'type': 'array', 'itemType': 'string' },
+      key: 'string',
+      value: 'string',
     };
   }
 
@@ -5769,29 +6308,26 @@ export class GetPolarxCommodityResponseBodyComponentList extends $tea.Model {
   }
 }
 
-export class GetPolarxCommodityResponseBodyDBInstanceConnAddrs extends $tea.Model {
-  connectionString?: string;
-  port?: string;
-  type?: string;
-  VPCId?: string;
-  vSwitchId?: string;
+export class ListTagResourcesResponseBodyTagResourcesTagResource extends $tea.Model {
+  resourceId?: string;
+  resourceType?: string;
+  tagKey?: string;
+  tagValue?: string;
   static names(): { [key: string]: string } {
     return {
-      connectionString: 'ConnectionString',
-      port: 'Port',
-      type: 'Type',
-      VPCId: 'VPCId',
-      vSwitchId: 'VSwitchId',
+      resourceId: 'ResourceId',
+      resourceType: 'ResourceType',
+      tagKey: 'TagKey',
+      tagValue: 'TagValue',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      connectionString: 'string',
-      port: 'string',
-      type: 'string',
-      VPCId: 'string',
-      vSwitchId: 'string',
+      resourceId: 'string',
+      resourceType: 'string',
+      tagKey: 'string',
+      tagValue: 'string',
     };
   }
 
@@ -5800,26 +6336,17 @@ export class GetPolarxCommodityResponseBodyDBInstanceConnAddrs extends $tea.Mode
   }
 }
 
-export class GetPolarxCommodityResponseBodyDBInstanceDBNodes extends $tea.Model {
-  id?: string;
-  nodeClass?: string;
-  regionId?: string;
-  zoneId?: string;
+export class ListTagResourcesResponseBodyTagResources extends $tea.Model {
+  tagResource?: ListTagResourcesResponseBodyTagResourcesTagResource[];
   static names(): { [key: string]: string } {
     return {
-      id: 'Id',
-      nodeClass: 'NodeClass',
-      regionId: 'RegionId',
-      zoneId: 'ZoneId',
+      tagResource: 'TagResource',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      id: 'string',
-      nodeClass: 'string',
-      regionId: 'string',
-      zoneId: 'string',
+      tagResource: { 'type': 'array', 'itemType': ListTagResourcesResponseBodyTagResourcesTagResource },
     };
   }
 
@@ -5828,107 +6355,48 @@ export class GetPolarxCommodityResponseBodyDBInstanceDBNodes extends $tea.Model
   }
 }
 
-export class GetPolarxCommodityResponseBodyDBInstance extends $tea.Model {
-  commodityCode?: string;
-  connAddrs?: GetPolarxCommodityResponseBodyDBInstanceConnAddrs[];
+export class ModifyDBInstanceConnectionStringResponseBodyData extends $tea.Model {
   connectionString?: string;
-  createTime?: string;
-  DBInstanceType?: string;
-  DBNodeClass?: string;
-  DBNodeCount?: number;
-  DBNodes?: GetPolarxCommodityResponseBodyDBInstanceDBNodes[];
-  DBType?: string;
-  DBVersion?: string;
-  description?: string;
-  engine?: string;
-  expireDate?: string;
-  expired?: string;
-  id?: string;
-  latestMinorVersion?: string;
-  lockMode?: string;
-  maintainEndTime?: string;
-  maintainStartTime?: string;
-  minorVersion?: string;
-  network?: string;
-  payType?: string;
+  DBInstanceName?: string;
+  DBInstanceNetType?: string;
   port?: string;
-  readDBInstances?: string[];
-  regionId?: string;
-  status?: string;
-  storageUsed?: number;
-  type?: string;
-  VPCId?: string;
-  vSwitchId?: string;
-  zoneId?: string;
   static names(): { [key: string]: string } {
     return {
-      commodityCode: 'CommodityCode',
-      connAddrs: 'ConnAddrs',
       connectionString: 'ConnectionString',
-      createTime: 'CreateTime',
-      DBInstanceType: 'DBInstanceType',
-      DBNodeClass: 'DBNodeClass',
-      DBNodeCount: 'DBNodeCount',
-      DBNodes: 'DBNodes',
-      DBType: 'DBType',
-      DBVersion: 'DBVersion',
-      description: 'Description',
-      engine: 'Engine',
-      expireDate: 'ExpireDate',
-      expired: 'Expired',
-      id: 'Id',
-      latestMinorVersion: 'LatestMinorVersion',
-      lockMode: 'LockMode',
-      maintainEndTime: 'MaintainEndTime',
-      maintainStartTime: 'MaintainStartTime',
-      minorVersion: 'MinorVersion',
-      network: 'Network',
-      payType: 'PayType',
+      DBInstanceName: 'DBInstanceName',
+      DBInstanceNetType: 'DBInstanceNetType',
       port: 'Port',
-      readDBInstances: 'ReadDBInstances',
-      regionId: 'RegionId',
-      status: 'Status',
-      storageUsed: 'StorageUsed',
-      type: 'Type',
-      VPCId: 'VPCId',
-      vSwitchId: 'VSwitchId',
-      zoneId: 'ZoneId',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      commodityCode: 'string',
-      connAddrs: { 'type': 'array', 'itemType': GetPolarxCommodityResponseBodyDBInstanceConnAddrs },
       connectionString: 'string',
-      createTime: 'string',
-      DBInstanceType: 'string',
-      DBNodeClass: 'string',
-      DBNodeCount: 'number',
-      DBNodes: { 'type': 'array', 'itemType': GetPolarxCommodityResponseBodyDBInstanceDBNodes },
-      DBType: 'string',
-      DBVersion: 'string',
-      description: 'string',
-      engine: 'string',
-      expireDate: 'string',
-      expired: 'string',
-      id: 'string',
-      latestMinorVersion: 'string',
-      lockMode: 'string',
-      maintainEndTime: 'string',
-      maintainStartTime: 'string',
-      minorVersion: 'string',
-      network: 'string',
-      payType: 'string',
+      DBInstanceName: 'string',
+      DBInstanceNetType: 'string',
       port: 'string',
-      readDBInstances: { 'type': 'array', 'itemType': 'string' },
-      regionId: 'string',
-      status: 'string',
-      storageUsed: 'number',
-      type: 'string',
-      VPCId: 'string',
-      vSwitchId: 'string',
-      zoneId: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class TagResourcesRequestTag extends $tea.Model {
+  key?: string;
+  value?: string;
+  static names(): { [key: string]: string } {
+    return {
+      key: 'Key',
+      value: 'Value',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      key: 'string',
+      value: 'string',
     };
   }
 
@@ -6096,10 +6564,54 @@ export default class Client extends OpenApi {
 
   async allocateInstancePublicConnectionWithOptions(request: AllocateInstancePublicConnectionRequest, runtime: $Util.RuntimeOptions): Promise<AllocateInstancePublicConnectionResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.connectionStringPrefix)) {
+      query["ConnectionStringPrefix"] = request.connectionStringPrefix;
+    }
+
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.ownerAccount)) {
+      query["OwnerAccount"] = request.ownerAccount;
+    }
+
+    if (!Util.isUnset(request.ownerId)) {
+      query["OwnerId"] = request.ownerId;
+    }
+
+    if (!Util.isUnset(request.port)) {
+      query["Port"] = request.port;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.resourceOwnerAccount)) {
+      query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
+    }
+
+    if (!Util.isUnset(request.resourceOwnerId)) {
+      query["ResourceOwnerId"] = request.resourceOwnerId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<AllocateInstancePublicConnectionResponse>(await this.doRPCRequest("AllocateInstancePublicConnection", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new AllocateInstancePublicConnectionResponse({}));
+    let params = new $OpenApi.Params({
+      action: "AllocateInstancePublicConnection",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<AllocateInstancePublicConnectionResponse>(await this.callApi(params, req, runtime), new AllocateInstancePublicConnectionResponse({}));
   }
 
   async allocateInstancePublicConnection(request: AllocateInstancePublicConnectionRequest): Promise<AllocateInstancePublicConnectionResponse> {
@@ -6111,9 +6623,20 @@ export default class Client extends OpenApi {
     Util.validateModel(request);
     let query = OpenApiUtil.query(Util.toMap(request));
     let req = new $OpenApi.OpenApiRequest({
-      query: query,
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "CancelActiveOperationTasks",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "GET",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<CancelActiveOperationTasksResponse>(await this.doRPCRequest("CancelActiveOperationTasks", "2020-02-02", "HTTPS", "GET", "AK", "json", req, runtime), new CancelActiveOperationTasksResponse({}));
+    return $tea.cast<CancelActiveOperationTasksResponse>(await this.callApi(params, req, runtime), new CancelActiveOperationTasksResponse({}));
   }
 
   async cancelActiveOperationTasks(request: CancelActiveOperationTasksRequest): Promise<CancelActiveOperationTasksResponse> {
@@ -6121,25 +6644,77 @@ export default class Client extends OpenApi {
     return await this.cancelActiveOperationTasksWithOptions(request, runtime);
   }
 
-  async cancelPolarxOrderWithOptions(request: CancelPolarxOrderRequest, runtime: $Util.RuntimeOptions): Promise<CancelPolarxOrderResponse> {
+  async changeResourceGroupWithOptions(request: ChangeResourceGroupRequest, runtime: $Util.RuntimeOptions): Promise<ChangeResourceGroupResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.newResourceGroupId)) {
+      query["NewResourceGroupId"] = request.newResourceGroupId;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.resourceId)) {
+      query["ResourceId"] = request.resourceId;
+    }
+
+    if (!Util.isUnset(request.resourceType)) {
+      query["ResourceType"] = request.resourceType;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<CancelPolarxOrderResponse>(await this.doRPCRequest("CancelPolarxOrder", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new CancelPolarxOrderResponse({}));
+    let params = new $OpenApi.Params({
+      action: "ChangeResourceGroup",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<ChangeResourceGroupResponse>(await this.callApi(params, req, runtime), new ChangeResourceGroupResponse({}));
   }
 
-  async cancelPolarxOrder(request: CancelPolarxOrderRequest): Promise<CancelPolarxOrderResponse> {
+  async changeResourceGroup(request: ChangeResourceGroupRequest): Promise<ChangeResourceGroupResponse> {
     let runtime = new $Util.RuntimeOptions({ });
-    return await this.cancelPolarxOrderWithOptions(request, runtime);
+    return await this.changeResourceGroupWithOptions(request, runtime);
   }
 
   async checkCloudResourceAuthorizedWithOptions(request: CheckCloudResourceAuthorizedRequest, runtime: $Util.RuntimeOptions): Promise<CheckCloudResourceAuthorizedResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.roleArn)) {
+      query["RoleArn"] = request.roleArn;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "CheckCloudResourceAuthorized",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<CheckCloudResourceAuthorizedResponse>(await this.doRPCRequest("CheckCloudResourceAuthorized", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new CheckCloudResourceAuthorizedResponse({}));
+    return $tea.cast<CheckCloudResourceAuthorizedResponse>(await this.callApi(params, req, runtime), new CheckCloudResourceAuthorizedResponse({}));
   }
 
   async checkCloudResourceAuthorized(request: CheckCloudResourceAuthorizedRequest): Promise<CheckCloudResourceAuthorizedResponse> {
@@ -6149,10 +6724,58 @@ export default class Client extends OpenApi {
 
   async createAccountWithOptions(request: CreateAccountRequest, runtime: $Util.RuntimeOptions): Promise<CreateAccountResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.accountDescription)) {
+      query["AccountDescription"] = request.accountDescription;
+    }
+
+    if (!Util.isUnset(request.accountName)) {
+      query["AccountName"] = request.accountName;
+    }
+
+    if (!Util.isUnset(request.accountPassword)) {
+      query["AccountPassword"] = request.accountPassword;
+    }
+
+    if (!Util.isUnset(request.accountPrivilege)) {
+      query["AccountPrivilege"] = request.accountPrivilege;
+    }
+
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.DBName)) {
+      query["DBName"] = request.DBName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.securityAccountName)) {
+      query["SecurityAccountName"] = request.securityAccountName;
+    }
+
+    if (!Util.isUnset(request.securityAccountPassword)) {
+      query["SecurityAccountPassword"] = request.securityAccountPassword;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<CreateAccountResponse>(await this.doRPCRequest("CreateAccount", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new CreateAccountResponse({}));
+    let params = new $OpenApi.Params({
+      action: "CreateAccount",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<CreateAccountResponse>(await this.callApi(params, req, runtime), new CreateAccountResponse({}));
   }
 
   async createAccount(request: CreateAccountRequest): Promise<CreateAccountResponse> {
@@ -6162,10 +6785,34 @@ export default class Client extends OpenApi {
 
   async createBackupWithOptions(request: CreateBackupRequest, runtime: $Util.RuntimeOptions): Promise<CreateBackupResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.backupType)) {
+      query["BackupType"] = request.backupType;
+    }
+
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "CreateBackup",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<CreateBackupResponse>(await this.doRPCRequest("CreateBackup", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new CreateBackupResponse({}));
+    return $tea.cast<CreateBackupResponse>(await this.callApi(params, req, runtime), new CreateBackupResponse({}));
   }
 
   async createBackup(request: CreateBackupRequest): Promise<CreateBackupResponse> {
@@ -6175,10 +6822,58 @@ export default class Client extends OpenApi {
 
   async createDBWithOptions(request: CreateDBRequest, runtime: $Util.RuntimeOptions): Promise<CreateDBResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.accountName)) {
+      query["AccountName"] = request.accountName;
+    }
+
+    if (!Util.isUnset(request.accountPrivilege)) {
+      query["AccountPrivilege"] = request.accountPrivilege;
+    }
+
+    if (!Util.isUnset(request.charset)) {
+      query["Charset"] = request.charset;
+    }
+
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.dbDescription)) {
+      query["DbDescription"] = request.dbDescription;
+    }
+
+    if (!Util.isUnset(request.dbName)) {
+      query["DbName"] = request.dbName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.securityAccountName)) {
+      query["SecurityAccountName"] = request.securityAccountName;
+    }
+
+    if (!Util.isUnset(request.securityAccountPassword)) {
+      query["SecurityAccountPassword"] = request.securityAccountPassword;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<CreateDBResponse>(await this.doRPCRequest("CreateDB", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new CreateDBResponse({}));
+    let params = new $OpenApi.Params({
+      action: "CreateDB",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<CreateDBResponse>(await this.callApi(params, req, runtime), new CreateDBResponse({}));
   }
 
   async createDB(request: CreateDBRequest): Promise<CreateDBResponse> {
@@ -6188,10 +6883,102 @@ export default class Client extends OpenApi {
 
   async createDBInstanceWithOptions(request: CreateDBInstanceRequest, runtime: $Util.RuntimeOptions): Promise<CreateDBInstanceResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.autoRenew)) {
+      query["AutoRenew"] = request.autoRenew;
+    }
+
+    if (!Util.isUnset(request.clientToken)) {
+      query["ClientToken"] = request.clientToken;
+    }
+
+    if (!Util.isUnset(request.DBNodeClass)) {
+      query["DBNodeClass"] = request.DBNodeClass;
+    }
+
+    if (!Util.isUnset(request.DBNodeCount)) {
+      query["DBNodeCount"] = request.DBNodeCount;
+    }
+
+    if (!Util.isUnset(request.engineVersion)) {
+      query["EngineVersion"] = request.engineVersion;
+    }
+
+    if (!Util.isUnset(request.isReadDBInstance)) {
+      query["IsReadDBInstance"] = request.isReadDBInstance;
+    }
+
+    if (!Util.isUnset(request.networkType)) {
+      query["NetworkType"] = request.networkType;
+    }
+
+    if (!Util.isUnset(request.payType)) {
+      query["PayType"] = request.payType;
+    }
+
+    if (!Util.isUnset(request.period)) {
+      query["Period"] = request.period;
+    }
+
+    if (!Util.isUnset(request.primaryDBInstanceName)) {
+      query["PrimaryDBInstanceName"] = request.primaryDBInstanceName;
+    }
+
+    if (!Util.isUnset(request.primaryZone)) {
+      query["PrimaryZone"] = request.primaryZone;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.resourceGroupId)) {
+      query["ResourceGroupId"] = request.resourceGroupId;
+    }
+
+    if (!Util.isUnset(request.secondaryZone)) {
+      query["SecondaryZone"] = request.secondaryZone;
+    }
+
+    if (!Util.isUnset(request.tertiaryZone)) {
+      query["TertiaryZone"] = request.tertiaryZone;
+    }
+
+    if (!Util.isUnset(request.topologyType)) {
+      query["TopologyType"] = request.topologyType;
+    }
+
+    if (!Util.isUnset(request.usedTime)) {
+      query["UsedTime"] = request.usedTime;
+    }
+
+    if (!Util.isUnset(request.VPCId)) {
+      query["VPCId"] = request.VPCId;
+    }
+
+    if (!Util.isUnset(request.vSwitchId)) {
+      query["VSwitchId"] = request.vSwitchId;
+    }
+
+    if (!Util.isUnset(request.zoneId)) {
+      query["ZoneId"] = request.zoneId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "CreateDBInstance",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<CreateDBInstanceResponse>(await this.doRPCRequest("CreateDBInstance", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new CreateDBInstanceResponse({}));
+    return $tea.cast<CreateDBInstanceResponse>(await this.callApi(params, req, runtime), new CreateDBInstanceResponse({}));
   }
 
   async createDBInstance(request: CreateDBInstanceRequest): Promise<CreateDBInstanceResponse> {
@@ -6199,38 +6986,89 @@ export default class Client extends OpenApi {
     return await this.createDBInstanceWithOptions(request, runtime);
   }
 
-  async createPolarxOrderWithOptions(request: CreatePolarxOrderRequest, runtime: $Util.RuntimeOptions): Promise<CreatePolarxOrderResponse> {
+  async createSuperAccountWithOptions(request: CreateSuperAccountRequest, runtime: $Util.RuntimeOptions): Promise<CreateSuperAccountResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.accountDescription)) {
+      query["AccountDescription"] = request.accountDescription;
+    }
+
+    if (!Util.isUnset(request.accountName)) {
+      query["AccountName"] = request.accountName;
+    }
+
+    if (!Util.isUnset(request.accountPassword)) {
+      query["AccountPassword"] = request.accountPassword;
+    }
+
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "CreateSuperAccount",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<CreatePolarxOrderResponse>(await this.doRPCRequest("CreatePolarxOrder", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new CreatePolarxOrderResponse({}));
+    return $tea.cast<CreateSuperAccountResponse>(await this.callApi(params, req, runtime), new CreateSuperAccountResponse({}));
   }
 
-  async createPolarxOrder(request: CreatePolarxOrderRequest): Promise<CreatePolarxOrderResponse> {
+  async createSuperAccount(request: CreateSuperAccountRequest): Promise<CreateSuperAccountResponse> {
     let runtime = new $Util.RuntimeOptions({ });
-    return await this.createPolarxOrderWithOptions(request, runtime);
+    return await this.createSuperAccountWithOptions(request, runtime);
   }
 
-  async createSuperAccountWithOptions(request: CreateSuperAccountRequest, runtime: $Util.RuntimeOptions): Promise<CreateSuperAccountResponse> {
+  async deleteAccountWithOptions(request: DeleteAccountRequest, runtime: $Util.RuntimeOptions): Promise<DeleteAccountResponse> {
     Util.validateModel(request);
-    let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
-    });
-    return $tea.cast<CreateSuperAccountResponse>(await this.doRPCRequest("CreateSuperAccount", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new CreateSuperAccountResponse({}));
-  }
+    let query = { };
+    if (!Util.isUnset(request.accountName)) {
+      query["AccountName"] = request.accountName;
+    }
 
-  async createSuperAccount(request: CreateSuperAccountRequest): Promise<CreateSuperAccountResponse> {
-    let runtime = new $Util.RuntimeOptions({ });
-    return await this.createSuperAccountWithOptions(request, runtime);
-  }
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.securityAccountName)) {
+      query["SecurityAccountName"] = request.securityAccountName;
+    }
+
+    if (!Util.isUnset(request.securityAccountPassword)) {
+      query["SecurityAccountPassword"] = request.securityAccountPassword;
+    }
 
-  async deleteAccountWithOptions(request: DeleteAccountRequest, runtime: $Util.RuntimeOptions): Promise<DeleteAccountResponse> {
-    Util.validateModel(request);
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DeleteAccount",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DeleteAccountResponse>(await this.doRPCRequest("DeleteAccount", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DeleteAccountResponse({}));
+    return $tea.cast<DeleteAccountResponse>(await this.callApi(params, req, runtime), new DeleteAccountResponse({}));
   }
 
   async deleteAccount(request: DeleteAccountRequest): Promise<DeleteAccountResponse> {
@@ -6240,10 +7078,34 @@ export default class Client extends OpenApi {
 
   async deleteDBWithOptions(request: DeleteDBRequest, runtime: $Util.RuntimeOptions): Promise<DeleteDBResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.dbName)) {
+      query["DbName"] = request.dbName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<DeleteDBResponse>(await this.doRPCRequest("DeleteDB", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DeleteDBResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DeleteDB",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<DeleteDBResponse>(await this.callApi(params, req, runtime), new DeleteDBResponse({}));
   }
 
   async deleteDB(request: DeleteDBRequest): Promise<DeleteDBResponse> {
@@ -6253,10 +7115,30 @@ export default class Client extends OpenApi {
 
   async deleteDBInstanceWithOptions(request: DeleteDBInstanceRequest, runtime: $Util.RuntimeOptions): Promise<DeleteDBInstanceResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DeleteDBInstance",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DeleteDBInstanceResponse>(await this.doRPCRequest("DeleteDBInstance", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DeleteDBInstanceResponse({}));
+    return $tea.cast<DeleteDBInstanceResponse>(await this.callApi(params, req, runtime), new DeleteDBInstanceResponse({}));
   }
 
   async deleteDBInstance(request: DeleteDBInstanceRequest): Promise<DeleteDBInstanceResponse> {
@@ -6266,10 +7148,38 @@ export default class Client extends OpenApi {
 
   async describeAccountListWithOptions(request: DescribeAccountListRequest, runtime: $Util.RuntimeOptions): Promise<DescribeAccountListResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.accountName)) {
+      query["AccountName"] = request.accountName;
+    }
+
+    if (!Util.isUnset(request.accountType)) {
+      query["AccountType"] = request.accountType;
+    }
+
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DescribeAccountList",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DescribeAccountListResponse>(await this.doRPCRequest("DescribeAccountList", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeAccountListResponse({}));
+    return $tea.cast<DescribeAccountListResponse>(await this.callApi(params, req, runtime), new DescribeAccountListResponse({}));
   }
 
   async describeAccountList(request: DescribeAccountListRequest): Promise<DescribeAccountListResponse> {
@@ -6279,10 +7189,26 @@ export default class Client extends OpenApi {
 
   async describeActiveOperationMaintainConfWithOptions(request: DescribeActiveOperationMaintainConfRequest, runtime: $Util.RuntimeOptions): Promise<DescribeActiveOperationMaintainConfResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<DescribeActiveOperationMaintainConfResponse>(await this.doRPCRequest("DescribeActiveOperationMaintainConf", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeActiveOperationMaintainConfResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeActiveOperationMaintainConf",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeActiveOperationMaintainConfResponse>(await this.callApi(params, req, runtime), new DescribeActiveOperationMaintainConfResponse({}));
   }
 
   async describeActiveOperationMaintainConf(request: DescribeActiveOperationMaintainConfRequest): Promise<DescribeActiveOperationMaintainConfResponse> {
@@ -6294,9 +7220,20 @@ export default class Client extends OpenApi {
     Util.validateModel(request);
     let query = OpenApiUtil.query(Util.toMap(request));
     let req = new $OpenApi.OpenApiRequest({
-      query: query,
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DescribeActiveOperationTaskCount",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "GET",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DescribeActiveOperationTaskCountResponse>(await this.doRPCRequest("DescribeActiveOperationTaskCount", "2020-02-02", "HTTPS", "GET", "AK", "json", req, runtime), new DescribeActiveOperationTaskCountResponse({}));
+    return $tea.cast<DescribeActiveOperationTaskCountResponse>(await this.callApi(params, req, runtime), new DescribeActiveOperationTaskCountResponse({}));
   }
 
   async describeActiveOperationTaskCount(request: DescribeActiveOperationTaskCountRequest): Promise<DescribeActiveOperationTaskCountResponse> {
@@ -6304,12 +7241,57 @@ export default class Client extends OpenApi {
     return await this.describeActiveOperationTaskCountWithOptions(request, runtime);
   }
 
+  async describeActiveOperationTasksWithOptions(request: DescribeActiveOperationTasksRequest, runtime: $Util.RuntimeOptions): Promise<DescribeActiveOperationTasksResponse> {
+    Util.validateModel(request);
+    let query = OpenApiUtil.query(Util.toMap(request));
+    let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DescribeActiveOperationTasks",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "GET",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeActiveOperationTasksResponse>(await this.callApi(params, req, runtime), new DescribeActiveOperationTasksResponse({}));
+  }
+
+  async describeActiveOperationTasks(request: DescribeActiveOperationTasksRequest): Promise<DescribeActiveOperationTasksResponse> {
+    let runtime = new $Util.RuntimeOptions({ });
+    return await this.describeActiveOperationTasksWithOptions(request, runtime);
+  }
+
   async describeBackupPolicyWithOptions(request: DescribeBackupPolicyRequest, runtime: $Util.RuntimeOptions): Promise<DescribeBackupPolicyResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DescribeBackupPolicy",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DescribeBackupPolicyResponse>(await this.doRPCRequest("DescribeBackupPolicy", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeBackupPolicyResponse({}));
+    return $tea.cast<DescribeBackupPolicyResponse>(await this.callApi(params, req, runtime), new DescribeBackupPolicyResponse({}));
   }
 
   async describeBackupPolicy(request: DescribeBackupPolicyRequest): Promise<DescribeBackupPolicyResponse> {
@@ -6321,9 +7303,20 @@ export default class Client extends OpenApi {
     Util.validateModel(request);
     let query = OpenApiUtil.query(Util.toMap(request));
     let req = new $OpenApi.OpenApiRequest({
-      query: query,
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<DescribeBackupSetListResponse>(await this.doRPCRequest("DescribeBackupSetList", "2020-02-02", "HTTPS", "GET", "AK", "json", req, runtime), new DescribeBackupSetListResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeBackupSetList",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "GET",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeBackupSetListResponse>(await this.callApi(params, req, runtime), new DescribeBackupSetListResponse({}));
   }
 
   async describeBackupSetList(request: DescribeBackupSetListRequest): Promise<DescribeBackupSetListResponse> {
@@ -6333,10 +7326,46 @@ export default class Client extends OpenApi {
 
   async describeBinaryLogListWithOptions(request: DescribeBinaryLogListRequest, runtime: $Util.RuntimeOptions): Promise<DescribeBinaryLogListResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.endTime)) {
+      query["EndTime"] = request.endTime;
+    }
+
+    if (!Util.isUnset(request.pageNumber)) {
+      query["PageNumber"] = request.pageNumber;
+    }
+
+    if (!Util.isUnset(request.pageSize)) {
+      query["PageSize"] = request.pageSize;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.startTime)) {
+      query["StartTime"] = request.startTime;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<DescribeBinaryLogListResponse>(await this.doRPCRequest("DescribeBinaryLogList", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeBinaryLogListResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeBinaryLogList",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeBinaryLogListResponse>(await this.callApi(params, req, runtime), new DescribeBinaryLogListResponse({}));
   }
 
   async describeBinaryLogList(request: DescribeBinaryLogListRequest): Promise<DescribeBinaryLogListResponse> {
@@ -6346,10 +7375,30 @@ export default class Client extends OpenApi {
 
   async describeCharacterSetWithOptions(request: DescribeCharacterSetRequest, runtime: $Util.RuntimeOptions): Promise<DescribeCharacterSetResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DescribeCharacterSet",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DescribeCharacterSetResponse>(await this.doRPCRequest("DescribeCharacterSet", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeCharacterSetResponse({}));
+    return $tea.cast<DescribeCharacterSetResponse>(await this.callApi(params, req, runtime), new DescribeCharacterSetResponse({}));
   }
 
   async describeCharacterSet(request: DescribeCharacterSetRequest): Promise<DescribeCharacterSetResponse> {
@@ -6359,10 +7408,34 @@ export default class Client extends OpenApi {
 
   async describeDBInstanceAttributeWithOptions(request: DescribeDBInstanceAttributeRequest, runtime: $Util.RuntimeOptions): Promise<DescribeDBInstanceAttributeResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.resourceGroupId)) {
+      query["ResourceGroupId"] = request.resourceGroupId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<DescribeDBInstanceAttributeResponse>(await this.doRPCRequest("DescribeDBInstanceAttribute", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeDBInstanceAttributeResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeDBInstanceAttribute",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeDBInstanceAttributeResponse>(await this.callApi(params, req, runtime), new DescribeDBInstanceAttributeResponse({}));
   }
 
   async describeDBInstanceAttribute(request: DescribeDBInstanceAttributeRequest): Promise<DescribeDBInstanceAttributeResponse> {
@@ -6372,10 +7445,34 @@ export default class Client extends OpenApi {
 
   async describeDBInstanceConfigWithOptions(request: DescribeDBInstanceConfigRequest, runtime: $Util.RuntimeOptions): Promise<DescribeDBInstanceConfigResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.configName)) {
+      query["ConfigName"] = request.configName;
+    }
+
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DescribeDBInstanceConfig",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DescribeDBInstanceConfigResponse>(await this.doRPCRequest("DescribeDBInstanceConfig", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeDBInstanceConfigResponse({}));
+    return $tea.cast<DescribeDBInstanceConfigResponse>(await this.callApi(params, req, runtime), new DescribeDBInstanceConfigResponse({}));
   }
 
   async describeDBInstanceConfig(request: DescribeDBInstanceConfigRequest): Promise<DescribeDBInstanceConfigResponse> {
@@ -6385,10 +7482,30 @@ export default class Client extends OpenApi {
 
   async describeDBInstanceSSLWithOptions(request: DescribeDBInstanceSSLRequest, runtime: $Util.RuntimeOptions): Promise<DescribeDBInstanceSSLResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DescribeDBInstanceSSL",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DescribeDBInstanceSSLResponse>(await this.doRPCRequest("DescribeDBInstanceSSL", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeDBInstanceSSLResponse({}));
+    return $tea.cast<DescribeDBInstanceSSLResponse>(await this.callApi(params, req, runtime), new DescribeDBInstanceSSLResponse({}));
   }
 
   async describeDBInstanceSSL(request: DescribeDBInstanceSSLRequest): Promise<DescribeDBInstanceSSLResponse> {
@@ -6398,10 +7515,30 @@ export default class Client extends OpenApi {
 
   async describeDBInstanceTDEWithOptions(request: DescribeDBInstanceTDERequest, runtime: $Util.RuntimeOptions): Promise<DescribeDBInstanceTDEResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<DescribeDBInstanceTDEResponse>(await this.doRPCRequest("DescribeDBInstanceTDE", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeDBInstanceTDEResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeDBInstanceTDE",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeDBInstanceTDEResponse>(await this.callApi(params, req, runtime), new DescribeDBInstanceTDEResponse({}));
   }
 
   async describeDBInstanceTDE(request: DescribeDBInstanceTDERequest): Promise<DescribeDBInstanceTDEResponse> {
@@ -6411,10 +7548,30 @@ export default class Client extends OpenApi {
 
   async describeDBInstanceTopologyWithOptions(request: DescribeDBInstanceTopologyRequest, runtime: $Util.RuntimeOptions): Promise<DescribeDBInstanceTopologyResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DescribeDBInstanceTopology",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DescribeDBInstanceTopologyResponse>(await this.doRPCRequest("DescribeDBInstanceTopology", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeDBInstanceTopologyResponse({}));
+    return $tea.cast<DescribeDBInstanceTopologyResponse>(await this.callApi(params, req, runtime), new DescribeDBInstanceTopologyResponse({}));
   }
 
   async describeDBInstanceTopology(request: DescribeDBInstanceTopologyRequest): Promise<DescribeDBInstanceTopologyResponse> {
@@ -6424,10 +7581,46 @@ export default class Client extends OpenApi {
 
   async describeDBInstancesWithOptions(request: DescribeDBInstancesRequest, runtime: $Util.RuntimeOptions): Promise<DescribeDBInstancesResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.instanceId)) {
+      query["InstanceId"] = request.instanceId;
+    }
+
+    if (!Util.isUnset(request.pageNumber)) {
+      query["PageNumber"] = request.pageNumber;
+    }
+
+    if (!Util.isUnset(request.pageSize)) {
+      query["PageSize"] = request.pageSize;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.resourceGroupId)) {
+      query["ResourceGroupId"] = request.resourceGroupId;
+    }
+
+    if (!Util.isUnset(request.tags)) {
+      query["Tags"] = request.tags;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DescribeDBInstances",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DescribeDBInstancesResponse>(await this.doRPCRequest("DescribeDBInstances", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeDBInstancesResponse({}));
+    return $tea.cast<DescribeDBInstancesResponse>(await this.callApi(params, req, runtime), new DescribeDBInstancesResponse({}));
   }
 
   async describeDBInstances(request: DescribeDBInstancesRequest): Promise<DescribeDBInstancesResponse> {
@@ -6437,10 +7630,54 @@ export default class Client extends OpenApi {
 
   async describeDBNodePerformanceWithOptions(request: DescribeDBNodePerformanceRequest, runtime: $Util.RuntimeOptions): Promise<DescribeDBNodePerformanceResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.characterType)) {
+      query["CharacterType"] = request.characterType;
+    }
+
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.DBNodeIds)) {
+      query["DBNodeIds"] = request.DBNodeIds;
+    }
+
+    if (!Util.isUnset(request.DBNodeRole)) {
+      query["DBNodeRole"] = request.DBNodeRole;
+    }
+
+    if (!Util.isUnset(request.endTime)) {
+      query["EndTime"] = request.endTime;
+    }
+
+    if (!Util.isUnset(request.key)) {
+      query["Key"] = request.key;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.startTime)) {
+      query["StartTime"] = request.startTime;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DescribeDBNodePerformance",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DescribeDBNodePerformanceResponse>(await this.doRPCRequest("DescribeDBNodePerformance", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeDBNodePerformanceResponse({}));
+    return $tea.cast<DescribeDBNodePerformanceResponse>(await this.callApi(params, req, runtime), new DescribeDBNodePerformanceResponse({}));
   }
 
   async describeDBNodePerformance(request: DescribeDBNodePerformanceRequest): Promise<DescribeDBNodePerformanceResponse> {
@@ -6450,10 +7687,34 @@ export default class Client extends OpenApi {
 
   async describeDbListWithOptions(request: DescribeDbListRequest, runtime: $Util.RuntimeOptions): Promise<DescribeDbListResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.DBName)) {
+      query["DBName"] = request.DBName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<DescribeDbListResponse>(await this.doRPCRequest("DescribeDbList", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeDbListResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeDbList",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeDbListResponse>(await this.callApi(params, req, runtime), new DescribeDbListResponse({}));
   }
 
   async describeDbList(request: DescribeDbListRequest): Promise<DescribeDbListResponse> {
@@ -6463,10 +7724,34 @@ export default class Client extends OpenApi {
 
   async describeDistributeTableListWithOptions(request: DescribeDistributeTableListRequest, runtime: $Util.RuntimeOptions): Promise<DescribeDistributeTableListResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.dbName)) {
+      query["DbName"] = request.dbName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DescribeDistributeTableList",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DescribeDistributeTableListResponse>(await this.doRPCRequest("DescribeDistributeTableList", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeDistributeTableListResponse({}));
+    return $tea.cast<DescribeDistributeTableListResponse>(await this.callApi(params, req, runtime), new DescribeDistributeTableListResponse({}));
   }
 
   async describeDistributeTableList(request: DescribeDistributeTableListRequest): Promise<DescribeDistributeTableListResponse> {
@@ -6478,9 +7763,20 @@ export default class Client extends OpenApi {
     Util.validateModel(request);
     let query = OpenApiUtil.query(Util.toMap(request));
     let req = new $OpenApi.OpenApiRequest({
-      query: query,
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<DescribeEventsResponse>(await this.doRPCRequest("DescribeEvents", "2020-02-02", "HTTPS", "GET", "AK", "json", req, runtime), new DescribeEventsResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeEvents",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "GET",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeEventsResponse>(await this.callApi(params, req, runtime), new DescribeEventsResponse({}));
   }
 
   async describeEvents(request: DescribeEventsRequest): Promise<DescribeEventsResponse> {
@@ -6490,10 +7786,34 @@ export default class Client extends OpenApi {
 
   async describeParameterTemplatesWithOptions(request: DescribeParameterTemplatesRequest, runtime: $Util.RuntimeOptions): Promise<DescribeParameterTemplatesResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceId)) {
+      query["DBInstanceId"] = request.DBInstanceId;
+    }
+
+    if (!Util.isUnset(request.paramLevel)) {
+      query["ParamLevel"] = request.paramLevel;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<DescribeParameterTemplatesResponse>(await this.doRPCRequest("DescribeParameterTemplates", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeParameterTemplatesResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeParameterTemplates",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeParameterTemplatesResponse>(await this.callApi(params, req, runtime), new DescribeParameterTemplatesResponse({}));
   }
 
   async describeParameterTemplates(request: DescribeParameterTemplatesRequest): Promise<DescribeParameterTemplatesResponse> {
@@ -6503,10 +7823,34 @@ export default class Client extends OpenApi {
 
   async describeParametersWithOptions(request: DescribeParametersRequest, runtime: $Util.RuntimeOptions): Promise<DescribeParametersResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceId)) {
+      query["DBInstanceId"] = request.DBInstanceId;
+    }
+
+    if (!Util.isUnset(request.paramLevel)) {
+      query["ParamLevel"] = request.paramLevel;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DescribeParameters",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DescribeParametersResponse>(await this.doRPCRequest("DescribeParameters", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeParametersResponse({}));
+    return $tea.cast<DescribeParametersResponse>(await this.callApi(params, req, runtime), new DescribeParametersResponse({}));
   }
 
   async describeParameters(request: DescribeParametersRequest): Promise<DescribeParametersResponse> {
@@ -6514,74 +7858,249 @@ export default class Client extends OpenApi {
     return await this.describeParametersWithOptions(request, runtime);
   }
 
-  async describePolarxDataNodesWithOptions(request: DescribePolarxDataNodesRequest, runtime: $Util.RuntimeOptions): Promise<DescribePolarxDataNodesResponse> {
-    Util.validateModel(request);
-    let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+  async describeRegionsWithOptions(runtime: $Util.RuntimeOptions): Promise<DescribeRegionsResponse> {
+    let req = new $OpenApi.OpenApiRequest({ });
+    let params = new $OpenApi.Params({
+      action: "DescribeRegions",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DescribePolarxDataNodesResponse>(await this.doRPCRequest("DescribePolarxDataNodes", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribePolarxDataNodesResponse({}));
+    return $tea.cast<DescribeRegionsResponse>(await this.callApi(params, req, runtime), new DescribeRegionsResponse({}));
   }
 
-  async describePolarxDataNodes(request: DescribePolarxDataNodesRequest): Promise<DescribePolarxDataNodesResponse> {
+  async describeRegions(): Promise<DescribeRegionsResponse> {
     let runtime = new $Util.RuntimeOptions({ });
-    return await this.describePolarxDataNodesWithOptions(request, runtime);
+    return await this.describeRegionsWithOptions(runtime);
   }
 
-  async describePolarxDbInstancesWithOptions(request: DescribePolarxDbInstancesRequest, runtime: $Util.RuntimeOptions): Promise<DescribePolarxDbInstancesResponse> {
+  async describeScaleOutMigrateTaskListWithOptions(request: DescribeScaleOutMigrateTaskListRequest, runtime: $Util.RuntimeOptions): Promise<DescribeScaleOutMigrateTaskListResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.ownerAccount)) {
+      query["OwnerAccount"] = request.ownerAccount;
+    }
+
+    if (!Util.isUnset(request.ownerId)) {
+      query["OwnerId"] = request.ownerId;
+    }
+
+    if (!Util.isUnset(request.resourceOwnerAccount)) {
+      query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
+    }
+
+    if (!Util.isUnset(request.resourceOwnerId)) {
+      query["ResourceOwnerId"] = request.resourceOwnerId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DescribeScaleOutMigrateTaskList",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DescribePolarxDbInstancesResponse>(await this.doRPCRequest("DescribePolarxDbInstances", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribePolarxDbInstancesResponse({}));
+    return $tea.cast<DescribeScaleOutMigrateTaskListResponse>(await this.callApi(params, req, runtime), new DescribeScaleOutMigrateTaskListResponse({}));
   }
 
-  async describePolarxDbInstances(request: DescribePolarxDbInstancesRequest): Promise<DescribePolarxDbInstancesResponse> {
+  async describeScaleOutMigrateTaskList(request: DescribeScaleOutMigrateTaskListRequest): Promise<DescribeScaleOutMigrateTaskListResponse> {
     let runtime = new $Util.RuntimeOptions({ });
-    return await this.describePolarxDbInstancesWithOptions(request, runtime);
+    return await this.describeScaleOutMigrateTaskListWithOptions(request, runtime);
   }
 
-  async describeRegionsWithOptions(runtime: $Util.RuntimeOptions): Promise<DescribeRegionsResponse> {
-    let req = new $OpenApi.OpenApiRequest({ });
-    return $tea.cast<DescribeRegionsResponse>(await this.doRPCRequest("DescribeRegions", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeRegionsResponse({}));
+  async describeSecurityIpsWithOptions(request: DescribeSecurityIpsRequest, runtime: $Util.RuntimeOptions): Promise<DescribeSecurityIpsResponse> {
+    Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DescribeSecurityIps",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeSecurityIpsResponse>(await this.callApi(params, req, runtime), new DescribeSecurityIpsResponse({}));
   }
 
-  async describeRegions(): Promise<DescribeRegionsResponse> {
+  async describeSecurityIps(request: DescribeSecurityIpsRequest): Promise<DescribeSecurityIpsResponse> {
     let runtime = new $Util.RuntimeOptions({ });
-    return await this.describeRegionsWithOptions(runtime);
+    return await this.describeSecurityIpsWithOptions(request, runtime);
   }
 
-  async describeScaleOutMigrateTaskListWithOptions(request: DescribeScaleOutMigrateTaskListRequest, runtime: $Util.RuntimeOptions): Promise<DescribeScaleOutMigrateTaskListResponse> {
+  async describeSlinkTaskInfoWithOptions(request: DescribeSlinkTaskInfoRequest, runtime: $Util.RuntimeOptions): Promise<DescribeSlinkTaskInfoResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.failPageNumber)) {
+      query["FailPageNumber"] = request.failPageNumber;
+    }
+
+    if (!Util.isUnset(request.failPageSize)) {
+      query["FailPageSize"] = request.failPageSize;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.slinkTaskId)) {
+      query["SlinkTaskId"] = request.slinkTaskId;
+    }
+
+    if (!Util.isUnset(request.successPageNumber)) {
+      query["SuccessPageNumber"] = request.successPageNumber;
+    }
+
+    if (!Util.isUnset(request.successPageSize)) {
+      query["SuccessPageSize"] = request.successPageSize;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DescribeSlinkTaskInfo",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DescribeScaleOutMigrateTaskListResponse>(await this.doRPCRequest("DescribeScaleOutMigrateTaskList", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeScaleOutMigrateTaskListResponse({}));
+    return $tea.cast<DescribeSlinkTaskInfoResponse>(await this.callApi(params, req, runtime), new DescribeSlinkTaskInfoResponse({}));
   }
 
-  async describeScaleOutMigrateTaskList(request: DescribeScaleOutMigrateTaskListRequest): Promise<DescribeScaleOutMigrateTaskListResponse> {
+  async describeSlinkTaskInfo(request: DescribeSlinkTaskInfoRequest): Promise<DescribeSlinkTaskInfoResponse> {
     let runtime = new $Util.RuntimeOptions({ });
-    return await this.describeScaleOutMigrateTaskListWithOptions(request, runtime);
+    return await this.describeSlinkTaskInfoWithOptions(request, runtime);
   }
 
-  async describeSecurityIpsWithOptions(request: DescribeSecurityIpsRequest, runtime: $Util.RuntimeOptions): Promise<DescribeSecurityIpsResponse> {
+  async describeTagsWithOptions(request: DescribeTagsRequest, runtime: $Util.RuntimeOptions): Promise<DescribeTagsResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.tagKey)) {
+      query["TagKey"] = request.tagKey;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DescribeTags",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DescribeSecurityIpsResponse>(await this.doRPCRequest("DescribeSecurityIps", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeSecurityIpsResponse({}));
+    return $tea.cast<DescribeTagsResponse>(await this.callApi(params, req, runtime), new DescribeTagsResponse({}));
   }
 
-  async describeSecurityIps(request: DescribeSecurityIpsRequest): Promise<DescribeSecurityIpsResponse> {
+  async describeTags(request: DescribeTagsRequest): Promise<DescribeTagsResponse> {
     let runtime = new $Util.RuntimeOptions({ });
-    return await this.describeSecurityIpsWithOptions(request, runtime);
+    return await this.describeTagsWithOptions(request, runtime);
   }
 
   async describeTasksWithOptions(request: DescribeTasksRequest, runtime: $Util.RuntimeOptions): Promise<DescribeTasksResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceId)) {
+      query["DBInstanceId"] = request.DBInstanceId;
+    }
+
+    if (!Util.isUnset(request.endTime)) {
+      query["EndTime"] = request.endTime;
+    }
+
+    if (!Util.isUnset(request.ownerAccount)) {
+      query["OwnerAccount"] = request.ownerAccount;
+    }
+
+    if (!Util.isUnset(request.ownerId)) {
+      query["OwnerId"] = request.ownerId;
+    }
+
+    if (!Util.isUnset(request.pageNumber)) {
+      query["PageNumber"] = request.pageNumber;
+    }
+
+    if (!Util.isUnset(request.pageSize)) {
+      query["PageSize"] = request.pageSize;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.resourceOwnerAccount)) {
+      query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
+    }
+
+    if (!Util.isUnset(request.resourceOwnerId)) {
+      query["ResourceOwnerId"] = request.resourceOwnerId;
+    }
+
+    if (!Util.isUnset(request.startTime)) {
+      query["StartTime"] = request.startTime;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<DescribeTasksResponse>(await this.doRPCRequest("DescribeTasks", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeTasksResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeTasks",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeTasksResponse>(await this.callApi(params, req, runtime), new DescribeTasksResponse({}));
   }
 
   async describeTasks(request: DescribeTasksRequest): Promise<DescribeTasksResponse> {
@@ -6591,10 +8110,30 @@ export default class Client extends OpenApi {
 
   async describeUserEncryptionKeyListWithOptions(request: DescribeUserEncryptionKeyListRequest, runtime: $Util.RuntimeOptions): Promise<DescribeUserEncryptionKeyListResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DescribeUserEncryptionKeyList",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<DescribeUserEncryptionKeyListResponse>(await this.doRPCRequest("DescribeUserEncryptionKeyList", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeUserEncryptionKeyListResponse({}));
+    return $tea.cast<DescribeUserEncryptionKeyListResponse>(await this.callApi(params, req, runtime), new DescribeUserEncryptionKeyListResponse({}));
   }
 
   async describeUserEncryptionKeyList(request: DescribeUserEncryptionKeyListRequest): Promise<DescribeUserEncryptionKeyListResponse> {
@@ -6602,25 +8141,118 @@ export default class Client extends OpenApi {
     return await this.describeUserEncryptionKeyListWithOptions(request, runtime);
   }
 
-  async getPolarxCommodityWithOptions(request: GetPolarxCommodityRequest, runtime: $Util.RuntimeOptions): Promise<GetPolarxCommodityResponse> {
+  async initDBInstanceResourceGroupIdWithOptions(request: InitDBInstanceResourceGroupIdRequest, runtime: $Util.RuntimeOptions): Promise<InitDBInstanceResourceGroupIdResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<GetPolarxCommodityResponse>(await this.doRPCRequest("GetPolarxCommodity", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new GetPolarxCommodityResponse({}));
+    let params = new $OpenApi.Params({
+      action: "InitDBInstanceResourceGroupId",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<InitDBInstanceResourceGroupIdResponse>(await this.callApi(params, req, runtime), new InitDBInstanceResourceGroupIdResponse({}));
   }
 
-  async getPolarxCommodity(request: GetPolarxCommodityRequest): Promise<GetPolarxCommodityResponse> {
+  async initDBInstanceResourceGroupId(request: InitDBInstanceResourceGroupIdRequest): Promise<InitDBInstanceResourceGroupIdResponse> {
     let runtime = new $Util.RuntimeOptions({ });
-    return await this.getPolarxCommodityWithOptions(request, runtime);
+    return await this.initDBInstanceResourceGroupIdWithOptions(request, runtime);
+  }
+
+  async listTagResourcesWithOptions(request: ListTagResourcesRequest, runtime: $Util.RuntimeOptions): Promise<ListTagResourcesResponse> {
+    Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.nextToken)) {
+      query["NextToken"] = request.nextToken;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.resourceId)) {
+      query["ResourceId"] = request.resourceId;
+    }
+
+    if (!Util.isUnset(request.resourceType)) {
+      query["ResourceType"] = request.resourceType;
+    }
+
+    if (!Util.isUnset(request.tag)) {
+      query["Tag"] = request.tag;
+    }
+
+    let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "ListTagResources",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<ListTagResourcesResponse>(await this.callApi(params, req, runtime), new ListTagResourcesResponse({}));
+  }
+
+  async listTagResources(request: ListTagResourcesRequest): Promise<ListTagResourcesResponse> {
+    let runtime = new $Util.RuntimeOptions({ });
+    return await this.listTagResourcesWithOptions(request, runtime);
   }
 
   async modifyAccountDescriptionWithOptions(request: ModifyAccountDescriptionRequest, runtime: $Util.RuntimeOptions): Promise<ModifyAccountDescriptionResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.accountDescription)) {
+      query["AccountDescription"] = request.accountDescription;
+    }
+
+    if (!Util.isUnset(request.accountName)) {
+      query["AccountName"] = request.accountName;
+    }
+
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "ModifyAccountDescription",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<ModifyAccountDescriptionResponse>(await this.doRPCRequest("ModifyAccountDescription", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new ModifyAccountDescriptionResponse({}));
+    return $tea.cast<ModifyAccountDescriptionResponse>(await this.callApi(params, req, runtime), new ModifyAccountDescriptionResponse({}));
   }
 
   async modifyAccountDescription(request: ModifyAccountDescriptionRequest): Promise<ModifyAccountDescriptionResponse> {
@@ -6632,9 +8264,20 @@ export default class Client extends OpenApi {
     Util.validateModel(request);
     let query = OpenApiUtil.query(Util.toMap(request));
     let req = new $OpenApi.OpenApiRequest({
-      query: query,
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<ModifyActiveOperationMaintainConfResponse>(await this.doRPCRequest("ModifyActiveOperationMaintainConf", "2020-02-02", "HTTPS", "GET", "AK", "json", req, runtime), new ModifyActiveOperationMaintainConfResponse({}));
+    let params = new $OpenApi.Params({
+      action: "ModifyActiveOperationMaintainConf",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "GET",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<ModifyActiveOperationMaintainConfResponse>(await this.callApi(params, req, runtime), new ModifyActiveOperationMaintainConfResponse({}));
   }
 
   async modifyActiveOperationMaintainConf(request: ModifyActiveOperationMaintainConfRequest): Promise<ModifyActiveOperationMaintainConfResponse> {
@@ -6644,10 +8287,38 @@ export default class Client extends OpenApi {
 
   async modifyActiveOperationTasksWithOptions(request: ModifyActiveOperationTasksRequest, runtime: $Util.RuntimeOptions): Promise<ModifyActiveOperationTasksResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.ids)) {
+      query["Ids"] = request.ids;
+    }
+
+    if (!Util.isUnset(request.immediateStart)) {
+      query["ImmediateStart"] = request.immediateStart;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.switchTime)) {
+      query["SwitchTime"] = request.switchTime;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<ModifyActiveOperationTasksResponse>(await this.doRPCRequest("ModifyActiveOperationTasks", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new ModifyActiveOperationTasksResponse({}));
+    let params = new $OpenApi.Params({
+      action: "ModifyActiveOperationTasks",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<ModifyActiveOperationTasksResponse>(await this.callApi(params, req, runtime), new ModifyActiveOperationTasksResponse({}));
   }
 
   async modifyActiveOperationTasks(request: ModifyActiveOperationTasksRequest): Promise<ModifyActiveOperationTasksResponse> {
@@ -6657,10 +8328,38 @@ export default class Client extends OpenApi {
 
   async modifyDBInstanceClassWithOptions(request: ModifyDBInstanceClassRequest, runtime: $Util.RuntimeOptions): Promise<ModifyDBInstanceClassResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.clientToken)) {
+      query["ClientToken"] = request.clientToken;
+    }
+
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.targetDBInstanceClass)) {
+      query["TargetDBInstanceClass"] = request.targetDBInstanceClass;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "ModifyDBInstanceClass",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<ModifyDBInstanceClassResponse>(await this.doRPCRequest("ModifyDBInstanceClass", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new ModifyDBInstanceClassResponse({}));
+    return $tea.cast<ModifyDBInstanceClassResponse>(await this.callApi(params, req, runtime), new ModifyDBInstanceClassResponse({}));
   }
 
   async modifyDBInstanceClass(request: ModifyDBInstanceClassRequest): Promise<ModifyDBInstanceClassResponse> {
@@ -6670,10 +8369,38 @@ export default class Client extends OpenApi {
 
   async modifyDBInstanceConfigWithOptions(request: ModifyDBInstanceConfigRequest, runtime: $Util.RuntimeOptions): Promise<ModifyDBInstanceConfigResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.configName)) {
+      query["ConfigName"] = request.configName;
+    }
+
+    if (!Util.isUnset(request.configValue)) {
+      query["ConfigValue"] = request.configValue;
+    }
+
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "ModifyDBInstanceConfig",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<ModifyDBInstanceConfigResponse>(await this.doRPCRequest("ModifyDBInstanceConfig", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new ModifyDBInstanceConfigResponse({}));
+    return $tea.cast<ModifyDBInstanceConfigResponse>(await this.callApi(params, req, runtime), new ModifyDBInstanceConfigResponse({}));
   }
 
   async modifyDBInstanceConfig(request: ModifyDBInstanceConfigRequest): Promise<ModifyDBInstanceConfigResponse> {
@@ -6681,12 +8408,81 @@ export default class Client extends OpenApi {
     return await this.modifyDBInstanceConfigWithOptions(request, runtime);
   }
 
+  async modifyDBInstanceConnectionStringWithOptions(request: ModifyDBInstanceConnectionStringRequest, runtime: $Util.RuntimeOptions): Promise<ModifyDBInstanceConnectionStringResponse> {
+    Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.connectionString)) {
+      query["ConnectionString"] = request.connectionString;
+    }
+
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.newPort)) {
+      query["NewPort"] = request.newPort;
+    }
+
+    if (!Util.isUnset(request.newPrefix)) {
+      query["NewPrefix"] = request.newPrefix;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "ModifyDBInstanceConnectionString",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<ModifyDBInstanceConnectionStringResponse>(await this.callApi(params, req, runtime), new ModifyDBInstanceConnectionStringResponse({}));
+  }
+
+  async modifyDBInstanceConnectionString(request: ModifyDBInstanceConnectionStringRequest): Promise<ModifyDBInstanceConnectionStringResponse> {
+    let runtime = new $Util.RuntimeOptions({ });
+    return await this.modifyDBInstanceConnectionStringWithOptions(request, runtime);
+  }
+
   async modifyDBInstanceDescriptionWithOptions(request: ModifyDBInstanceDescriptionRequest, runtime: $Util.RuntimeOptions): Promise<ModifyDBInstanceDescriptionResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceDescription)) {
+      query["DBInstanceDescription"] = request.DBInstanceDescription;
+    }
+
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<ModifyDBInstanceDescriptionResponse>(await this.doRPCRequest("ModifyDBInstanceDescription", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new ModifyDBInstanceDescriptionResponse({}));
+    let params = new $OpenApi.Params({
+      action: "ModifyDBInstanceDescription",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<ModifyDBInstanceDescriptionResponse>(await this.callApi(params, req, runtime), new ModifyDBInstanceDescriptionResponse({}));
   }
 
   async modifyDBInstanceDescription(request: ModifyDBInstanceDescriptionRequest): Promise<ModifyDBInstanceDescriptionResponse> {
@@ -6696,10 +8492,38 @@ export default class Client extends OpenApi {
 
   async modifyDatabaseDescriptionWithOptions(request: ModifyDatabaseDescriptionRequest, runtime: $Util.RuntimeOptions): Promise<ModifyDatabaseDescriptionResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.dbDescription)) {
+      query["DbDescription"] = request.dbDescription;
+    }
+
+    if (!Util.isUnset(request.dbName)) {
+      query["DbName"] = request.dbName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "ModifyDatabaseDescription",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<ModifyDatabaseDescriptionResponse>(await this.doRPCRequest("ModifyDatabaseDescription", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new ModifyDatabaseDescriptionResponse({}));
+    return $tea.cast<ModifyDatabaseDescriptionResponse>(await this.callApi(params, req, runtime), new ModifyDatabaseDescriptionResponse({}));
   }
 
   async modifyDatabaseDescription(request: ModifyDatabaseDescriptionRequest): Promise<ModifyDatabaseDescriptionResponse> {
@@ -6709,10 +8533,42 @@ export default class Client extends OpenApi {
 
   async modifyParameterWithOptions(request: ModifyParameterRequest, runtime: $Util.RuntimeOptions): Promise<ModifyParameterResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.clientToken)) {
+      query["ClientToken"] = request.clientToken;
+    }
+
+    if (!Util.isUnset(request.DBInstanceId)) {
+      query["DBInstanceId"] = request.DBInstanceId;
+    }
+
+    if (!Util.isUnset(request.paramLevel)) {
+      query["ParamLevel"] = request.paramLevel;
+    }
+
+    if (!Util.isUnset(request.parameters)) {
+      query["Parameters"] = request.parameters;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "ModifyParameter",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<ModifyParameterResponse>(await this.doRPCRequest("ModifyParameter", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new ModifyParameterResponse({}));
+    return $tea.cast<ModifyParameterResponse>(await this.callApi(params, req, runtime), new ModifyParameterResponse({}));
   }
 
   async modifyParameter(request: ModifyParameterRequest): Promise<ModifyParameterResponse> {
@@ -6722,10 +8578,42 @@ export default class Client extends OpenApi {
 
   async modifySecurityIpsWithOptions(request: ModifySecurityIpsRequest, runtime: $Util.RuntimeOptions): Promise<ModifySecurityIpsResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.groupName)) {
+      query["GroupName"] = request.groupName;
+    }
+
+    if (!Util.isUnset(request.modifyMode)) {
+      query["ModifyMode"] = request.modifyMode;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.securityIPList)) {
+      query["SecurityIPList"] = request.securityIPList;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "ModifySecurityIps",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<ModifySecurityIpsResponse>(await this.doRPCRequest("ModifySecurityIps", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new ModifySecurityIpsResponse({}));
+    return $tea.cast<ModifySecurityIpsResponse>(await this.callApi(params, req, runtime), new ModifySecurityIpsResponse({}));
   }
 
   async modifySecurityIps(request: ModifySecurityIpsRequest): Promise<ModifySecurityIpsResponse> {
@@ -6735,10 +8623,50 @@ export default class Client extends OpenApi {
 
   async releaseInstancePublicConnectionWithOptions(request: ReleaseInstancePublicConnectionRequest, runtime: $Util.RuntimeOptions): Promise<ReleaseInstancePublicConnectionResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.currentConnectionString)) {
+      query["CurrentConnectionString"] = request.currentConnectionString;
+    }
+
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.ownerAccount)) {
+      query["OwnerAccount"] = request.ownerAccount;
+    }
+
+    if (!Util.isUnset(request.ownerId)) {
+      query["OwnerId"] = request.ownerId;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.resourceOwnerAccount)) {
+      query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
+    }
+
+    if (!Util.isUnset(request.resourceOwnerId)) {
+      query["ResourceOwnerId"] = request.resourceOwnerId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<ReleaseInstancePublicConnectionResponse>(await this.doRPCRequest("ReleaseInstancePublicConnection", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new ReleaseInstancePublicConnectionResponse({}));
+    let params = new $OpenApi.Params({
+      action: "ReleaseInstancePublicConnection",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<ReleaseInstancePublicConnectionResponse>(await this.callApi(params, req, runtime), new ReleaseInstancePublicConnectionResponse({}));
   }
 
   async releaseInstancePublicConnection(request: ReleaseInstancePublicConnectionRequest): Promise<ReleaseInstancePublicConnectionResponse> {
@@ -6748,10 +8676,30 @@ export default class Client extends OpenApi {
 
   async restartDBInstanceWithOptions(request: RestartDBInstanceRequest, runtime: $Util.RuntimeOptions): Promise<RestartDBInstanceResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "RestartDBInstance",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<RestartDBInstanceResponse>(await this.doRPCRequest("RestartDBInstance", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new RestartDBInstanceResponse({}));
+    return $tea.cast<RestartDBInstanceResponse>(await this.callApi(params, req, runtime), new RestartDBInstanceResponse({}));
   }
 
   async restartDBInstance(request: RestartDBInstanceRequest): Promise<RestartDBInstanceResponse> {
@@ -6759,12 +8707,158 @@ export default class Client extends OpenApi {
     return await this.restartDBInstanceWithOptions(request, runtime);
   }
 
+  async tagResourcesWithOptions(request: TagResourcesRequest, runtime: $Util.RuntimeOptions): Promise<TagResourcesResponse> {
+    Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.resourceId)) {
+      query["ResourceId"] = request.resourceId;
+    }
+
+    if (!Util.isUnset(request.resourceType)) {
+      query["ResourceType"] = request.resourceType;
+    }
+
+    if (!Util.isUnset(request.tag)) {
+      query["Tag"] = request.tag;
+    }
+
+    let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "TagResources",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<TagResourcesResponse>(await this.callApi(params, req, runtime), new TagResourcesResponse({}));
+  }
+
+  async tagResources(request: TagResourcesRequest): Promise<TagResourcesResponse> {
+    let runtime = new $Util.RuntimeOptions({ });
+    return await this.tagResourcesWithOptions(request, runtime);
+  }
+
+  async untagResourcesWithOptions(request: UntagResourcesRequest, runtime: $Util.RuntimeOptions): Promise<UntagResourcesResponse> {
+    Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.all)) {
+      query["All"] = request.all;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.resourceId)) {
+      query["ResourceId"] = request.resourceId;
+    }
+
+    if (!Util.isUnset(request.resourceType)) {
+      query["ResourceType"] = request.resourceType;
+    }
+
+    if (!Util.isUnset(request.tagKey)) {
+      query["TagKey"] = request.tagKey;
+    }
+
+    let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "UntagResources",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<UntagResourcesResponse>(await this.callApi(params, req, runtime), new UntagResourcesResponse({}));
+  }
+
+  async untagResources(request: UntagResourcesRequest): Promise<UntagResourcesResponse> {
+    let runtime = new $Util.RuntimeOptions({ });
+    return await this.untagResourcesWithOptions(request, runtime);
+  }
+
   async updateBackupPolicyWithOptions(request: UpdateBackupPolicyRequest, runtime: $Util.RuntimeOptions): Promise<UpdateBackupPolicyResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.backupPeriod)) {
+      query["BackupPeriod"] = request.backupPeriod;
+    }
+
+    if (!Util.isUnset(request.backupPlanBegin)) {
+      query["BackupPlanBegin"] = request.backupPlanBegin;
+    }
+
+    if (!Util.isUnset(request.backupSetRetention)) {
+      query["BackupSetRetention"] = request.backupSetRetention;
+    }
+
+    if (!Util.isUnset(request.backupType)) {
+      query["BackupType"] = request.backupType;
+    }
+
+    if (!Util.isUnset(request.backupWay)) {
+      query["BackupWay"] = request.backupWay;
+    }
+
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.forceCleanOnHighSpaceUsage)) {
+      query["ForceCleanOnHighSpaceUsage"] = request.forceCleanOnHighSpaceUsage;
+    }
+
+    if (!Util.isUnset(request.isEnabled)) {
+      query["IsEnabled"] = request.isEnabled;
+    }
+
+    if (!Util.isUnset(request.localLogRetention)) {
+      query["LocalLogRetention"] = request.localLogRetention;
+    }
+
+    if (!Util.isUnset(request.logLocalRetentionSpace)) {
+      query["LogLocalRetentionSpace"] = request.logLocalRetentionSpace;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.removeLogRetention)) {
+      query["RemoveLogRetention"] = request.removeLogRetention;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<UpdateBackupPolicyResponse>(await this.doRPCRequest("UpdateBackupPolicy", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new UpdateBackupPolicyResponse({}));
+    let params = new $OpenApi.Params({
+      action: "UpdateBackupPolicy",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<UpdateBackupPolicyResponse>(await this.callApi(params, req, runtime), new UpdateBackupPolicyResponse({}));
   }
 
   async updateBackupPolicy(request: UpdateBackupPolicyRequest): Promise<UpdateBackupPolicyResponse> {
@@ -6774,10 +8868,38 @@ export default class Client extends OpenApi {
 
   async updateDBInstanceSSLWithOptions(request: UpdateDBInstanceSSLRequest, runtime: $Util.RuntimeOptions): Promise<UpdateDBInstanceSSLResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.certCommonName)) {
+      query["CertCommonName"] = request.certCommonName;
+    }
+
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.enableSSL)) {
+      query["EnableSSL"] = request.enableSSL;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
     });
-    return $tea.cast<UpdateDBInstanceSSLResponse>(await this.doRPCRequest("UpdateDBInstanceSSL", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new UpdateDBInstanceSSLResponse({}));
+    let params = new $OpenApi.Params({
+      action: "UpdateDBInstanceSSL",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<UpdateDBInstanceSSLResponse>(await this.callApi(params, req, runtime), new UpdateDBInstanceSSLResponse({}));
   }
 
   async updateDBInstanceSSL(request: UpdateDBInstanceSSLRequest): Promise<UpdateDBInstanceSSLResponse> {
@@ -6787,10 +8909,42 @@ export default class Client extends OpenApi {
 
   async updateDBInstanceTDEWithOptions(request: UpdateDBInstanceTDERequest, runtime: $Util.RuntimeOptions): Promise<UpdateDBInstanceTDEResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.encryptionKey)) {
+      query["EncryptionKey"] = request.encryptionKey;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.roleArn)) {
+      query["RoleArn"] = request.roleArn;
+    }
+
+    if (!Util.isUnset(request.TDEStatus)) {
+      query["TDEStatus"] = request.TDEStatus;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "UpdateDBInstanceTDE",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<UpdateDBInstanceTDEResponse>(await this.doRPCRequest("UpdateDBInstanceTDE", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new UpdateDBInstanceTDEResponse({}));
+    return $tea.cast<UpdateDBInstanceTDEResponse>(await this.callApi(params, req, runtime), new UpdateDBInstanceTDEResponse({}));
   }
 
   async updateDBInstanceTDE(request: UpdateDBInstanceTDERequest): Promise<UpdateDBInstanceTDEResponse> {
@@ -6800,10 +8954,38 @@ export default class Client extends OpenApi {
 
   async updatePolarDBXInstanceNodeWithOptions(request: UpdatePolarDBXInstanceNodeRequest, runtime: $Util.RuntimeOptions): Promise<UpdatePolarDBXInstanceNodeResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.clientToken)) {
+      query["ClientToken"] = request.clientToken;
+    }
+
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.dbInstanceNodeCount)) {
+      query["DbInstanceNodeCount"] = request.dbInstanceNodeCount;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "UpdatePolarDBXInstanceNode",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<UpdatePolarDBXInstanceNodeResponse>(await this.doRPCRequest("UpdatePolarDBXInstanceNode", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new UpdatePolarDBXInstanceNodeResponse({}));
+    return $tea.cast<UpdatePolarDBXInstanceNodeResponse>(await this.callApi(params, req, runtime), new UpdatePolarDBXInstanceNodeResponse({}));
   }
 
   async updatePolarDBXInstanceNode(request: UpdatePolarDBXInstanceNodeRequest): Promise<UpdatePolarDBXInstanceNodeResponse> {
@@ -6813,10 +8995,34 @@ export default class Client extends OpenApi {
 
   async upgradeDBInstanceKernelVersionWithOptions(request: UpgradeDBInstanceKernelVersionRequest, runtime: $Util.RuntimeOptions): Promise<UpgradeDBInstanceKernelVersionResponse> {
     Util.validateModel(request);
+    let query = { };
+    if (!Util.isUnset(request.DBInstanceName)) {
+      query["DBInstanceName"] = request.DBInstanceName;
+    }
+
+    if (!Util.isUnset(request.regionId)) {
+      query["RegionId"] = request.regionId;
+    }
+
+    if (!Util.isUnset(request.switchMode)) {
+      query["SwitchMode"] = request.switchMode;
+    }
+
     let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "UpgradeDBInstanceKernelVersion",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
     });
-    return $tea.cast<UpgradeDBInstanceKernelVersionResponse>(await this.doRPCRequest("UpgradeDBInstanceKernelVersion", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new UpgradeDBInstanceKernelVersionResponse({}));
+    return $tea.cast<UpgradeDBInstanceKernelVersionResponse>(await this.callApi(params, req, runtime), new UpgradeDBInstanceKernelVersionResponse({}));
   }
 
   async upgradeDBInstanceKernelVersion(request: UpgradeDBInstanceKernelVersionRequest): Promise<UpgradeDBInstanceKernelVersionResponse> {