@alicloud/polardbx20200202 1.0.1 → 1.0.5

package/src/client.ts

@@ -89,6 +89,72 @@ export class AllocateInstancePublicConnectionResponse extends $tea.Model {
   }
 }
 
+export class CancelActiveOperationTasksRequest extends $tea.Model {
+  ids?: string;
+  regionId?: string;
+  static names(): { [key: string]: string } {
+    return {
+      ids: 'Ids',
+      regionId: 'RegionId',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      ids: 'string',
+      regionId: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class CancelActiveOperationTasksResponseBody extends $tea.Model {
+  ids?: string;
+  requestId?: string;
+  static names(): { [key: string]: string } {
+    return {
+      ids: 'Ids',
+      requestId: 'RequestId',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      ids: 'string',
+      requestId: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class CancelActiveOperationTasksResponse extends $tea.Model {
+  headers: { [key: string]: string };
+  body: CancelActiveOperationTasksResponseBody;
+  static names(): { [key: string]: string } {
+    return {
+      headers: 'headers',
+      body: 'body',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+      body: CancelActiveOperationTasksResponseBody,
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
 export class CancelPolarxOrderRequest extends $tea.Model {
   DBInstanceName?: string;
   regionId?: string;
@@ -590,120 +656,6 @@ export class CreateDBInstanceResponse extends $tea.Model {
   }
 }
 
-export class CreatePolarxInstanceRequest extends $tea.Model {
-  clientToken?: string;
-  description?: string;
-  duration?: number;
-  instanceSeries?: string;
-  isAutoRenew?: boolean;
-  masterInstId?: string;
-  mySQLVersion?: number;
-  payType?: string;
-  pricingCycle?: string;
-  quantity?: number;
-  regionId?: string;
-  specification?: string;
-  type?: string;
-  vpcId?: string;
-  vswitchId?: string;
-  zoneId?: string;
-  isHa?: boolean;
-  static names(): { [key: string]: string } {
-    return {
-      clientToken: 'ClientToken',
-      description: 'Description',
-      duration: 'Duration',
-      instanceSeries: 'InstanceSeries',
-      isAutoRenew: 'IsAutoRenew',
-      masterInstId: 'MasterInstId',
-      mySQLVersion: 'MySQLVersion',
-      payType: 'PayType',
-      pricingCycle: 'PricingCycle',
-      quantity: 'Quantity',
-      regionId: 'RegionId',
-      specification: 'Specification',
-      type: 'Type',
-      vpcId: 'VpcId',
-      vswitchId: 'VswitchId',
-      zoneId: 'ZoneId',
-      isHa: 'isHa',
-    };
-  }
-
-  static types(): { [key: string]: any } {
-    return {
-      clientToken: 'string',
-      description: 'string',
-      duration: 'number',
-      instanceSeries: 'string',
-      isAutoRenew: 'boolean',
-      masterInstId: 'string',
-      mySQLVersion: 'number',
-      payType: 'string',
-      pricingCycle: 'string',
-      quantity: 'number',
-      regionId: 'string',
-      specification: 'string',
-      type: 'string',
-      vpcId: 'string',
-      vswitchId: 'string',
-      zoneId: 'string',
-      isHa: 'boolean',
-    };
-  }
-
-  constructor(map?: { [key: string]: any }) {
-    super(map);
-  }
-}
-
-export class CreatePolarxInstanceResponseBody extends $tea.Model {
-  data?: CreatePolarxInstanceResponseBodyData;
-  requestId?: string;
-  success?: boolean;
-  static names(): { [key: string]: string } {
-    return {
-      data: 'Data',
-      requestId: 'RequestId',
-      success: 'Success',
-    };
-  }
-
-  static types(): { [key: string]: any } {
-    return {
-      data: CreatePolarxInstanceResponseBodyData,
-      requestId: 'string',
-      success: 'boolean',
-    };
-  }
-
-  constructor(map?: { [key: string]: any }) {
-    super(map);
-  }
-}
-
-export class CreatePolarxInstanceResponse extends $tea.Model {
-  headers: { [key: string]: string };
-  body: CreatePolarxInstanceResponseBody;
-  static names(): { [key: string]: string } {
-    return {
-      headers: 'headers',
-      body: 'body',
-    };
-  }
-
-  static types(): { [key: string]: any } {
-    return {
-      headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
-      body: CreatePolarxInstanceResponseBody,
-    };
-  }
-
-  constructor(map?: { [key: string]: any }) {
-    super(map);
-  }
-}
-
 export class CreatePolarxOrderRequest extends $tea.Model {
   DBInstanceName?: string;
   nodeCount?: string;
@@ -1142,6 +1094,249 @@ export class DescribeAccountListResponse extends $tea.Model {
   }
 }
 
+export class DescribeActiveOperationMaintainConfRequest extends $tea.Model {
+  regionId?: string;
+  static names(): { [key: string]: string } {
+    return {
+      regionId: 'RegionId',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      regionId: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class DescribeActiveOperationMaintainConfResponseBody extends $tea.Model {
+  config?: DescribeActiveOperationMaintainConfResponseBodyConfig;
+  hasConfig?: number;
+  requestId?: string;
+  static names(): { [key: string]: string } {
+    return {
+      config: 'Config',
+      hasConfig: 'HasConfig',
+      requestId: 'RequestId',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      config: DescribeActiveOperationMaintainConfResponseBodyConfig,
+      hasConfig: 'number',
+      requestId: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class DescribeActiveOperationMaintainConfResponse extends $tea.Model {
+  headers: { [key: string]: string };
+  body: DescribeActiveOperationMaintainConfResponseBody;
+  static names(): { [key: string]: string } {
+    return {
+      headers: 'headers',
+      body: 'body',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+      body: DescribeActiveOperationMaintainConfResponseBody,
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class DescribeActiveOperationTaskCountRequest extends $tea.Model {
+  category?: string;
+  product?: string;
+  regionId?: string;
+  static names(): { [key: string]: string } {
+    return {
+      category: 'Category',
+      product: 'Product',
+      regionId: 'RegionId',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      category: 'string',
+      product: 'string',
+      regionId: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class DescribeActiveOperationTaskCountResponseBody extends $tea.Model {
+  needPop?: number;
+  requestId?: string;
+  taskCount?: number;
+  static names(): { [key: string]: string } {
+    return {
+      needPop: 'NeedPop',
+      requestId: 'RequestId',
+      taskCount: 'TaskCount',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      needPop: 'number',
+      requestId: 'string',
+      taskCount: 'number',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class DescribeActiveOperationTaskCountResponse extends $tea.Model {
+  headers: { [key: string]: string };
+  body: DescribeActiveOperationTaskCountResponseBody;
+  static names(): { [key: string]: string } {
+    return {
+      headers: 'headers',
+      body: 'body',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+      body: DescribeActiveOperationTaskCountResponseBody,
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+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;
@@ -1872,6 +2067,7 @@ export class DescribeDBNodePerformanceRequest extends $tea.Model {
   characterType?: string;
   DBInstanceName?: string;
   DBNodeIds?: string;
+  DBNodeRole?: string;
   endTime?: string;
   key?: string;
   regionId?: string;
@@ -1881,6 +2077,7 @@ export class DescribeDBNodePerformanceRequest extends $tea.Model {
       characterType: 'CharacterType',
       DBInstanceName: 'DBInstanceName',
       DBNodeIds: 'DBNodeIds',
+      DBNodeRole: 'DBNodeRole',
       endTime: 'EndTime',
       key: 'Key',
       regionId: 'RegionId',
@@ -1893,6 +2090,7 @@ export class DescribeDBNodePerformanceRequest extends $tea.Model {
       characterType: 'string',
       DBInstanceName: 'string',
       DBNodeIds: 'string',
+      DBNodeRole: 'string',
       endTime: 'string',
       key: 'string',
       regionId: 'string',
@@ -2108,23 +2306,29 @@ export class DescribeDistributeTableListResponse extends $tea.Model {
   }
 }
 
-export class DescribeParameterTemplatesRequest extends $tea.Model {
-  DBInstanceId?: string;
-  paramLevel?: string;
+export class DescribeEventsRequest extends $tea.Model {
+  endTime?: string;
+  pageNumber?: number;
+  pageSize?: number;
   regionId?: string;
+  startTime?: string;
   static names(): { [key: string]: string } {
     return {
-      DBInstanceId: 'DBInstanceId',
-      paramLevel: 'ParamLevel',
+      endTime: 'EndTime',
+      pageNumber: 'PageNumber',
+      pageSize: 'PageSize',
       regionId: 'RegionId',
+      startTime: 'StartTime',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      DBInstanceId: 'string',
-      paramLevel: 'string',
+      endTime: 'string',
+      pageNumber: 'number',
+      pageSize: 'number',
       regionId: 'string',
+      startTime: 'string',
     };
   }
 
@@ -2133,20 +2337,29 @@ export class DescribeParameterTemplatesRequest extends $tea.Model {
   }
 }
 
-export class DescribeParameterTemplatesResponseBody extends $tea.Model {
-  data?: DescribeParameterTemplatesResponseBodyData;
+export class DescribeEventsResponseBody extends $tea.Model {
+  eventItems?: DescribeEventsResponseBodyEventItems[];
+  pageNumber?: number;
+  pageSize?: number;
   requestId?: string;
+  totalRecordCount?: number;
   static names(): { [key: string]: string } {
     return {
-      data: 'Data',
+      eventItems: 'EventItems',
+      pageNumber: 'PageNumber',
+      pageSize: 'PageSize',
       requestId: 'RequestId',
+      totalRecordCount: 'TotalRecordCount',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      data: DescribeParameterTemplatesResponseBodyData,
+      eventItems: { 'type': 'array', 'itemType': DescribeEventsResponseBodyEventItems },
+      pageNumber: 'number',
+      pageSize: 'number',
       requestId: 'string',
+      totalRecordCount: 'number',
     };
   }
 
@@ -2155,9 +2368,9 @@ export class DescribeParameterTemplatesResponseBody extends $tea.Model {
   }
 }
 
-export class DescribeParameterTemplatesResponse extends $tea.Model {
+export class DescribeEventsResponse extends $tea.Model {
   headers: { [key: string]: string };
-  body: DescribeParameterTemplatesResponseBody;
+  body: DescribeEventsResponseBody;
   static names(): { [key: string]: string } {
     return {
       headers: 'headers',
@@ -2168,7 +2381,7 @@ export class DescribeParameterTemplatesResponse extends $tea.Model {
   static types(): { [key: string]: any } {
     return {
       headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
-      body: DescribeParameterTemplatesResponseBody,
+      body: DescribeEventsResponseBody,
     };
   }
 
@@ -2177,7 +2390,7 @@ export class DescribeParameterTemplatesResponse extends $tea.Model {
   }
 }
 
-export class DescribeParametersRequest extends $tea.Model {
+export class DescribeParameterTemplatesRequest extends $tea.Model {
   DBInstanceId?: string;
   paramLevel?: string;
   regionId?: string;
@@ -2202,8 +2415,8 @@ export class DescribeParametersRequest extends $tea.Model {
   }
 }
 
-export class DescribeParametersResponseBody extends $tea.Model {
-  data?: DescribeParametersResponseBodyData;
+export class DescribeParameterTemplatesResponseBody extends $tea.Model {
+  data?: DescribeParameterTemplatesResponseBodyData;
   requestId?: string;
   static names(): { [key: string]: string } {
     return {
@@ -2214,7 +2427,7 @@ export class DescribeParametersResponseBody extends $tea.Model {
 
   static types(): { [key: string]: any } {
     return {
-      data: DescribeParametersResponseBodyData,
+      data: DescribeParameterTemplatesResponseBodyData,
       requestId: 'string',
     };
   }
@@ -2224,9 +2437,9 @@ export class DescribeParametersResponseBody extends $tea.Model {
   }
 }
 
-export class DescribeParametersResponse extends $tea.Model {
+export class DescribeParameterTemplatesResponse extends $tea.Model {
   headers: { [key: string]: string };
-  body: DescribeParametersResponseBody;
+  body: DescribeParameterTemplatesResponseBody;
   static names(): { [key: string]: string } {
     return {
       headers: 'headers',
@@ -2237,7 +2450,7 @@ export class DescribeParametersResponse extends $tea.Model {
   static types(): { [key: string]: any } {
     return {
       headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
-      body: DescribeParametersResponseBody,
+      body: DescribeParameterTemplatesResponseBody,
     };
   }
 
@@ -2246,22 +2459,22 @@ export class DescribeParametersResponse extends $tea.Model {
   }
 }
 
-export class DescribePolarxDataNodesRequest extends $tea.Model {
-  pageNumber?: number;
-  pageSize?: number;
+export class DescribeParametersRequest extends $tea.Model {
+  DBInstanceId?: string;
+  paramLevel?: string;
   regionId?: string;
   static names(): { [key: string]: string } {
     return {
-      pageNumber: 'PageNumber',
-      pageSize: 'PageSize',
+      DBInstanceId: 'DBInstanceId',
+      paramLevel: 'ParamLevel',
       regionId: 'RegionId',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      pageNumber: 'number',
-      pageSize: 'number',
+      DBInstanceId: 'string',
+      paramLevel: 'string',
       regionId: 'string',
     };
   }
@@ -2271,29 +2484,20 @@ export class DescribePolarxDataNodesRequest extends $tea.Model {
   }
 }
 
-export class DescribePolarxDataNodesResponseBody extends $tea.Model {
-  DBInstanceDataNodes?: DescribePolarxDataNodesResponseBodyDBInstanceDataNodes[];
-  pageNumber?: number;
-  pageSize?: number;
+export class DescribeParametersResponseBody extends $tea.Model {
+  data?: DescribeParametersResponseBodyData;
   requestId?: string;
-  totalNumber?: number;
   static names(): { [key: string]: string } {
     return {
-      DBInstanceDataNodes: 'DBInstanceDataNodes',
-      pageNumber: 'PageNumber',
-      pageSize: 'PageSize',
+      data: 'Data',
       requestId: 'RequestId',
-      totalNumber: 'TotalNumber',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      DBInstanceDataNodes: { 'type': 'array', 'itemType': DescribePolarxDataNodesResponseBodyDBInstanceDataNodes },
-      pageNumber: 'number',
-      pageSize: 'number',
+      data: DescribeParametersResponseBodyData,
       requestId: 'string',
-      totalNumber: 'number',
     };
   }
 
@@ -2302,9 +2506,9 @@ export class DescribePolarxDataNodesResponseBody extends $tea.Model {
   }
 }
 
-export class DescribePolarxDataNodesResponse extends $tea.Model {
+export class DescribeParametersResponse extends $tea.Model {
   headers: { [key: string]: string };
-  body: DescribePolarxDataNodesResponseBody;
+  body: DescribeParametersResponseBody;
   static names(): { [key: string]: string } {
     return {
       headers: 'headers',
@@ -2315,7 +2519,7 @@ export class DescribePolarxDataNodesResponse extends $tea.Model {
   static types(): { [key: string]: any } {
     return {
       headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
-      body: DescribePolarxDataNodesResponseBody,
+      body: DescribeParametersResponseBody,
     };
   }
 
@@ -2324,26 +2528,23 @@ export class DescribePolarxDataNodesResponse extends $tea.Model {
   }
 }
 
-export class DescribePolarxDbInstancesRequest extends $tea.Model {
-  dbName?: string;
-  drdsInstanceId?: string;
+export class DescribePolarxDataNodesRequest extends $tea.Model {
   pageNumber?: number;
   pageSize?: number;
+  regionId?: string;
   static names(): { [key: string]: string } {
     return {
-      dbName: 'DbName',
-      drdsInstanceId: 'DrdsInstanceId',
       pageNumber: 'PageNumber',
       pageSize: 'PageSize',
+      regionId: 'RegionId',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      dbName: 'string',
-      drdsInstanceId: 'string',
       pageNumber: 'number',
       pageSize: 'number',
+      regionId: 'string',
     };
   }
 
@@ -2352,32 +2553,29 @@ export class DescribePolarxDbInstancesRequest extends $tea.Model {
   }
 }
 
-export class DescribePolarxDbInstancesResponseBody extends $tea.Model {
-  dbInstances?: DescribePolarxDbInstancesResponseBodyDbInstances;
-  pageNumber?: string;
-  pageSize?: string;
+export class DescribePolarxDataNodesResponseBody extends $tea.Model {
+  DBInstanceDataNodes?: DescribePolarxDataNodesResponseBodyDBInstanceDataNodes[];
+  pageNumber?: number;
+  pageSize?: number;
   requestId?: string;
-  success?: boolean;
-  total?: string;
+  totalNumber?: number;
   static names(): { [key: string]: string } {
     return {
-      dbInstances: 'DbInstances',
+      DBInstanceDataNodes: 'DBInstanceDataNodes',
       pageNumber: 'PageNumber',
       pageSize: 'PageSize',
       requestId: 'RequestId',
-      success: 'Success',
-      total: 'Total',
+      totalNumber: 'TotalNumber',
     };
   }
 
   static types(): { [key: string]: any } {
-    return {
-      dbInstances: DescribePolarxDbInstancesResponseBodyDbInstances,
-      pageNumber: 'string',
-      pageSize: 'string',
+    return {
+      DBInstanceDataNodes: { 'type': 'array', 'itemType': DescribePolarxDataNodesResponseBodyDBInstanceDataNodes },
+      pageNumber: 'number',
+      pageSize: 'number',
       requestId: 'string',
-      success: 'boolean',
-      total: 'string',
+      totalNumber: 'number',
     };
   }
 
@@ -2386,9 +2584,9 @@ export class DescribePolarxDbInstancesResponseBody extends $tea.Model {
   }
 }
 
-export class DescribePolarxDbInstancesResponse extends $tea.Model {
+export class DescribePolarxDataNodesResponse extends $tea.Model {
   headers: { [key: string]: string };
-  body: DescribePolarxDbInstancesResponseBody;
+  body: DescribePolarxDataNodesResponseBody;
   static names(): { [key: string]: string } {
     return {
       headers: 'headers',
@@ -2399,7 +2597,7 @@ export class DescribePolarxDbInstancesResponse extends $tea.Model {
   static types(): { [key: string]: any } {
     return {
       headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
-      body: DescribePolarxDbInstancesResponseBody,
+      body: DescribePolarxDataNodesResponseBody,
     };
   }
 
@@ -2408,26 +2606,26 @@ export class DescribePolarxDbInstancesResponse extends $tea.Model {
   }
 }
 
-export class DescribePolarxPgInstancesRequest extends $tea.Model {
+export class DescribePolarxDbInstancesRequest extends $tea.Model {
+  dbName?: string;
+  drdsInstanceId?: string;
   pageNumber?: number;
   pageSize?: number;
-  regionId?: string;
-  resourceGroupId?: string;
   static names(): { [key: string]: string } {
     return {
+      dbName: 'DbName',
+      drdsInstanceId: 'DrdsInstanceId',
       pageNumber: 'PageNumber',
       pageSize: 'PageSize',
-      regionId: 'RegionId',
-      resourceGroupId: 'ResourceGroupId',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
+      dbName: 'string',
+      drdsInstanceId: 'string',
       pageNumber: 'number',
       pageSize: 'number',
-      regionId: 'string',
-      resourceGroupId: 'string',
     };
   }
 
@@ -2436,29 +2634,32 @@ export class DescribePolarxPgInstancesRequest extends $tea.Model {
   }
 }
 
-export class DescribePolarxPgInstancesResponseBody extends $tea.Model {
-  DBInstances?: DescribePolarxPgInstancesResponseBodyDBInstances[];
-  expireDate?: string;
-  pageNumber?: number;
-  pageSize?: number;
+export class DescribePolarxDbInstancesResponseBody extends $tea.Model {
+  dbInstances?: DescribePolarxDbInstancesResponseBodyDbInstances;
+  pageNumber?: string;
+  pageSize?: string;
   requestId?: string;
+  success?: boolean;
+  total?: string;
   static names(): { [key: string]: string } {
     return {
-      DBInstances: 'DBInstances',
-      expireDate: 'ExpireDate',
+      dbInstances: 'DbInstances',
       pageNumber: 'PageNumber',
       pageSize: 'PageSize',
       requestId: 'RequestId',
+      success: 'Success',
+      total: 'Total',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      DBInstances: { 'type': 'array', 'itemType': DescribePolarxPgInstancesResponseBodyDBInstances },
-      expireDate: 'string',
-      pageNumber: 'number',
-      pageSize: 'number',
+      dbInstances: DescribePolarxDbInstancesResponseBodyDbInstances,
+      pageNumber: 'string',
+      pageSize: 'string',
       requestId: 'string',
+      success: 'boolean',
+      total: 'string',
     };
   }
 
@@ -2467,9 +2668,9 @@ export class DescribePolarxPgInstancesResponseBody extends $tea.Model {
   }
 }
 
-export class DescribePolarxPgInstancesResponse extends $tea.Model {
+export class DescribePolarxDbInstancesResponse extends $tea.Model {
   headers: { [key: string]: string };
-  body: DescribePolarxPgInstancesResponseBody;
+  body: DescribePolarxDbInstancesResponseBody;
   static names(): { [key: string]: string } {
     return {
       headers: 'headers',
@@ -2480,7 +2681,7 @@ export class DescribePolarxPgInstancesResponse extends $tea.Model {
   static types(): { [key: string]: any } {
     return {
       headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
-      body: DescribePolarxPgInstancesResponseBody,
+      body: DescribePolarxDbInstancesResponseBody,
     };
   }
 
@@ -2703,8 +2904,6 @@ export class DescribeTasksRequest extends $tea.Model {
   resourceOwnerAccount?: string;
   resourceOwnerId?: number;
   startTime?: string;
-  status?: string;
-  taskAction?: string;
   static names(): { [key: string]: string } {
     return {
       DBInstanceId: 'DBInstanceId',
@@ -2717,8 +2916,6 @@ export class DescribeTasksRequest extends $tea.Model {
       resourceOwnerAccount: 'ResourceOwnerAccount',
       resourceOwnerId: 'ResourceOwnerId',
       startTime: 'StartTime',
-      status: 'Status',
-      taskAction: 'TaskAction',
     };
   }
 
@@ -2734,8 +2931,6 @@ export class DescribeTasksRequest extends $tea.Model {
       resourceOwnerAccount: 'string',
       resourceOwnerId: 'number',
       startTime: 'string',
-      status: 'string',
-      taskAction: 'string',
     };
   }
 
@@ -3010,6 +3205,153 @@ export class ModifyAccountDescriptionResponse extends $tea.Model {
   }
 }
 
+export class ModifyActiveOperationMaintainConfRequest extends $tea.Model {
+  cycleTime?: string;
+  cycleType?: string;
+  maintainEndTime?: string;
+  maintainStartTime?: string;
+  regionId?: string;
+  status?: number;
+  static names(): { [key: string]: string } {
+    return {
+      cycleTime: 'CycleTime',
+      cycleType: 'CycleType',
+      maintainEndTime: 'MaintainEndTime',
+      maintainStartTime: 'MaintainStartTime',
+      regionId: 'RegionId',
+      status: 'Status',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      cycleTime: 'string',
+      cycleType: 'string',
+      maintainEndTime: 'string',
+      maintainStartTime: 'string',
+      regionId: 'string',
+      status: 'number',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class ModifyActiveOperationMaintainConfResponseBody 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 ModifyActiveOperationMaintainConfResponse extends $tea.Model {
+  headers: { [key: string]: string };
+  body: ModifyActiveOperationMaintainConfResponseBody;
+  static names(): { [key: string]: string } {
+    return {
+      headers: 'headers',
+      body: 'body',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+      body: ModifyActiveOperationMaintainConfResponseBody,
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class ModifyActiveOperationTasksRequest extends $tea.Model {
+  ids?: string;
+  immediateStart?: number;
+  regionId?: string;
+  switchTime?: string;
+  static names(): { [key: string]: string } {
+    return {
+      ids: 'Ids',
+      immediateStart: 'ImmediateStart',
+      regionId: 'RegionId',
+      switchTime: 'SwitchTime',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      ids: 'string',
+      immediateStart: 'number',
+      regionId: 'string',
+      switchTime: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class ModifyActiveOperationTasksResponseBody extends $tea.Model {
+  ids?: string;
+  requestId?: string;
+  static names(): { [key: string]: string } {
+    return {
+      ids: 'Ids',
+      requestId: 'RequestId',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      ids: 'string',
+      requestId: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class ModifyActiveOperationTasksResponse extends $tea.Model {
+  headers: { [key: string]: string };
+  body: ModifyActiveOperationTasksResponseBody;
+  static names(): { [key: string]: string } {
+    return {
+      headers: 'headers',
+      body: 'body',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+      body: ModifyActiveOperationTasksResponseBody,
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
 export class ModifyDBInstanceClassRequest extends $tea.Model {
   clientToken?: string;
   DBInstanceName?: string;
@@ -3907,14 +4249,10 @@ export class UpdatePolarDBXInstanceNodeResponse extends $tea.Model {
 export class UpgradeDBInstanceKernelVersionRequest extends $tea.Model {
   DBInstanceName?: string;
   regionId?: string;
-  switchTime?: string;
-  upgradeTime?: string;
   static names(): { [key: string]: string } {
     return {
       DBInstanceName: 'DBInstanceName',
       regionId: 'RegionId',
-      switchTime: 'SwitchTime',
-      upgradeTime: 'UpgradeTime',
     };
   }
 
@@ -3922,8 +4260,6 @@ export class UpgradeDBInstanceKernelVersionRequest extends $tea.Model {
     return {
       DBInstanceName: 'string',
       regionId: 'string',
-      switchTime: 'string',
-      upgradeTime: 'string',
     };
   }
 
@@ -4023,17 +4359,20 @@ export class CreateBackupResponseBodyData extends $tea.Model {
   }
 }
 
-export class CreatePolarxInstanceResponseBodyDataDrdsInstanceIdList extends $tea.Model {
-  drdsInstanceIdList?: string[];
+export class CreatePolarxOrderResponseBodyOrderResultList extends $tea.Model {
+  DBInstanceName?: string;
+  orderId?: number;
   static names(): { [key: string]: string } {
     return {
-      drdsInstanceIdList: 'drdsInstanceIdList',
+      DBInstanceName: 'DBInstanceName',
+      orderId: 'OrderId',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      drdsInstanceIdList: { 'type': 'array', 'itemType': 'string' },
+      DBInstanceName: 'string',
+      orderId: 'number',
     };
   }
 
@@ -4042,20 +4381,35 @@ export class CreatePolarxInstanceResponseBodyDataDrdsInstanceIdList extends $tea
   }
 }
 
-export class CreatePolarxInstanceResponseBodyData extends $tea.Model {
-  drdsInstanceIdList?: CreatePolarxInstanceResponseBodyDataDrdsInstanceIdList;
-  orderId?: number;
+export class DescribeAccountListResponseBodyData extends $tea.Model {
+  accountDescription?: string;
+  accountName?: string;
+  accountPrivilege?: string;
+  accountType?: string;
+  DBInstanceName?: string;
+  DBName?: string;
+  gmtCreated?: string;
   static names(): { [key: string]: string } {
     return {
-      drdsInstanceIdList: 'DrdsInstanceIdList',
-      orderId: 'OrderId',
+      accountDescription: 'AccountDescription',
+      accountName: 'AccountName',
+      accountPrivilege: 'AccountPrivilege',
+      accountType: 'AccountType',
+      DBInstanceName: 'DBInstanceName',
+      DBName: 'DBName',
+      gmtCreated: 'GmtCreated',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      drdsInstanceIdList: CreatePolarxInstanceResponseBodyDataDrdsInstanceIdList,
-      orderId: 'number',
+      accountDescription: 'string',
+      accountName: 'string',
+      accountPrivilege: 'string',
+      accountType: 'string',
+      DBInstanceName: 'string',
+      DBName: 'string',
+      gmtCreated: 'string',
     };
   }
 
@@ -4064,20 +4418,35 @@ export class CreatePolarxInstanceResponseBodyData extends $tea.Model {
   }
 }
 
-export class CreatePolarxOrderResponseBodyOrderResultList extends $tea.Model {
-  DBInstanceName?: string;
-  orderId?: number;
+export class DescribeActiveOperationMaintainConfResponseBodyConfig extends $tea.Model {
+  createdTime?: string;
+  cycleTime?: string;
+  cycleType?: string;
+  maintainEndTime?: string;
+  maintainStartTime?: string;
+  modifiedTime?: string;
+  status?: number;
   static names(): { [key: string]: string } {
     return {
-      DBInstanceName: 'DBInstanceName',
-      orderId: 'OrderId',
+      createdTime: 'CreatedTime',
+      cycleTime: 'CycleTime',
+      cycleType: 'CycleType',
+      maintainEndTime: 'MaintainEndTime',
+      maintainStartTime: 'MaintainStartTime',
+      modifiedTime: 'ModifiedTime',
+      status: 'Status',
     };
   }
 
   static types(): { [key: string]: any } {
     return {
-      DBInstanceName: 'string',
-      orderId: 'number',
+      createdTime: 'string',
+      cycleTime: 'string',
+      cycleType: 'string',
+      maintainEndTime: 'string',
+      maintainStartTime: 'string',
+      modifiedTime: 'string',
+      status: 'number',
     };
   }
 
@@ -4086,35 +4455,95 @@ export class CreatePolarxOrderResponseBodyOrderResultList extends $tea.Model {
   }
 }
 
-export class DescribeAccountListResponseBodyData extends $tea.Model {
-  accountDescription?: string;
-  accountName?: string;
-  accountPrivilege?: string;
-  accountType?: string;
-  DBInstanceName?: string;
-  DBName?: string;
-  gmtCreated?: string;
-  static names(): { [key: string]: string } {
-    return {
-      accountDescription: 'AccountDescription',
-      accountName: 'AccountName',
-      accountPrivilege: 'AccountPrivilege',
-      accountType: 'AccountType',
-      DBInstanceName: 'DBInstanceName',
-      DBName: 'DBName',
-      gmtCreated: 'GmtCreated',
+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 {
-      accountDescription: 'string',
-      accountName: 'string',
-      accountPrivilege: 'string',
-      accountType: 'string',
-      DBInstanceName: 'string',
-      DBName: 'string',
-      gmtCreated: 'string',
+      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',
     };
   }
 
@@ -4282,7 +4711,7 @@ export class DescribeCharacterSetResponseBodyData extends $tea.Model {
 
 export class DescribeDBInstanceAttributeResponseBodyDBInstanceConnAddrs extends $tea.Model {
   connectionString?: string;
-  port?: string;
+  port?: number;
   type?: string;
   VPCId?: string;
   vSwitchId?: string;
@@ -4299,7 +4728,7 @@ export class DescribeDBInstanceAttributeResponseBodyDBInstanceConnAddrs extends
   static types(): { [key: string]: any } {
     return {
       connectionString: 'string',
-      port: 'string',
+      port: 'number',
       type: 'string',
       VPCId: 'string',
       vSwitchId: 'string',
@@ -5011,6 +5440,55 @@ export class DescribeDistributeTableListResponseBodyData extends $tea.Model {
   }
 }
 
+export class DescribeEventsResponseBodyEventItems extends $tea.Model {
+  eventId?: number;
+  eventName?: string;
+  eventPayload?: string;
+  eventReason?: string;
+  eventRecordTime?: string;
+  eventTime?: string;
+  eventType?: string;
+  eventUserType?: string;
+  regionId?: string;
+  resourceName?: string;
+  resourceType?: string;
+  static names(): { [key: string]: string } {
+    return {
+      eventId: 'EventId',
+      eventName: 'EventName',
+      eventPayload: 'EventPayload',
+      eventReason: 'EventReason',
+      eventRecordTime: 'EventRecordTime',
+      eventTime: 'EventTime',
+      eventType: 'EventType',
+      eventUserType: 'EventUserType',
+      regionId: 'RegionId',
+      resourceName: 'ResourceName',
+      resourceType: 'ResourceType',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      eventId: 'number',
+      eventName: 'string',
+      eventPayload: 'string',
+      eventReason: 'string',
+      eventRecordTime: 'string',
+      eventTime: 'string',
+      eventType: 'string',
+      eventUserType: 'string',
+      regionId: 'string',
+      resourceName: 'string',
+      resourceType: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
 export class DescribeParameterTemplatesResponseBodyDataParameters extends $tea.Model {
   checkingCode?: string;
   dynamic?: number;
@@ -5268,82 +5746,6 @@ export class DescribePolarxDbInstancesResponseBodyDbInstances extends $tea.Model
   }
 }
 
-export class DescribePolarxPgInstancesResponseBodyDBInstances extends $tea.Model {
-  commodityCode?: string;
-  createTime?: string;
-  DBType?: string;
-  DBVersion?: string;
-  description?: string;
-  engine?: string;
-  expireTime?: string;
-  expired?: boolean;
-  id?: string;
-  lockMode?: string;
-  lockReason?: string;
-  network?: string;
-  nodeClass?: string;
-  nodeCount?: number;
-  payType?: string;
-  regionId?: string;
-  status?: string;
-  storageUsed?: number;
-  VPCId?: string;
-  zoneId?: string;
-  static names(): { [key: string]: string } {
-    return {
-      commodityCode: 'CommodityCode',
-      createTime: 'CreateTime',
-      DBType: 'DBType',
-      DBVersion: 'DBVersion',
-      description: 'Description',
-      engine: 'Engine',
-      expireTime: 'ExpireTime',
-      expired: 'Expired',
-      id: 'Id',
-      lockMode: 'LockMode',
-      lockReason: 'LockReason',
-      network: 'Network',
-      nodeClass: 'NodeClass',
-      nodeCount: 'NodeCount',
-      payType: 'PayType',
-      regionId: 'RegionId',
-      status: 'Status',
-      storageUsed: 'StorageUsed',
-      VPCId: 'VPCId',
-      zoneId: 'ZoneId',
-    };
-  }
-
-  static types(): { [key: string]: any } {
-    return {
-      commodityCode: 'string',
-      createTime: 'string',
-      DBType: 'string',
-      DBVersion: 'string',
-      description: 'string',
-      engine: 'string',
-      expireTime: 'string',
-      expired: 'boolean',
-      id: 'string',
-      lockMode: 'string',
-      lockReason: 'string',
-      network: 'string',
-      nodeClass: 'string',
-      nodeCount: 'number',
-      payType: 'string',
-      regionId: 'string',
-      status: 'string',
-      storageUsed: 'number',
-      VPCId: 'string',
-      zoneId: 'string',
-    };
-  }
-
-  constructor(map?: { [key: string]: any }) {
-    super(map);
-  }
-}
-
 export class DescribeRegionsResponseBodyRegionsRegionZonesZone extends $tea.Model {
   vpcEnabled?: boolean;
   zoneId?: string;
@@ -5896,10 +6298,31 @@ export default class Client extends OpenApi {
 
   async allocateInstancePublicConnectionWithOptions(request: AllocateInstancePublicConnectionRequest, runtime: $Util.RuntimeOptions): Promise<AllocateInstancePublicConnectionResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["ConnectionStringPrefix"] = request.connectionStringPrefix;
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["OwnerAccount"] = request.ownerAccount;
+    query["OwnerId"] = request.ownerId;
+    query["Port"] = request.port;
+    query["RegionId"] = request.regionId;
+    query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
+    query["ResourceOwnerId"] = request.resourceOwnerId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    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: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<AllocateInstancePublicConnectionResponse>(await this.callApi(params, req, runtime), new AllocateInstancePublicConnectionResponse({}));
   }
 
   async allocateInstancePublicConnection(request: AllocateInstancePublicConnectionRequest): Promise<AllocateInstancePublicConnectionResponse> {
@@ -5907,12 +6330,53 @@ export default class Client extends OpenApi {
     return await this.allocateInstancePublicConnectionWithOptions(request, runtime);
   }
 
+  async cancelActiveOperationTasksWithOptions(request: CancelActiveOperationTasksRequest, runtime: $Util.RuntimeOptions): Promise<CancelActiveOperationTasksResponse> {
+    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: "CancelActiveOperationTasks",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "GET",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<CancelActiveOperationTasksResponse>(await this.callApi(params, req, runtime), new CancelActiveOperationTasksResponse({}));
+  }
+
+  async cancelActiveOperationTasks(request: CancelActiveOperationTasksRequest): Promise<CancelActiveOperationTasksResponse> {
+    let runtime = new $Util.RuntimeOptions({ });
+    return await this.cancelActiveOperationTasksWithOptions(request, runtime);
+  }
+
   async cancelPolarxOrderWithOptions(request: CancelPolarxOrderRequest, runtime: $Util.RuntimeOptions): Promise<CancelPolarxOrderResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
+    query["ScaleOutToken"] = request.scaleOutToken;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    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: "CancelPolarxOrder",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<CancelPolarxOrderResponse>(await this.callApi(params, req, runtime), new CancelPolarxOrderResponse({}));
   }
 
   async cancelPolarxOrder(request: CancelPolarxOrderRequest): Promise<CancelPolarxOrderResponse> {
@@ -5922,10 +6386,26 @@ export default class Client extends OpenApi {
 
   async checkCloudResourceAuthorizedWithOptions(request: CheckCloudResourceAuthorizedRequest, runtime: $Util.RuntimeOptions): Promise<CheckCloudResourceAuthorizedResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
+    query["RoleArn"] = request.roleArn;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<CheckCloudResourceAuthorizedResponse>(await this.doRPCRequest("CheckCloudResourceAuthorized", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new CheckCloudResourceAuthorizedResponse({}));
+    let params = new $OpenApi.Params({
+      action: "CheckCloudResourceAuthorized",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<CheckCloudResourceAuthorizedResponse>(await this.callApi(params, req, runtime), new CheckCloudResourceAuthorizedResponse({}));
   }
 
   async checkCloudResourceAuthorized(request: CheckCloudResourceAuthorizedRequest): Promise<CheckCloudResourceAuthorizedResponse> {
@@ -5935,10 +6415,32 @@ export default class Client extends OpenApi {
 
   async createAccountWithOptions(request: CreateAccountRequest, runtime: $Util.RuntimeOptions): Promise<CreateAccountResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["AccountDescription"] = request.accountDescription;
+    query["AccountName"] = request.accountName;
+    query["AccountPassword"] = request.accountPassword;
+    query["AccountPrivilege"] = request.accountPrivilege;
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["DBName"] = request.DBName;
+    query["RegionId"] = request.regionId;
+    query["SecurityAccountName"] = request.securityAccountName;
+    query["SecurityAccountPassword"] = request.securityAccountPassword;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    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: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<CreateAccountResponse>(await this.callApi(params, req, runtime), new CreateAccountResponse({}));
   }
 
   async createAccount(request: CreateAccountRequest): Promise<CreateAccountResponse> {
@@ -5948,10 +6450,26 @@ export default class Client extends OpenApi {
 
   async createBackupWithOptions(request: CreateBackupRequest, runtime: $Util.RuntimeOptions): Promise<CreateBackupResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["BackupType"] = request.backupType;
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<CreateBackupResponse>(await this.doRPCRequest("CreateBackup", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new CreateBackupResponse({}));
+    let params = new $OpenApi.Params({
+      action: "CreateBackup",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<CreateBackupResponse>(await this.callApi(params, req, runtime), new CreateBackupResponse({}));
   }
 
   async createBackup(request: CreateBackupRequest): Promise<CreateBackupResponse> {
@@ -5961,10 +6479,32 @@ export default class Client extends OpenApi {
 
   async createDBWithOptions(request: CreateDBRequest, runtime: $Util.RuntimeOptions): Promise<CreateDBResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["AccountName"] = request.accountName;
+    query["AccountPrivilege"] = request.accountPrivilege;
+    query["Charset"] = request.charset;
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["DbDescription"] = request.dbDescription;
+    query["DbName"] = request.dbName;
+    query["RegionId"] = request.regionId;
+    query["SecurityAccountName"] = request.securityAccountName;
+    query["SecurityAccountPassword"] = request.securityAccountPassword;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    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: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<CreateDBResponse>(await this.callApi(params, req, runtime), new CreateDBResponse({}));
   }
 
   async createDB(request: CreateDBRequest): Promise<CreateDBResponse> {
@@ -5974,10 +6514,39 @@ export default class Client extends OpenApi {
 
   async createDBInstanceWithOptions(request: CreateDBInstanceRequest, runtime: $Util.RuntimeOptions): Promise<CreateDBInstanceResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["AutoRenew"] = request.autoRenew;
+    query["ClientToken"] = request.clientToken;
+    query["DBNodeClass"] = request.DBNodeClass;
+    query["DBNodeCount"] = request.DBNodeCount;
+    query["EngineVersion"] = request.engineVersion;
+    query["IsReadDBInstance"] = request.isReadDBInstance;
+    query["NetworkType"] = request.networkType;
+    query["PayType"] = request.payType;
+    query["Period"] = request.period;
+    query["PrimaryDBInstanceName"] = request.primaryDBInstanceName;
+    query["RegionId"] = request.regionId;
+    query["ResourceGroupId"] = request.resourceGroupId;
+    query["UsedTime"] = request.usedTime;
+    query["VPCId"] = request.VPCId;
+    query["VSwitchId"] = request.vSwitchId;
+    query["ZoneId"] = request.zoneId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<CreateDBInstanceResponse>(await this.doRPCRequest("CreateDBInstance", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new CreateDBInstanceResponse({}));
+    let params = new $OpenApi.Params({
+      action: "CreateDBInstance",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<CreateDBInstanceResponse>(await this.callApi(params, req, runtime), new CreateDBInstanceResponse({}));
   }
 
   async createDBInstance(request: CreateDBInstanceRequest): Promise<CreateDBInstanceResponse> {
@@ -5985,25 +6554,28 @@ export default class Client extends OpenApi {
     return await this.createDBInstanceWithOptions(request, runtime);
   }
 
-  async createPolarxInstanceWithOptions(request: CreatePolarxInstanceRequest, runtime: $Util.RuntimeOptions): Promise<CreatePolarxInstanceResponse> {
-    Util.validateModel(request);
-    let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
-    });
-    return $tea.cast<CreatePolarxInstanceResponse>(await this.doRPCRequest("CreatePolarxInstance", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new CreatePolarxInstanceResponse({}));
-  }
-
-  async createPolarxInstance(request: CreatePolarxInstanceRequest): Promise<CreatePolarxInstanceResponse> {
-    let runtime = new $Util.RuntimeOptions({ });
-    return await this.createPolarxInstanceWithOptions(request, runtime);
-  }
-
   async createPolarxOrderWithOptions(request: CreatePolarxOrderRequest, runtime: $Util.RuntimeOptions): Promise<CreatePolarxOrderResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["NodeCount"] = request.nodeCount;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<CreatePolarxOrderResponse>(await this.doRPCRequest("CreatePolarxOrder", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new CreatePolarxOrderResponse({}));
+    let params = new $OpenApi.Params({
+      action: "CreatePolarxOrder",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<CreatePolarxOrderResponse>(await this.callApi(params, req, runtime), new CreatePolarxOrderResponse({}));
   }
 
   async createPolarxOrder(request: CreatePolarxOrderRequest): Promise<CreatePolarxOrderResponse> {
@@ -6013,10 +6585,28 @@ export default class Client extends OpenApi {
 
   async createSuperAccountWithOptions(request: CreateSuperAccountRequest, runtime: $Util.RuntimeOptions): Promise<CreateSuperAccountResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["AccountDescription"] = request.accountDescription;
+    query["AccountName"] = request.accountName;
+    query["AccountPassword"] = request.accountPassword;
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<CreateSuperAccountResponse>(await this.doRPCRequest("CreateSuperAccount", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new CreateSuperAccountResponse({}));
+    let params = new $OpenApi.Params({
+      action: "CreateSuperAccount",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<CreateSuperAccountResponse>(await this.callApi(params, req, runtime), new CreateSuperAccountResponse({}));
   }
 
   async createSuperAccount(request: CreateSuperAccountRequest): Promise<CreateSuperAccountResponse> {
@@ -6026,10 +6616,28 @@ export default class Client extends OpenApi {
 
   async deleteAccountWithOptions(request: DeleteAccountRequest, runtime: $Util.RuntimeOptions): Promise<DeleteAccountResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["AccountName"] = request.accountName;
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
+    query["SecurityAccountName"] = request.securityAccountName;
+    query["SecurityAccountPassword"] = request.securityAccountPassword;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<DeleteAccountResponse>(await this.doRPCRequest("DeleteAccount", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DeleteAccountResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DeleteAccount",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DeleteAccountResponse>(await this.callApi(params, req, runtime), new DeleteAccountResponse({}));
   }
 
   async deleteAccount(request: DeleteAccountRequest): Promise<DeleteAccountResponse> {
@@ -6039,10 +6647,26 @@ export default class Client extends OpenApi {
 
   async deleteDBWithOptions(request: DeleteDBRequest, runtime: $Util.RuntimeOptions): Promise<DeleteDBResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["DbName"] = request.dbName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    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: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DeleteDBResponse>(await this.callApi(params, req, runtime), new DeleteDBResponse({}));
   }
 
   async deleteDB(request: DeleteDBRequest): Promise<DeleteDBResponse> {
@@ -6052,10 +6676,25 @@ export default class Client extends OpenApi {
 
   async deleteDBInstanceWithOptions(request: DeleteDBInstanceRequest, runtime: $Util.RuntimeOptions): Promise<DeleteDBInstanceResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<DeleteDBInstanceResponse>(await this.doRPCRequest("DeleteDBInstance", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DeleteDBInstanceResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DeleteDBInstance",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DeleteDBInstanceResponse>(await this.callApi(params, req, runtime), new DeleteDBInstanceResponse({}));
   }
 
   async deleteDBInstance(request: DeleteDBInstanceRequest): Promise<DeleteDBInstanceResponse> {
@@ -6065,10 +6704,27 @@ export default class Client extends OpenApi {
 
   async describeAccountListWithOptions(request: DescribeAccountListRequest, runtime: $Util.RuntimeOptions): Promise<DescribeAccountListResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["AccountName"] = request.accountName;
+    query["AccountType"] = request.accountType;
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<DescribeAccountListResponse>(await this.doRPCRequest("DescribeAccountList", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeAccountListResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeAccountList",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeAccountListResponse>(await this.callApi(params, req, runtime), new DescribeAccountListResponse({}));
   }
 
   async describeAccountList(request: DescribeAccountListRequest): Promise<DescribeAccountListResponse> {
@@ -6076,12 +6732,104 @@ export default class Client extends OpenApi {
     return await this.describeAccountListWithOptions(request, runtime);
   }
 
+  async describeActiveOperationMaintainConfWithOptions(request: DescribeActiveOperationMaintainConfRequest, runtime: $Util.RuntimeOptions): Promise<DescribeActiveOperationMaintainConfResponse> {
+    Util.validateModel(request);
+    let query = { };
+    query["RegionId"] = request.regionId;
+    let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
+      body: Util.toMap(request),
+    });
+    let params = new $OpenApi.Params({
+      action: "DescribeActiveOperationMaintainConf",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeActiveOperationMaintainConfResponse>(await this.callApi(params, req, runtime), new DescribeActiveOperationMaintainConfResponse({}));
+  }
+
+  async describeActiveOperationMaintainConf(request: DescribeActiveOperationMaintainConfRequest): Promise<DescribeActiveOperationMaintainConfResponse> {
+    let runtime = new $Util.RuntimeOptions({ });
+    return await this.describeActiveOperationMaintainConfWithOptions(request, runtime);
+  }
+
+  async describeActiveOperationTaskCountWithOptions(request: DescribeActiveOperationTaskCountRequest, runtime: $Util.RuntimeOptions): Promise<DescribeActiveOperationTaskCountResponse> {
+    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: "DescribeActiveOperationTaskCount",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "GET",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeActiveOperationTaskCountResponse>(await this.callApi(params, req, runtime), new DescribeActiveOperationTaskCountResponse({}));
+  }
+
+  async describeActiveOperationTaskCount(request: DescribeActiveOperationTaskCountRequest): Promise<DescribeActiveOperationTaskCountResponse> {
+    let runtime = new $Util.RuntimeOptions({ });
+    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: "json",
+      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 = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<DescribeBackupPolicyResponse>(await this.doRPCRequest("DescribeBackupPolicy", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeBackupPolicyResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeBackupPolicy",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeBackupPolicyResponse>(await this.callApi(params, req, runtime), new DescribeBackupPolicyResponse({}));
   }
 
   async describeBackupPolicy(request: DescribeBackupPolicyRequest): Promise<DescribeBackupPolicyResponse> {
@@ -6093,9 +6841,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: "DescribeBackupSetList",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "GET",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
     });
-    return $tea.cast<DescribeBackupSetListResponse>(await this.doRPCRequest("DescribeBackupSetList", "2020-02-02", "HTTPS", "GET", "AK", "json", req, runtime), new DescribeBackupSetListResponse({}));
+    return $tea.cast<DescribeBackupSetListResponse>(await this.callApi(params, req, runtime), new DescribeBackupSetListResponse({}));
   }
 
   async describeBackupSetList(request: DescribeBackupSetListRequest): Promise<DescribeBackupSetListResponse> {
@@ -6105,10 +6864,29 @@ export default class Client extends OpenApi {
 
   async describeBinaryLogListWithOptions(request: DescribeBinaryLogListRequest, runtime: $Util.RuntimeOptions): Promise<DescribeBinaryLogListResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["EndTime"] = request.endTime;
+    query["PageNumber"] = request.pageNumber;
+    query["PageSize"] = request.pageSize;
+    query["RegionId"] = request.regionId;
+    query["StartTime"] = request.startTime;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    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: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeBinaryLogListResponse>(await this.callApi(params, req, runtime), new DescribeBinaryLogListResponse({}));
   }
 
   async describeBinaryLogList(request: DescribeBinaryLogListRequest): Promise<DescribeBinaryLogListResponse> {
@@ -6118,10 +6896,25 @@ export default class Client extends OpenApi {
 
   async describeCharacterSetWithOptions(request: DescribeCharacterSetRequest, runtime: $Util.RuntimeOptions): Promise<DescribeCharacterSetResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<DescribeCharacterSetResponse>(await this.doRPCRequest("DescribeCharacterSet", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeCharacterSetResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeCharacterSet",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeCharacterSetResponse>(await this.callApi(params, req, runtime), new DescribeCharacterSetResponse({}));
   }
 
   async describeCharacterSet(request: DescribeCharacterSetRequest): Promise<DescribeCharacterSetResponse> {
@@ -6131,10 +6924,25 @@ export default class Client extends OpenApi {
 
   async describeDBInstanceAttributeWithOptions(request: DescribeDBInstanceAttributeRequest, runtime: $Util.RuntimeOptions): Promise<DescribeDBInstanceAttributeResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    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: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeDBInstanceAttributeResponse>(await this.callApi(params, req, runtime), new DescribeDBInstanceAttributeResponse({}));
   }
 
   async describeDBInstanceAttribute(request: DescribeDBInstanceAttributeRequest): Promise<DescribeDBInstanceAttributeResponse> {
@@ -6144,10 +6952,26 @@ export default class Client extends OpenApi {
 
   async describeDBInstanceConfigWithOptions(request: DescribeDBInstanceConfigRequest, runtime: $Util.RuntimeOptions): Promise<DescribeDBInstanceConfigResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["ConfigName"] = request.configName;
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<DescribeDBInstanceConfigResponse>(await this.doRPCRequest("DescribeDBInstanceConfig", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeDBInstanceConfigResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeDBInstanceConfig",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeDBInstanceConfigResponse>(await this.callApi(params, req, runtime), new DescribeDBInstanceConfigResponse({}));
   }
 
   async describeDBInstanceConfig(request: DescribeDBInstanceConfigRequest): Promise<DescribeDBInstanceConfigResponse> {
@@ -6157,10 +6981,25 @@ export default class Client extends OpenApi {
 
   async describeDBInstanceSSLWithOptions(request: DescribeDBInstanceSSLRequest, runtime: $Util.RuntimeOptions): Promise<DescribeDBInstanceSSLResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<DescribeDBInstanceSSLResponse>(await this.doRPCRequest("DescribeDBInstanceSSL", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeDBInstanceSSLResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeDBInstanceSSL",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeDBInstanceSSLResponse>(await this.callApi(params, req, runtime), new DescribeDBInstanceSSLResponse({}));
   }
 
   async describeDBInstanceSSL(request: DescribeDBInstanceSSLRequest): Promise<DescribeDBInstanceSSLResponse> {
@@ -6170,10 +7009,25 @@ export default class Client extends OpenApi {
 
   async describeDBInstanceTDEWithOptions(request: DescribeDBInstanceTDERequest, runtime: $Util.RuntimeOptions): Promise<DescribeDBInstanceTDEResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    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: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeDBInstanceTDEResponse>(await this.callApi(params, req, runtime), new DescribeDBInstanceTDEResponse({}));
   }
 
   async describeDBInstanceTDE(request: DescribeDBInstanceTDERequest): Promise<DescribeDBInstanceTDEResponse> {
@@ -6183,10 +7037,25 @@ export default class Client extends OpenApi {
 
   async describeDBInstanceTopologyWithOptions(request: DescribeDBInstanceTopologyRequest, runtime: $Util.RuntimeOptions): Promise<DescribeDBInstanceTopologyResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<DescribeDBInstanceTopologyResponse>(await this.doRPCRequest("DescribeDBInstanceTopology", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeDBInstanceTopologyResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeDBInstanceTopology",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeDBInstanceTopologyResponse>(await this.callApi(params, req, runtime), new DescribeDBInstanceTopologyResponse({}));
   }
 
   async describeDBInstanceTopology(request: DescribeDBInstanceTopologyRequest): Promise<DescribeDBInstanceTopologyResponse> {
@@ -6196,10 +7065,26 @@ export default class Client extends OpenApi {
 
   async describeDBInstancesWithOptions(request: DescribeDBInstancesRequest, runtime: $Util.RuntimeOptions): Promise<DescribeDBInstancesResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["PageNumber"] = request.pageNumber;
+    query["PageSize"] = request.pageSize;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<DescribeDBInstancesResponse>(await this.doRPCRequest("DescribeDBInstances", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeDBInstancesResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeDBInstances",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeDBInstancesResponse>(await this.callApi(params, req, runtime), new DescribeDBInstancesResponse({}));
   }
 
   async describeDBInstances(request: DescribeDBInstancesRequest): Promise<DescribeDBInstancesResponse> {
@@ -6209,10 +7094,31 @@ export default class Client extends OpenApi {
 
   async describeDBNodePerformanceWithOptions(request: DescribeDBNodePerformanceRequest, runtime: $Util.RuntimeOptions): Promise<DescribeDBNodePerformanceResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["CharacterType"] = request.characterType;
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["DBNodeIds"] = request.DBNodeIds;
+    query["DBNodeRole"] = request.DBNodeRole;
+    query["EndTime"] = request.endTime;
+    query["Key"] = request.key;
+    query["RegionId"] = request.regionId;
+    query["StartTime"] = request.startTime;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<DescribeDBNodePerformanceResponse>(await this.doRPCRequest("DescribeDBNodePerformance", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeDBNodePerformanceResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeDBNodePerformance",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeDBNodePerformanceResponse>(await this.callApi(params, req, runtime), new DescribeDBNodePerformanceResponse({}));
   }
 
   async describeDBNodePerformance(request: DescribeDBNodePerformanceRequest): Promise<DescribeDBNodePerformanceResponse> {
@@ -6222,10 +7128,26 @@ export default class Client extends OpenApi {
 
   async describeDbListWithOptions(request: DescribeDbListRequest, runtime: $Util.RuntimeOptions): Promise<DescribeDbListResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["DBName"] = request.DBName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    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: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeDbListResponse>(await this.callApi(params, req, runtime), new DescribeDbListResponse({}));
   }
 
   async describeDbList(request: DescribeDbListRequest): Promise<DescribeDbListResponse> {
@@ -6235,10 +7157,26 @@ export default class Client extends OpenApi {
 
   async describeDistributeTableListWithOptions(request: DescribeDistributeTableListRequest, runtime: $Util.RuntimeOptions): Promise<DescribeDistributeTableListResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["DbName"] = request.dbName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<DescribeDistributeTableListResponse>(await this.doRPCRequest("DescribeDistributeTableList", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeDistributeTableListResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeDistributeTableList",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeDistributeTableListResponse>(await this.callApi(params, req, runtime), new DescribeDistributeTableListResponse({}));
   }
 
   async describeDistributeTableList(request: DescribeDistributeTableListRequest): Promise<DescribeDistributeTableListResponse> {
@@ -6246,12 +7184,53 @@ export default class Client extends OpenApi {
     return await this.describeDistributeTableListWithOptions(request, runtime);
   }
 
+  async describeEventsWithOptions(request: DescribeEventsRequest, runtime: $Util.RuntimeOptions): Promise<DescribeEventsResponse> {
+    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: "DescribeEvents",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "GET",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeEventsResponse>(await this.callApi(params, req, runtime), new DescribeEventsResponse({}));
+  }
+
+  async describeEvents(request: DescribeEventsRequest): Promise<DescribeEventsResponse> {
+    let runtime = new $Util.RuntimeOptions({ });
+    return await this.describeEventsWithOptions(request, runtime);
+  }
+
   async describeParameterTemplatesWithOptions(request: DescribeParameterTemplatesRequest, runtime: $Util.RuntimeOptions): Promise<DescribeParameterTemplatesResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceId"] = request.DBInstanceId;
+    query["ParamLevel"] = request.paramLevel;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    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: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeParameterTemplatesResponse>(await this.callApi(params, req, runtime), new DescribeParameterTemplatesResponse({}));
   }
 
   async describeParameterTemplates(request: DescribeParameterTemplatesRequest): Promise<DescribeParameterTemplatesResponse> {
@@ -6261,10 +7240,26 @@ export default class Client extends OpenApi {
 
   async describeParametersWithOptions(request: DescribeParametersRequest, runtime: $Util.RuntimeOptions): Promise<DescribeParametersResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceId"] = request.DBInstanceId;
+    query["ParamLevel"] = request.paramLevel;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<DescribeParametersResponse>(await this.doRPCRequest("DescribeParameters", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeParametersResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeParameters",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeParametersResponse>(await this.callApi(params, req, runtime), new DescribeParametersResponse({}));
   }
 
   async describeParameters(request: DescribeParametersRequest): Promise<DescribeParametersResponse> {
@@ -6274,10 +7269,26 @@ export default class Client extends OpenApi {
 
   async describePolarxDataNodesWithOptions(request: DescribePolarxDataNodesRequest, runtime: $Util.RuntimeOptions): Promise<DescribePolarxDataNodesResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["PageNumber"] = request.pageNumber;
+    query["PageSize"] = request.pageSize;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<DescribePolarxDataNodesResponse>(await this.doRPCRequest("DescribePolarxDataNodes", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribePolarxDataNodesResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribePolarxDataNodes",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribePolarxDataNodesResponse>(await this.callApi(params, req, runtime), new DescribePolarxDataNodesResponse({}));
   }
 
   async describePolarxDataNodes(request: DescribePolarxDataNodesRequest): Promise<DescribePolarxDataNodesResponse> {
@@ -6287,10 +7298,27 @@ export default class Client extends OpenApi {
 
   async describePolarxDbInstancesWithOptions(request: DescribePolarxDbInstancesRequest, runtime: $Util.RuntimeOptions): Promise<DescribePolarxDbInstancesResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DbName"] = request.dbName;
+    query["DrdsInstanceId"] = request.drdsInstanceId;
+    query["PageNumber"] = request.pageNumber;
+    query["PageSize"] = request.pageSize;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<DescribePolarxDbInstancesResponse>(await this.doRPCRequest("DescribePolarxDbInstances", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribePolarxDbInstancesResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribePolarxDbInstances",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribePolarxDbInstancesResponse>(await this.callApi(params, req, runtime), new DescribePolarxDbInstancesResponse({}));
   }
 
   async describePolarxDbInstances(request: DescribePolarxDbInstancesRequest): Promise<DescribePolarxDbInstancesResponse> {
@@ -6298,22 +7326,20 @@ export default class Client extends OpenApi {
     return await this.describePolarxDbInstancesWithOptions(request, runtime);
   }
 
-  async describePolarxPgInstancesWithOptions(request: DescribePolarxPgInstancesRequest, runtime: $Util.RuntimeOptions): Promise<DescribePolarxPgInstancesResponse> {
-    Util.validateModel(request);
-    let req = new $OpenApi.OpenApiRequest({
-      body: Util.toMap(request),
-    });
-    return $tea.cast<DescribePolarxPgInstancesResponse>(await this.doRPCRequest("DescribePolarxPgInstances", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribePolarxPgInstancesResponse({}));
-  }
-
-  async describePolarxPgInstances(request: DescribePolarxPgInstancesRequest): Promise<DescribePolarxPgInstancesResponse> {
-    let runtime = new $Util.RuntimeOptions({ });
-    return await this.describePolarxPgInstancesWithOptions(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({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeRegions",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeRegionsResponse>(await this.callApi(params, req, runtime), new DescribeRegionsResponse({}));
   }
 
   async describeRegions(): Promise<DescribeRegionsResponse> {
@@ -6323,10 +7349,28 @@ export default class Client extends OpenApi {
 
   async describeScaleOutMigrateTaskListWithOptions(request: DescribeScaleOutMigrateTaskListRequest, runtime: $Util.RuntimeOptions): Promise<DescribeScaleOutMigrateTaskListResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["OwnerAccount"] = request.ownerAccount;
+    query["OwnerId"] = request.ownerId;
+    query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
+    query["ResourceOwnerId"] = request.resourceOwnerId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<DescribeScaleOutMigrateTaskListResponse>(await this.doRPCRequest("DescribeScaleOutMigrateTaskList", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeScaleOutMigrateTaskListResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeScaleOutMigrateTaskList",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeScaleOutMigrateTaskListResponse>(await this.callApi(params, req, runtime), new DescribeScaleOutMigrateTaskListResponse({}));
   }
 
   async describeScaleOutMigrateTaskList(request: DescribeScaleOutMigrateTaskListRequest): Promise<DescribeScaleOutMigrateTaskListResponse> {
@@ -6336,10 +7380,25 @@ export default class Client extends OpenApi {
 
   async describeSecurityIpsWithOptions(request: DescribeSecurityIpsRequest, runtime: $Util.RuntimeOptions): Promise<DescribeSecurityIpsResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<DescribeSecurityIpsResponse>(await this.doRPCRequest("DescribeSecurityIps", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeSecurityIpsResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeSecurityIps",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeSecurityIpsResponse>(await this.callApi(params, req, runtime), new DescribeSecurityIpsResponse({}));
   }
 
   async describeSecurityIps(request: DescribeSecurityIpsRequest): Promise<DescribeSecurityIpsResponse> {
@@ -6349,10 +7408,33 @@ export default class Client extends OpenApi {
 
   async describeTasksWithOptions(request: DescribeTasksRequest, runtime: $Util.RuntimeOptions): Promise<DescribeTasksResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceId"] = request.DBInstanceId;
+    query["EndTime"] = request.endTime;
+    query["OwnerAccount"] = request.ownerAccount;
+    query["OwnerId"] = request.ownerId;
+    query["PageNumber"] = request.pageNumber;
+    query["PageSize"] = request.pageSize;
+    query["RegionId"] = request.regionId;
+    query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
+    query["ResourceOwnerId"] = request.resourceOwnerId;
+    query["StartTime"] = request.startTime;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    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: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeTasksResponse>(await this.callApi(params, req, runtime), new DescribeTasksResponse({}));
   }
 
   async describeTasks(request: DescribeTasksRequest): Promise<DescribeTasksResponse> {
@@ -6362,10 +7444,25 @@ export default class Client extends OpenApi {
 
   async describeUserEncryptionKeyListWithOptions(request: DescribeUserEncryptionKeyListRequest, runtime: $Util.RuntimeOptions): Promise<DescribeUserEncryptionKeyListResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<DescribeUserEncryptionKeyListResponse>(await this.doRPCRequest("DescribeUserEncryptionKeyList", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribeUserEncryptionKeyListResponse({}));
+    let params = new $OpenApi.Params({
+      action: "DescribeUserEncryptionKeyList",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribeUserEncryptionKeyListResponse>(await this.callApi(params, req, runtime), new DescribeUserEncryptionKeyListResponse({}));
   }
 
   async describeUserEncryptionKeyList(request: DescribeUserEncryptionKeyListRequest): Promise<DescribeUserEncryptionKeyListResponse> {
@@ -6375,10 +7472,26 @@ export default class Client extends OpenApi {
 
   async getPolarxCommodityWithOptions(request: GetPolarxCommodityRequest, runtime: $Util.RuntimeOptions): Promise<GetPolarxCommodityResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["OrderType"] = request.orderType;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    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: "GetPolarxCommodity",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<GetPolarxCommodityResponse>(await this.callApi(params, req, runtime), new GetPolarxCommodityResponse({}));
   }
 
   async getPolarxCommodity(request: GetPolarxCommodityRequest): Promise<GetPolarxCommodityResponse> {
@@ -6388,10 +7501,27 @@ export default class Client extends OpenApi {
 
   async modifyAccountDescriptionWithOptions(request: ModifyAccountDescriptionRequest, runtime: $Util.RuntimeOptions): Promise<ModifyAccountDescriptionResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["AccountDescription"] = request.accountDescription;
+    query["AccountName"] = request.accountName;
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<ModifyAccountDescriptionResponse>(await this.doRPCRequest("ModifyAccountDescription", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new ModifyAccountDescriptionResponse({}));
+    let params = new $OpenApi.Params({
+      action: "ModifyAccountDescription",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<ModifyAccountDescriptionResponse>(await this.callApi(params, req, runtime), new ModifyAccountDescriptionResponse({}));
   }
 
   async modifyAccountDescription(request: ModifyAccountDescriptionRequest): Promise<ModifyAccountDescriptionResponse> {
@@ -6399,12 +7529,84 @@ export default class Client extends OpenApi {
     return await this.modifyAccountDescriptionWithOptions(request, runtime);
   }
 
+  async modifyActiveOperationMaintainConfWithOptions(request: ModifyActiveOperationMaintainConfRequest, runtime: $Util.RuntimeOptions): Promise<ModifyActiveOperationMaintainConfResponse> {
+    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: "ModifyActiveOperationMaintainConf",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "GET",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<ModifyActiveOperationMaintainConfResponse>(await this.callApi(params, req, runtime), new ModifyActiveOperationMaintainConfResponse({}));
+  }
+
+  async modifyActiveOperationMaintainConf(request: ModifyActiveOperationMaintainConfRequest): Promise<ModifyActiveOperationMaintainConfResponse> {
+    let runtime = new $Util.RuntimeOptions({ });
+    return await this.modifyActiveOperationMaintainConfWithOptions(request, runtime);
+  }
+
+  async modifyActiveOperationTasksWithOptions(request: ModifyActiveOperationTasksRequest, runtime: $Util.RuntimeOptions): Promise<ModifyActiveOperationTasksResponse> {
+    Util.validateModel(request);
+    let query = { };
+    query["Ids"] = request.ids;
+    query["ImmediateStart"] = request.immediateStart;
+    query["RegionId"] = request.regionId;
+    query["SwitchTime"] = request.switchTime;
+    let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
+      body: Util.toMap(request),
+    });
+    let params = new $OpenApi.Params({
+      action: "ModifyActiveOperationTasks",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<ModifyActiveOperationTasksResponse>(await this.callApi(params, req, runtime), new ModifyActiveOperationTasksResponse({}));
+  }
+
+  async modifyActiveOperationTasks(request: ModifyActiveOperationTasksRequest): Promise<ModifyActiveOperationTasksResponse> {
+    let runtime = new $Util.RuntimeOptions({ });
+    return await this.modifyActiveOperationTasksWithOptions(request, runtime);
+  }
+
   async modifyDBInstanceClassWithOptions(request: ModifyDBInstanceClassRequest, runtime: $Util.RuntimeOptions): Promise<ModifyDBInstanceClassResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["ClientToken"] = request.clientToken;
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
+    query["TargetDBInstanceClass"] = request.targetDBInstanceClass;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<ModifyDBInstanceClassResponse>(await this.doRPCRequest("ModifyDBInstanceClass", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new ModifyDBInstanceClassResponse({}));
+    let params = new $OpenApi.Params({
+      action: "ModifyDBInstanceClass",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<ModifyDBInstanceClassResponse>(await this.callApi(params, req, runtime), new ModifyDBInstanceClassResponse({}));
   }
 
   async modifyDBInstanceClass(request: ModifyDBInstanceClassRequest): Promise<ModifyDBInstanceClassResponse> {
@@ -6414,10 +7616,27 @@ export default class Client extends OpenApi {
 
   async modifyDBInstanceConfigWithOptions(request: ModifyDBInstanceConfigRequest, runtime: $Util.RuntimeOptions): Promise<ModifyDBInstanceConfigResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["ConfigName"] = request.configName;
+    query["ConfigValue"] = request.configValue;
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<ModifyDBInstanceConfigResponse>(await this.doRPCRequest("ModifyDBInstanceConfig", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new ModifyDBInstanceConfigResponse({}));
+    let params = new $OpenApi.Params({
+      action: "ModifyDBInstanceConfig",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<ModifyDBInstanceConfigResponse>(await this.callApi(params, req, runtime), new ModifyDBInstanceConfigResponse({}));
   }
 
   async modifyDBInstanceConfig(request: ModifyDBInstanceConfigRequest): Promise<ModifyDBInstanceConfigResponse> {
@@ -6427,10 +7646,26 @@ export default class Client extends OpenApi {
 
   async modifyDBInstanceDescriptionWithOptions(request: ModifyDBInstanceDescriptionRequest, runtime: $Util.RuntimeOptions): Promise<ModifyDBInstanceDescriptionResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceDescription"] = request.DBInstanceDescription;
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    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: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<ModifyDBInstanceDescriptionResponse>(await this.callApi(params, req, runtime), new ModifyDBInstanceDescriptionResponse({}));
   }
 
   async modifyDBInstanceDescription(request: ModifyDBInstanceDescriptionRequest): Promise<ModifyDBInstanceDescriptionResponse> {
@@ -6440,10 +7675,27 @@ export default class Client extends OpenApi {
 
   async modifyDatabaseDescriptionWithOptions(request: ModifyDatabaseDescriptionRequest, runtime: $Util.RuntimeOptions): Promise<ModifyDatabaseDescriptionResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["DbDescription"] = request.dbDescription;
+    query["DbName"] = request.dbName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<ModifyDatabaseDescriptionResponse>(await this.doRPCRequest("ModifyDatabaseDescription", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new ModifyDatabaseDescriptionResponse({}));
+    let params = new $OpenApi.Params({
+      action: "ModifyDatabaseDescription",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<ModifyDatabaseDescriptionResponse>(await this.callApi(params, req, runtime), new ModifyDatabaseDescriptionResponse({}));
   }
 
   async modifyDatabaseDescription(request: ModifyDatabaseDescriptionRequest): Promise<ModifyDatabaseDescriptionResponse> {
@@ -6453,10 +7705,28 @@ export default class Client extends OpenApi {
 
   async modifyParameterWithOptions(request: ModifyParameterRequest, runtime: $Util.RuntimeOptions): Promise<ModifyParameterResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["ClientToken"] = request.clientToken;
+    query["DBInstanceId"] = request.DBInstanceId;
+    query["ParamLevel"] = request.paramLevel;
+    query["Parameters"] = request.parameters;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<ModifyParameterResponse>(await this.doRPCRequest("ModifyParameter", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new ModifyParameterResponse({}));
+    let params = new $OpenApi.Params({
+      action: "ModifyParameter",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<ModifyParameterResponse>(await this.callApi(params, req, runtime), new ModifyParameterResponse({}));
   }
 
   async modifyParameter(request: ModifyParameterRequest): Promise<ModifyParameterResponse> {
@@ -6466,10 +7736,28 @@ export default class Client extends OpenApi {
 
   async modifySecurityIpsWithOptions(request: ModifySecurityIpsRequest, runtime: $Util.RuntimeOptions): Promise<ModifySecurityIpsResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["GroupName"] = request.groupName;
+    query["ModifyMode"] = request.modifyMode;
+    query["RegionId"] = request.regionId;
+    query["SecurityIPList"] = request.securityIPList;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<ModifySecurityIpsResponse>(await this.doRPCRequest("ModifySecurityIps", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new ModifySecurityIpsResponse({}));
+    let params = new $OpenApi.Params({
+      action: "ModifySecurityIps",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<ModifySecurityIpsResponse>(await this.callApi(params, req, runtime), new ModifySecurityIpsResponse({}));
   }
 
   async modifySecurityIps(request: ModifySecurityIpsRequest): Promise<ModifySecurityIpsResponse> {
@@ -6479,10 +7767,30 @@ export default class Client extends OpenApi {
 
   async releaseInstancePublicConnectionWithOptions(request: ReleaseInstancePublicConnectionRequest, runtime: $Util.RuntimeOptions): Promise<ReleaseInstancePublicConnectionResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["CurrentConnectionString"] = request.currentConnectionString;
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["OwnerAccount"] = request.ownerAccount;
+    query["OwnerId"] = request.ownerId;
+    query["RegionId"] = request.regionId;
+    query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
+    query["ResourceOwnerId"] = request.resourceOwnerId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    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: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<ReleaseInstancePublicConnectionResponse>(await this.callApi(params, req, runtime), new ReleaseInstancePublicConnectionResponse({}));
   }
 
   async releaseInstancePublicConnection(request: ReleaseInstancePublicConnectionRequest): Promise<ReleaseInstancePublicConnectionResponse> {
@@ -6492,10 +7800,25 @@ export default class Client extends OpenApi {
 
   async restartDBInstanceWithOptions(request: RestartDBInstanceRequest, runtime: $Util.RuntimeOptions): Promise<RestartDBInstanceResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<RestartDBInstanceResponse>(await this.doRPCRequest("RestartDBInstance", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new RestartDBInstanceResponse({}));
+    let params = new $OpenApi.Params({
+      action: "RestartDBInstance",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<RestartDBInstanceResponse>(await this.callApi(params, req, runtime), new RestartDBInstanceResponse({}));
   }
 
   async restartDBInstance(request: RestartDBInstanceRequest): Promise<RestartDBInstanceResponse> {
@@ -6505,10 +7828,35 @@ export default class Client extends OpenApi {
 
   async updateBackupPolicyWithOptions(request: UpdateBackupPolicyRequest, runtime: $Util.RuntimeOptions): Promise<UpdateBackupPolicyResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["BackupPeriod"] = request.backupPeriod;
+    query["BackupPlanBegin"] = request.backupPlanBegin;
+    query["BackupSetRetention"] = request.backupSetRetention;
+    query["BackupType"] = request.backupType;
+    query["BackupWay"] = request.backupWay;
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["ForceCleanOnHighSpaceUsage"] = request.forceCleanOnHighSpaceUsage;
+    query["IsEnabled"] = request.isEnabled;
+    query["LocalLogRetention"] = request.localLogRetention;
+    query["LogLocalRetentionSpace"] = request.logLocalRetentionSpace;
+    query["RegionId"] = request.regionId;
+    query["RemoveLogRetention"] = request.removeLogRetention;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    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: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<UpdateBackupPolicyResponse>(await this.callApi(params, req, runtime), new UpdateBackupPolicyResponse({}));
   }
 
   async updateBackupPolicy(request: UpdateBackupPolicyRequest): Promise<UpdateBackupPolicyResponse> {
@@ -6518,10 +7866,27 @@ export default class Client extends OpenApi {
 
   async updateDBInstanceSSLWithOptions(request: UpdateDBInstanceSSLRequest, runtime: $Util.RuntimeOptions): Promise<UpdateDBInstanceSSLResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["CertCommonName"] = request.certCommonName;
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["EnableSSL"] = request.enableSSL;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    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: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<UpdateDBInstanceSSLResponse>(await this.callApi(params, req, runtime), new UpdateDBInstanceSSLResponse({}));
   }
 
   async updateDBInstanceSSL(request: UpdateDBInstanceSSLRequest): Promise<UpdateDBInstanceSSLResponse> {
@@ -6531,10 +7896,28 @@ export default class Client extends OpenApi {
 
   async updateDBInstanceTDEWithOptions(request: UpdateDBInstanceTDERequest, runtime: $Util.RuntimeOptions): Promise<UpdateDBInstanceTDEResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["EncryptionKey"] = request.encryptionKey;
+    query["RegionId"] = request.regionId;
+    query["RoleArn"] = request.roleArn;
+    query["TDEStatus"] = request.TDEStatus;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<UpdateDBInstanceTDEResponse>(await this.doRPCRequest("UpdateDBInstanceTDE", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new UpdateDBInstanceTDEResponse({}));
+    let params = new $OpenApi.Params({
+      action: "UpdateDBInstanceTDE",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<UpdateDBInstanceTDEResponse>(await this.callApi(params, req, runtime), new UpdateDBInstanceTDEResponse({}));
   }
 
   async updateDBInstanceTDE(request: UpdateDBInstanceTDERequest): Promise<UpdateDBInstanceTDEResponse> {
@@ -6544,10 +7927,27 @@ export default class Client extends OpenApi {
 
   async updatePolarDBXInstanceNodeWithOptions(request: UpdatePolarDBXInstanceNodeRequest, runtime: $Util.RuntimeOptions): Promise<UpdatePolarDBXInstanceNodeResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["ClientToken"] = request.clientToken;
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["DbInstanceNodeCount"] = request.dbInstanceNodeCount;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<UpdatePolarDBXInstanceNodeResponse>(await this.doRPCRequest("UpdatePolarDBXInstanceNode", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new UpdatePolarDBXInstanceNodeResponse({}));
+    let params = new $OpenApi.Params({
+      action: "UpdatePolarDBXInstanceNode",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<UpdatePolarDBXInstanceNodeResponse>(await this.callApi(params, req, runtime), new UpdatePolarDBXInstanceNodeResponse({}));
   }
 
   async updatePolarDBXInstanceNode(request: UpdatePolarDBXInstanceNodeRequest): Promise<UpdatePolarDBXInstanceNodeResponse> {
@@ -6557,10 +7957,25 @@ export default class Client extends OpenApi {
 
   async upgradeDBInstanceKernelVersionWithOptions(request: UpgradeDBInstanceKernelVersionRequest, runtime: $Util.RuntimeOptions): Promise<UpgradeDBInstanceKernelVersionResponse> {
     Util.validateModel(request);
+    let query = { };
+    query["DBInstanceName"] = request.DBInstanceName;
+    query["RegionId"] = request.regionId;
     let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
       body: Util.toMap(request),
     });
-    return $tea.cast<UpgradeDBInstanceKernelVersionResponse>(await this.doRPCRequest("UpgradeDBInstanceKernelVersion", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new UpgradeDBInstanceKernelVersionResponse({}));
+    let params = new $OpenApi.Params({
+      action: "UpgradeDBInstanceKernelVersion",
+      version: "2020-02-02",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "POST",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "json",
+      bodyType: "json",
+    });
+    return $tea.cast<UpgradeDBInstanceKernelVersionResponse>(await this.callApi(params, req, runtime), new UpgradeDBInstanceKernelVersionResponse({}));
   }
 
   async upgradeDBInstanceKernelVersion(request: UpgradeDBInstanceKernelVersionRequest): Promise<UpgradeDBInstanceKernelVersionResponse> {