@alicloud/polardbx20200202 1.0.1 → 1.0.5

package/dist/client.js

@@ -83,6 +83,60 @@ class AllocateInstancePublicConnectionResponse extends $tea.Model {
     }
 }
 exports.AllocateInstancePublicConnectionResponse = AllocateInstancePublicConnectionResponse;
+class CancelActiveOperationTasksRequest extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            ids: 'Ids',
+            regionId: 'RegionId',
+        };
+    }
+    static types() {
+        return {
+            ids: 'string',
+            regionId: 'string',
+        };
+    }
+}
+exports.CancelActiveOperationTasksRequest = CancelActiveOperationTasksRequest;
+class CancelActiveOperationTasksResponseBody extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            ids: 'Ids',
+            requestId: 'RequestId',
+        };
+    }
+    static types() {
+        return {
+            ids: 'string',
+            requestId: 'string',
+        };
+    }
+}
+exports.CancelActiveOperationTasksResponseBody = CancelActiveOperationTasksResponseBody;
+class CancelActiveOperationTasksResponse extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            headers: 'headers',
+            body: 'body',
+        };
+    }
+    static types() {
+        return {
+            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+            body: CancelActiveOperationTasksResponseBody,
+        };
+    }
+}
+exports.CancelActiveOperationTasksResponse = CancelActiveOperationTasksResponse;
 class CancelPolarxOrderRequest extends $tea.Model {
     constructor(map) {
         super(map);
@@ -477,92 +531,6 @@ class CreateDBInstanceResponse extends $tea.Model {
     }
 }
 exports.CreateDBInstanceResponse = CreateDBInstanceResponse;
-class CreatePolarxInstanceRequest extends $tea.Model {
-    constructor(map) {
-        super(map);
-    }
-    static names() {
-        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() {
-        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',
-        };
-    }
-}
-exports.CreatePolarxInstanceRequest = CreatePolarxInstanceRequest;
-class CreatePolarxInstanceResponseBody extends $tea.Model {
-    constructor(map) {
-        super(map);
-    }
-    static names() {
-        return {
-            data: 'Data',
-            requestId: 'RequestId',
-            success: 'Success',
-        };
-    }
-    static types() {
-        return {
-            data: CreatePolarxInstanceResponseBodyData,
-            requestId: 'string',
-            success: 'boolean',
-        };
-    }
-}
-exports.CreatePolarxInstanceResponseBody = CreatePolarxInstanceResponseBody;
-class CreatePolarxInstanceResponse extends $tea.Model {
-    constructor(map) {
-        super(map);
-    }
-    static names() {
-        return {
-            headers: 'headers',
-            body: 'body',
-        };
-    }
-    static types() {
-        return {
-            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
-            body: CreatePolarxInstanceResponseBody,
-        };
-    }
-}
-exports.CreatePolarxInstanceResponse = CreatePolarxInstanceResponse;
 class CreatePolarxOrderRequest extends $tea.Model {
     constructor(map) {
         super(map);
@@ -915,6 +883,198 @@ class DescribeAccountListResponse extends $tea.Model {
     }
 }
 exports.DescribeAccountListResponse = DescribeAccountListResponse;
+class DescribeActiveOperationMaintainConfRequest extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            regionId: 'RegionId',
+        };
+    }
+    static types() {
+        return {
+            regionId: 'string',
+        };
+    }
+}
+exports.DescribeActiveOperationMaintainConfRequest = DescribeActiveOperationMaintainConfRequest;
+class DescribeActiveOperationMaintainConfResponseBody extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            config: 'Config',
+            hasConfig: 'HasConfig',
+            requestId: 'RequestId',
+        };
+    }
+    static types() {
+        return {
+            config: DescribeActiveOperationMaintainConfResponseBodyConfig,
+            hasConfig: 'number',
+            requestId: 'string',
+        };
+    }
+}
+exports.DescribeActiveOperationMaintainConfResponseBody = DescribeActiveOperationMaintainConfResponseBody;
+class DescribeActiveOperationMaintainConfResponse extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            headers: 'headers',
+            body: 'body',
+        };
+    }
+    static types() {
+        return {
+            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+            body: DescribeActiveOperationMaintainConfResponseBody,
+        };
+    }
+}
+exports.DescribeActiveOperationMaintainConfResponse = DescribeActiveOperationMaintainConfResponse;
+class DescribeActiveOperationTaskCountRequest extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            category: 'Category',
+            product: 'Product',
+            regionId: 'RegionId',
+        };
+    }
+    static types() {
+        return {
+            category: 'string',
+            product: 'string',
+            regionId: 'string',
+        };
+    }
+}
+exports.DescribeActiveOperationTaskCountRequest = DescribeActiveOperationTaskCountRequest;
+class DescribeActiveOperationTaskCountResponseBody extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            needPop: 'NeedPop',
+            requestId: 'RequestId',
+            taskCount: 'TaskCount',
+        };
+    }
+    static types() {
+        return {
+            needPop: 'number',
+            requestId: 'string',
+            taskCount: 'number',
+        };
+    }
+}
+exports.DescribeActiveOperationTaskCountResponseBody = DescribeActiveOperationTaskCountResponseBody;
+class DescribeActiveOperationTaskCountResponse extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            headers: 'headers',
+            body: 'body',
+        };
+    }
+    static types() {
+        return {
+            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+            body: DescribeActiveOperationTaskCountResponseBody,
+        };
+    }
+}
+exports.DescribeActiveOperationTaskCountResponse = DescribeActiveOperationTaskCountResponse;
+class DescribeActiveOperationTasksRequest extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        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() {
+        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',
+        };
+    }
+}
+exports.DescribeActiveOperationTasksRequest = DescribeActiveOperationTasksRequest;
+class DescribeActiveOperationTasksResponseBody extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            items: 'Items',
+            pageNumber: 'PageNumber',
+            pageSize: 'PageSize',
+            requestId: 'RequestId',
+            totalRecordCount: 'TotalRecordCount',
+        };
+    }
+    static types() {
+        return {
+            items: { 'type': 'array', 'itemType': DescribeActiveOperationTasksResponseBodyItems },
+            pageNumber: 'number',
+            pageSize: 'number',
+            requestId: 'string',
+            totalRecordCount: 'number',
+        };
+    }
+}
+exports.DescribeActiveOperationTasksResponseBody = DescribeActiveOperationTasksResponseBody;
+class DescribeActiveOperationTasksResponse extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            headers: 'headers',
+            body: 'body',
+        };
+    }
+    static types() {
+        return {
+            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+            body: DescribeActiveOperationTasksResponseBody,
+        };
+    }
+}
+exports.DescribeActiveOperationTasksResponse = DescribeActiveOperationTasksResponse;
 class DescribeBackupPolicyRequest extends $tea.Model {
     constructor(map) {
         super(map);
@@ -1508,6 +1668,7 @@ class DescribeDBNodePerformanceRequest extends $tea.Model {
             characterType: 'CharacterType',
             DBInstanceName: 'DBInstanceName',
             DBNodeIds: 'DBNodeIds',
+            DBNodeRole: 'DBNodeRole',
             endTime: 'EndTime',
             key: 'Key',
             regionId: 'RegionId',
@@ -1519,6 +1680,7 @@ class DescribeDBNodePerformanceRequest extends $tea.Model {
             characterType: 'string',
             DBInstanceName: 'string',
             DBNodeIds: 'string',
+            DBNodeRole: 'string',
             endTime: 'string',
             key: 'string',
             regionId: 'string',
@@ -1689,6 +1851,72 @@ class DescribeDistributeTableListResponse extends $tea.Model {
     }
 }
 exports.DescribeDistributeTableListResponse = DescribeDistributeTableListResponse;
+class DescribeEventsRequest extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            endTime: 'EndTime',
+            pageNumber: 'PageNumber',
+            pageSize: 'PageSize',
+            regionId: 'RegionId',
+            startTime: 'StartTime',
+        };
+    }
+    static types() {
+        return {
+            endTime: 'string',
+            pageNumber: 'number',
+            pageSize: 'number',
+            regionId: 'string',
+            startTime: 'string',
+        };
+    }
+}
+exports.DescribeEventsRequest = DescribeEventsRequest;
+class DescribeEventsResponseBody extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            eventItems: 'EventItems',
+            pageNumber: 'PageNumber',
+            pageSize: 'PageSize',
+            requestId: 'RequestId',
+            totalRecordCount: 'TotalRecordCount',
+        };
+    }
+    static types() {
+        return {
+            eventItems: { 'type': 'array', 'itemType': DescribeEventsResponseBodyEventItems },
+            pageNumber: 'number',
+            pageSize: 'number',
+            requestId: 'string',
+            totalRecordCount: 'number',
+        };
+    }
+}
+exports.DescribeEventsResponseBody = DescribeEventsResponseBody;
+class DescribeEventsResponse extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            headers: 'headers',
+            body: 'body',
+        };
+    }
+    static types() {
+        return {
+            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+            body: DescribeEventsResponseBody,
+        };
+    }
+}
+exports.DescribeEventsResponse = DescribeEventsResponse;
 class DescribeParameterTemplatesRequest extends $tea.Model {
     constructor(map) {
         super(map);
@@ -1929,70 +2157,6 @@ class DescribePolarxDbInstancesResponse extends $tea.Model {
     }
 }
 exports.DescribePolarxDbInstancesResponse = DescribePolarxDbInstancesResponse;
-class DescribePolarxPgInstancesRequest extends $tea.Model {
-    constructor(map) {
-        super(map);
-    }
-    static names() {
-        return {
-            pageNumber: 'PageNumber',
-            pageSize: 'PageSize',
-            regionId: 'RegionId',
-            resourceGroupId: 'ResourceGroupId',
-        };
-    }
-    static types() {
-        return {
-            pageNumber: 'number',
-            pageSize: 'number',
-            regionId: 'string',
-            resourceGroupId: 'string',
-        };
-    }
-}
-exports.DescribePolarxPgInstancesRequest = DescribePolarxPgInstancesRequest;
-class DescribePolarxPgInstancesResponseBody extends $tea.Model {
-    constructor(map) {
-        super(map);
-    }
-    static names() {
-        return {
-            DBInstances: 'DBInstances',
-            expireDate: 'ExpireDate',
-            pageNumber: 'PageNumber',
-            pageSize: 'PageSize',
-            requestId: 'RequestId',
-        };
-    }
-    static types() {
-        return {
-            DBInstances: { 'type': 'array', 'itemType': DescribePolarxPgInstancesResponseBodyDBInstances },
-            expireDate: 'string',
-            pageNumber: 'number',
-            pageSize: 'number',
-            requestId: 'string',
-        };
-    }
-}
-exports.DescribePolarxPgInstancesResponseBody = DescribePolarxPgInstancesResponseBody;
-class DescribePolarxPgInstancesResponse extends $tea.Model {
-    constructor(map) {
-        super(map);
-    }
-    static names() {
-        return {
-            headers: 'headers',
-            body: 'body',
-        };
-    }
-    static types() {
-        return {
-            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
-            body: DescribePolarxPgInstancesResponseBody,
-        };
-    }
-}
-exports.DescribePolarxPgInstancesResponse = DescribePolarxPgInstancesResponse;
 class DescribeRegionsResponseBody extends $tea.Model {
     constructor(map) {
         super(map);
@@ -2171,8 +2335,6 @@ class DescribeTasksRequest extends $tea.Model {
             resourceOwnerAccount: 'ResourceOwnerAccount',
             resourceOwnerId: 'ResourceOwnerId',
             startTime: 'StartTime',
-            status: 'Status',
-            taskAction: 'TaskAction',
         };
     }
     static types() {
@@ -2187,8 +2349,6 @@ class DescribeTasksRequest extends $tea.Model {
             resourceOwnerAccount: 'string',
             resourceOwnerId: 'number',
             startTime: 'string',
-            status: 'string',
-            taskAction: 'string',
         };
     }
 }
@@ -2407,6 +2567,124 @@ class ModifyAccountDescriptionResponse extends $tea.Model {
     }
 }
 exports.ModifyAccountDescriptionResponse = ModifyAccountDescriptionResponse;
+class ModifyActiveOperationMaintainConfRequest extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            cycleTime: 'CycleTime',
+            cycleType: 'CycleType',
+            maintainEndTime: 'MaintainEndTime',
+            maintainStartTime: 'MaintainStartTime',
+            regionId: 'RegionId',
+            status: 'Status',
+        };
+    }
+    static types() {
+        return {
+            cycleTime: 'string',
+            cycleType: 'string',
+            maintainEndTime: 'string',
+            maintainStartTime: 'string',
+            regionId: 'string',
+            status: 'number',
+        };
+    }
+}
+exports.ModifyActiveOperationMaintainConfRequest = ModifyActiveOperationMaintainConfRequest;
+class ModifyActiveOperationMaintainConfResponseBody extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            requestId: 'RequestId',
+        };
+    }
+    static types() {
+        return {
+            requestId: 'string',
+        };
+    }
+}
+exports.ModifyActiveOperationMaintainConfResponseBody = ModifyActiveOperationMaintainConfResponseBody;
+class ModifyActiveOperationMaintainConfResponse extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            headers: 'headers',
+            body: 'body',
+        };
+    }
+    static types() {
+        return {
+            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+            body: ModifyActiveOperationMaintainConfResponseBody,
+        };
+    }
+}
+exports.ModifyActiveOperationMaintainConfResponse = ModifyActiveOperationMaintainConfResponse;
+class ModifyActiveOperationTasksRequest extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            ids: 'Ids',
+            immediateStart: 'ImmediateStart',
+            regionId: 'RegionId',
+            switchTime: 'SwitchTime',
+        };
+    }
+    static types() {
+        return {
+            ids: 'string',
+            immediateStart: 'number',
+            regionId: 'string',
+            switchTime: 'string',
+        };
+    }
+}
+exports.ModifyActiveOperationTasksRequest = ModifyActiveOperationTasksRequest;
+class ModifyActiveOperationTasksResponseBody extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            ids: 'Ids',
+            requestId: 'RequestId',
+        };
+    }
+    static types() {
+        return {
+            ids: 'string',
+            requestId: 'string',
+        };
+    }
+}
+exports.ModifyActiveOperationTasksResponseBody = ModifyActiveOperationTasksResponseBody;
+class ModifyActiveOperationTasksResponse extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        return {
+            headers: 'headers',
+            body: 'body',
+        };
+    }
+    static types() {
+        return {
+            headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+            body: ModifyActiveOperationTasksResponseBody,
+        };
+    }
+}
+exports.ModifyActiveOperationTasksResponse = ModifyActiveOperationTasksResponse;
 class ModifyDBInstanceClassRequest extends $tea.Model {
     constructor(map) {
         super(map);
@@ -3131,16 +3409,12 @@ class UpgradeDBInstanceKernelVersionRequest extends $tea.Model {
         return {
             DBInstanceName: 'DBInstanceName',
             regionId: 'RegionId',
-            switchTime: 'SwitchTime',
-            upgradeTime: 'UpgradeTime',
         };
     }
     static types() {
         return {
             DBInstanceName: 'string',
             regionId: 'string',
-            switchTime: 'string',
-            upgradeTime: 'string',
         };
     }
 }
@@ -3219,86 +3493,148 @@ class CreateBackupResponseBodyData extends $tea.Model {
     }
 }
 exports.CreateBackupResponseBodyData = CreateBackupResponseBodyData;
-class CreatePolarxInstanceResponseBodyDataDrdsInstanceIdList extends $tea.Model {
+class CreatePolarxOrderResponseBodyOrderResultList extends $tea.Model {
     constructor(map) {
         super(map);
     }
     static names() {
         return {
-            drdsInstanceIdList: 'drdsInstanceIdList',
+            DBInstanceName: 'DBInstanceName',
+            orderId: 'OrderId',
         };
     }
     static types() {
         return {
-            drdsInstanceIdList: { 'type': 'array', 'itemType': 'string' },
+            DBInstanceName: 'string',
+            orderId: 'number',
         };
     }
 }
-exports.CreatePolarxInstanceResponseBodyDataDrdsInstanceIdList = CreatePolarxInstanceResponseBodyDataDrdsInstanceIdList;
-class CreatePolarxInstanceResponseBodyData extends $tea.Model {
+exports.CreatePolarxOrderResponseBodyOrderResultList = CreatePolarxOrderResponseBodyOrderResultList;
+class DescribeAccountListResponseBodyData extends $tea.Model {
     constructor(map) {
         super(map);
     }
     static names() {
         return {
-            drdsInstanceIdList: 'DrdsInstanceIdList',
-            orderId: 'OrderId',
+            accountDescription: 'AccountDescription',
+            accountName: 'AccountName',
+            accountPrivilege: 'AccountPrivilege',
+            accountType: 'AccountType',
+            DBInstanceName: 'DBInstanceName',
+            DBName: 'DBName',
+            gmtCreated: 'GmtCreated',
         };
     }
     static types() {
         return {
-            drdsInstanceIdList: CreatePolarxInstanceResponseBodyDataDrdsInstanceIdList,
-            orderId: 'number',
+            accountDescription: 'string',
+            accountName: 'string',
+            accountPrivilege: 'string',
+            accountType: 'string',
+            DBInstanceName: 'string',
+            DBName: 'string',
+            gmtCreated: 'string',
         };
     }
 }
-exports.CreatePolarxInstanceResponseBodyData = CreatePolarxInstanceResponseBodyData;
-class CreatePolarxOrderResponseBodyOrderResultList extends $tea.Model {
+exports.DescribeAccountListResponseBodyData = DescribeAccountListResponseBodyData;
+class DescribeActiveOperationMaintainConfResponseBodyConfig extends $tea.Model {
     constructor(map) {
         super(map);
     }
     static names() {
         return {
-            DBInstanceName: 'DBInstanceName',
-            orderId: 'OrderId',
+            createdTime: 'CreatedTime',
+            cycleTime: 'CycleTime',
+            cycleType: 'CycleType',
+            maintainEndTime: 'MaintainEndTime',
+            maintainStartTime: 'MaintainStartTime',
+            modifiedTime: 'ModifiedTime',
+            status: 'Status',
         };
     }
     static types() {
         return {
-            DBInstanceName: 'string',
-            orderId: 'number',
+            createdTime: 'string',
+            cycleTime: 'string',
+            cycleType: 'string',
+            maintainEndTime: 'string',
+            maintainStartTime: 'string',
+            modifiedTime: 'string',
+            status: 'number',
         };
     }
 }
-exports.CreatePolarxOrderResponseBodyOrderResultList = CreatePolarxOrderResponseBodyOrderResultList;
-class DescribeAccountListResponseBodyData extends $tea.Model {
+exports.DescribeActiveOperationMaintainConfResponseBodyConfig = DescribeActiveOperationMaintainConfResponseBodyConfig;
+class DescribeActiveOperationTasksResponseBodyItems extends $tea.Model {
     constructor(map) {
         super(map);
     }
     static names() {
         return {
-            accountDescription: 'AccountDescription',
-            accountName: 'AccountName',
-            accountPrivilege: 'AccountPrivilege',
-            accountType: 'AccountType',
-            DBInstanceName: 'DBInstanceName',
-            DBName: 'DBName',
-            gmtCreated: 'GmtCreated',
+            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() {
         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',
         };
     }
 }
-exports.DescribeAccountListResponseBodyData = DescribeAccountListResponseBodyData;
+exports.DescribeActiveOperationTasksResponseBodyItems = DescribeActiveOperationTasksResponseBodyItems;
 class DescribeBackupPolicyResponseBodyData extends $tea.Model {
     constructor(map) {
         super(map);
@@ -3433,7 +3769,7 @@ class DescribeDBInstanceAttributeResponseBodyDBInstanceConnAddrs extends $tea.Mo
     static types() {
         return {
             connectionString: 'string',
-            port: 'string',
+            port: 'number',
             type: 'string',
             VPCId: 'string',
             vSwitchId: 'string',
@@ -3971,6 +4307,42 @@ class DescribeDistributeTableListResponseBodyData extends $tea.Model {
     }
 }
 exports.DescribeDistributeTableListResponseBodyData = DescribeDistributeTableListResponseBodyData;
+class DescribeEventsResponseBodyEventItems extends $tea.Model {
+    constructor(map) {
+        super(map);
+    }
+    static names() {
+        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() {
+        return {
+            eventId: 'number',
+            eventName: 'string',
+            eventPayload: 'string',
+            eventReason: 'string',
+            eventRecordTime: 'string',
+            eventTime: 'string',
+            eventType: 'string',
+            eventUserType: 'string',
+            regionId: 'string',
+            resourceName: 'string',
+            resourceType: 'string',
+        };
+    }
+}
+exports.DescribeEventsResponseBodyEventItems = DescribeEventsResponseBodyEventItems;
 class DescribeParameterTemplatesResponseBodyDataParameters extends $tea.Model {
     constructor(map) {
         super(map);
@@ -4169,60 +4541,6 @@ class DescribePolarxDbInstancesResponseBodyDbInstances extends $tea.Model {
     }
 }
 exports.DescribePolarxDbInstancesResponseBodyDbInstances = DescribePolarxDbInstancesResponseBodyDbInstances;
-class DescribePolarxPgInstancesResponseBodyDBInstances extends $tea.Model {
-    constructor(map) {
-        super(map);
-    }
-    static names() {
-        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() {
-        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',
-        };
-    }
-}
-exports.DescribePolarxPgInstancesResponseBodyDBInstances = DescribePolarxPgInstancesResponseBodyDBInstances;
 class DescribeRegionsResponseBodyRegionsRegionZonesZone extends $tea.Model {
     constructor(map) {
         super(map);
@@ -4658,21 +4976,81 @@ class Client extends openapi_client_1.default {
     }
     async allocateInstancePublicConnectionWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new AllocateInstancePublicConnectionResponse({}));
     }
     async allocateInstancePublicConnection(request) {
         let runtime = new $Util.RuntimeOptions({});
         return await this.allocateInstancePublicConnectionWithOptions(request, runtime);
     }
+    async cancelActiveOperationTasksWithOptions(request, runtime) {
+        tea_util_1.default.validateModel(request);
+        let query = openapi_util_1.default.query(tea_util_1.default.toMap(request));
+        let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.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(await this.callApi(params, req, runtime), new CancelActiveOperationTasksResponse({}));
+    }
+    async cancelActiveOperationTasks(request) {
+        let runtime = new $Util.RuntimeOptions({});
+        return await this.cancelActiveOperationTasksWithOptions(request, runtime);
+    }
     async cancelPolarxOrderWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["RegionId"] = request.regionId;
+        query["ScaleOutToken"] = request.scaleOutToken;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new CancelPolarxOrderResponse({}));
     }
     async cancelPolarxOrder(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4680,10 +5058,26 @@ class Client extends openapi_client_1.default {
     }
     async checkCloudResourceAuthorizedWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["RegionId"] = request.regionId;
+        query["RoleArn"] = request.roleArn;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new CheckCloudResourceAuthorizedResponse({}));
     }
     async checkCloudResourceAuthorized(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4691,10 +5085,32 @@ class Client extends openapi_client_1.default {
     }
     async createAccountWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new CreateAccountResponse({}));
     }
     async createAccount(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4702,10 +5118,26 @@ class Client extends openapi_client_1.default {
     }
     async createBackupWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["BackupType"] = request.backupType;
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new CreateBackupResponse({}));
     }
     async createBackup(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4713,10 +5145,32 @@ class Client extends openapi_client_1.default {
     }
     async createDBWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new CreateDBResponse({}));
     }
     async createDB(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4724,32 +5178,66 @@ class Client extends openapi_client_1.default {
     }
     async createDBInstanceWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new CreateDBInstanceResponse({}));
     }
     async createDBInstance(request) {
         let runtime = new $Util.RuntimeOptions({});
         return await this.createDBInstanceWithOptions(request, runtime);
     }
-    async createPolarxInstanceWithOptions(request, runtime) {
-        tea_util_1.default.validateModel(request);
-        let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
-        });
-        return $tea.cast(await this.doRPCRequest("CreatePolarxInstance", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new CreatePolarxInstanceResponse({}));
-    }
-    async createPolarxInstance(request) {
-        let runtime = new $Util.RuntimeOptions({});
-        return await this.createPolarxInstanceWithOptions(request, runtime);
-    }
     async createPolarxOrderWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["NodeCount"] = request.nodeCount;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new CreatePolarxOrderResponse({}));
     }
     async createPolarxOrder(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4757,10 +5245,28 @@ class Client extends openapi_client_1.default {
     }
     async createSuperAccountWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new CreateSuperAccountResponse({}));
     }
     async createSuperAccount(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4768,10 +5274,28 @@ class Client extends openapi_client_1.default {
     }
     async deleteAccountWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DeleteAccountResponse({}));
     }
     async deleteAccount(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4779,10 +5303,26 @@ class Client extends openapi_client_1.default {
     }
     async deleteDBWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["DbName"] = request.dbName;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DeleteDBResponse({}));
     }
     async deleteDB(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4790,10 +5330,25 @@ class Client extends openapi_client_1.default {
     }
     async deleteDBInstanceWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DeleteDBInstanceResponse({}));
     }
     async deleteDBInstance(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4801,21 +5356,124 @@ class Client extends openapi_client_1.default {
     }
     async describeAccountListWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribeAccountListResponse({}));
     }
     async describeAccountList(request) {
         let runtime = new $Util.RuntimeOptions({});
         return await this.describeAccountListWithOptions(request, runtime);
     }
+    async describeActiveOperationMaintainConfWithOptions(request, runtime) {
+        tea_util_1.default.validateModel(request);
+        let query = {};
+        query["RegionId"] = request.regionId;
+        let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
+            body: tea_util_1.default.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(await this.callApi(params, req, runtime), new DescribeActiveOperationMaintainConfResponse({}));
+    }
+    async describeActiveOperationMaintainConf(request) {
+        let runtime = new $Util.RuntimeOptions({});
+        return await this.describeActiveOperationMaintainConfWithOptions(request, runtime);
+    }
+    async describeActiveOperationTaskCountWithOptions(request, runtime) {
+        tea_util_1.default.validateModel(request);
+        let query = openapi_util_1.default.query(tea_util_1.default.toMap(request));
+        let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.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(await this.callApi(params, req, runtime), new DescribeActiveOperationTaskCountResponse({}));
+    }
+    async describeActiveOperationTaskCount(request) {
+        let runtime = new $Util.RuntimeOptions({});
+        return await this.describeActiveOperationTaskCountWithOptions(request, runtime);
+    }
+    async describeActiveOperationTasksWithOptions(request, runtime) {
+        tea_util_1.default.validateModel(request);
+        let query = openapi_util_1.default.query(tea_util_1.default.toMap(request));
+        let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.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(await this.callApi(params, req, runtime), new DescribeActiveOperationTasksResponse({}));
+    }
+    async describeActiveOperationTasks(request) {
+        let runtime = new $Util.RuntimeOptions({});
+        return await this.describeActiveOperationTasksWithOptions(request, runtime);
+    }
     async describeBackupPolicyWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribeBackupPolicyResponse({}));
     }
     async describeBackupPolicy(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4825,9 +5483,20 @@ class Client extends openapi_client_1.default {
         tea_util_1.default.validateModel(request);
         let query = openapi_util_1.default.query(tea_util_1.default.toMap(request));
         let req = new $OpenApi.OpenApiRequest({
-            query: query,
+            query: openapi_util_1.default.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(await this.doRPCRequest("DescribeBackupSetList", "2020-02-02", "HTTPS", "GET", "AK", "json", req, runtime), new DescribeBackupSetListResponse({}));
+        return $tea.cast(await this.callApi(params, req, runtime), new DescribeBackupSetListResponse({}));
     }
     async describeBackupSetList(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4835,10 +5504,29 @@ class Client extends openapi_client_1.default {
     }
     async describeBinaryLogListWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribeBinaryLogListResponse({}));
     }
     async describeBinaryLogList(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4846,10 +5534,25 @@ class Client extends openapi_client_1.default {
     }
     async describeCharacterSetWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribeCharacterSetResponse({}));
     }
     async describeCharacterSet(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4857,10 +5560,25 @@ class Client extends openapi_client_1.default {
     }
     async describeDBInstanceAttributeWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribeDBInstanceAttributeResponse({}));
     }
     async describeDBInstanceAttribute(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4868,10 +5586,26 @@ class Client extends openapi_client_1.default {
     }
     async describeDBInstanceConfigWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["ConfigName"] = request.configName;
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribeDBInstanceConfigResponse({}));
     }
     async describeDBInstanceConfig(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4879,10 +5613,25 @@ class Client extends openapi_client_1.default {
     }
     async describeDBInstanceSSLWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribeDBInstanceSSLResponse({}));
     }
     async describeDBInstanceSSL(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4890,10 +5639,25 @@ class Client extends openapi_client_1.default {
     }
     async describeDBInstanceTDEWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribeDBInstanceTDEResponse({}));
     }
     async describeDBInstanceTDE(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4901,10 +5665,25 @@ class Client extends openapi_client_1.default {
     }
     async describeDBInstanceTopologyWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribeDBInstanceTopologyResponse({}));
     }
     async describeDBInstanceTopology(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4912,10 +5691,26 @@ class Client extends openapi_client_1.default {
     }
     async describeDBInstancesWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["PageNumber"] = request.pageNumber;
+        query["PageSize"] = request.pageSize;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribeDBInstancesResponse({}));
     }
     async describeDBInstances(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4923,10 +5718,31 @@ class Client extends openapi_client_1.default {
     }
     async describeDBNodePerformanceWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribeDBNodePerformanceResponse({}));
     }
     async describeDBNodePerformance(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4934,10 +5750,26 @@ class Client extends openapi_client_1.default {
     }
     async describeDbListWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["DBName"] = request.DBName;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribeDbListResponse({}));
     }
     async describeDbList(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4945,21 +5777,76 @@ class Client extends openapi_client_1.default {
     }
     async describeDistributeTableListWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["DbName"] = request.dbName;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribeDistributeTableListResponse({}));
     }
     async describeDistributeTableList(request) {
         let runtime = new $Util.RuntimeOptions({});
         return await this.describeDistributeTableListWithOptions(request, runtime);
     }
+    async describeEventsWithOptions(request, runtime) {
+        tea_util_1.default.validateModel(request);
+        let query = openapi_util_1.default.query(tea_util_1.default.toMap(request));
+        let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.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(await this.callApi(params, req, runtime), new DescribeEventsResponse({}));
+    }
+    async describeEvents(request) {
+        let runtime = new $Util.RuntimeOptions({});
+        return await this.describeEventsWithOptions(request, runtime);
+    }
     async describeParameterTemplatesWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceId"] = request.DBInstanceId;
+        query["ParamLevel"] = request.paramLevel;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribeParameterTemplatesResponse({}));
     }
     async describeParameterTemplates(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4967,10 +5854,26 @@ class Client extends openapi_client_1.default {
     }
     async describeParametersWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceId"] = request.DBInstanceId;
+        query["ParamLevel"] = request.paramLevel;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribeParametersResponse({}));
     }
     async describeParameters(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4978,10 +5881,26 @@ class Client extends openapi_client_1.default {
     }
     async describePolarxDataNodesWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["PageNumber"] = request.pageNumber;
+        query["PageSize"] = request.pageSize;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribePolarxDataNodesResponse({}));
     }
     async describePolarxDataNodes(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -4989,29 +5908,46 @@ class Client extends openapi_client_1.default {
     }
     async describePolarxDbInstancesWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribePolarxDbInstancesResponse({}));
     }
     async describePolarxDbInstances(request) {
         let runtime = new $Util.RuntimeOptions({});
         return await this.describePolarxDbInstancesWithOptions(request, runtime);
     }
-    async describePolarxPgInstancesWithOptions(request, runtime) {
-        tea_util_1.default.validateModel(request);
-        let req = new $OpenApi.OpenApiRequest({
-            body: tea_util_1.default.toMap(request),
-        });
-        return $tea.cast(await this.doRPCRequest("DescribePolarxPgInstances", "2020-02-02", "HTTPS", "POST", "AK", "json", req, runtime), new DescribePolarxPgInstancesResponse({}));
-    }
-    async describePolarxPgInstances(request) {
-        let runtime = new $Util.RuntimeOptions({});
-        return await this.describePolarxPgInstancesWithOptions(request, runtime);
-    }
     async describeRegionsWithOptions(runtime) {
         let req = new $OpenApi.OpenApiRequest({});
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribeRegionsResponse({}));
     }
     async describeRegions() {
         let runtime = new $Util.RuntimeOptions({});
@@ -5019,10 +5955,28 @@ class Client extends openapi_client_1.default {
     }
     async describeScaleOutMigrateTaskListWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribeScaleOutMigrateTaskListResponse({}));
     }
     async describeScaleOutMigrateTaskList(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -5030,10 +5984,25 @@ class Client extends openapi_client_1.default {
     }
     async describeSecurityIpsWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribeSecurityIpsResponse({}));
     }
     async describeSecurityIps(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -5041,10 +6010,33 @@ class Client extends openapi_client_1.default {
     }
     async describeTasksWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribeTasksResponse({}));
     }
     async describeTasks(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -5052,10 +6044,25 @@ class Client extends openapi_client_1.default {
     }
     async describeUserEncryptionKeyListWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new DescribeUserEncryptionKeyListResponse({}));
     }
     async describeUserEncryptionKeyList(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -5063,10 +6070,26 @@ class Client extends openapi_client_1.default {
     }
     async getPolarxCommodityWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["OrderType"] = request.orderType;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new GetPolarxCommodityResponse({}));
     }
     async getPolarxCommodity(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -5074,21 +6097,106 @@ class Client extends openapi_client_1.default {
     }
     async modifyAccountDescriptionWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new ModifyAccountDescriptionResponse({}));
     }
     async modifyAccountDescription(request) {
         let runtime = new $Util.RuntimeOptions({});
         return await this.modifyAccountDescriptionWithOptions(request, runtime);
     }
+    async modifyActiveOperationMaintainConfWithOptions(request, runtime) {
+        tea_util_1.default.validateModel(request);
+        let query = openapi_util_1.default.query(tea_util_1.default.toMap(request));
+        let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.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(await this.callApi(params, req, runtime), new ModifyActiveOperationMaintainConfResponse({}));
+    }
+    async modifyActiveOperationMaintainConf(request) {
+        let runtime = new $Util.RuntimeOptions({});
+        return await this.modifyActiveOperationMaintainConfWithOptions(request, runtime);
+    }
+    async modifyActiveOperationTasksWithOptions(request, runtime) {
+        tea_util_1.default.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: openapi_util_1.default.query(query),
+            body: tea_util_1.default.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(await this.callApi(params, req, runtime), new ModifyActiveOperationTasksResponse({}));
+    }
+    async modifyActiveOperationTasks(request) {
+        let runtime = new $Util.RuntimeOptions({});
+        return await this.modifyActiveOperationTasksWithOptions(request, runtime);
+    }
     async modifyDBInstanceClassWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new ModifyDBInstanceClassResponse({}));
     }
     async modifyDBInstanceClass(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -5096,10 +6204,27 @@ class Client extends openapi_client_1.default {
     }
     async modifyDBInstanceConfigWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new ModifyDBInstanceConfigResponse({}));
     }
     async modifyDBInstanceConfig(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -5107,10 +6232,26 @@ class Client extends openapi_client_1.default {
     }
     async modifyDBInstanceDescriptionWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceDescription"] = request.DBInstanceDescription;
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new ModifyDBInstanceDescriptionResponse({}));
     }
     async modifyDBInstanceDescription(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -5118,10 +6259,27 @@ class Client extends openapi_client_1.default {
     }
     async modifyDatabaseDescriptionWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new ModifyDatabaseDescriptionResponse({}));
     }
     async modifyDatabaseDescription(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -5129,10 +6287,28 @@ class Client extends openapi_client_1.default {
     }
     async modifyParameterWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new ModifyParameterResponse({}));
     }
     async modifyParameter(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -5140,10 +6316,28 @@ class Client extends openapi_client_1.default {
     }
     async modifySecurityIpsWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new ModifySecurityIpsResponse({}));
     }
     async modifySecurityIps(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -5151,10 +6345,30 @@ class Client extends openapi_client_1.default {
     }
     async releaseInstancePublicConnectionWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new ReleaseInstancePublicConnectionResponse({}));
     }
     async releaseInstancePublicConnection(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -5162,10 +6376,25 @@ class Client extends openapi_client_1.default {
     }
     async restartDBInstanceWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new RestartDBInstanceResponse({}));
     }
     async restartDBInstance(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -5173,10 +6402,35 @@ class Client extends openapi_client_1.default {
     }
     async updateBackupPolicyWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new UpdateBackupPolicyResponse({}));
     }
     async updateBackupPolicy(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -5184,10 +6438,27 @@ class Client extends openapi_client_1.default {
     }
     async updateDBInstanceSSLWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new UpdateDBInstanceSSLResponse({}));
     }
     async updateDBInstanceSSL(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -5195,10 +6466,28 @@ class Client extends openapi_client_1.default {
     }
     async updateDBInstanceTDEWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new UpdateDBInstanceTDEResponse({}));
     }
     async updateDBInstanceTDE(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -5206,10 +6495,27 @@ class Client extends openapi_client_1.default {
     }
     async updatePolarDBXInstanceNodeWithOptions(request, runtime) {
         tea_util_1.default.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: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new UpdatePolarDBXInstanceNodeResponse({}));
     }
     async updatePolarDBXInstanceNode(request) {
         let runtime = new $Util.RuntimeOptions({});
@@ -5217,10 +6523,25 @@ class Client extends openapi_client_1.default {
     }
     async upgradeDBInstanceKernelVersionWithOptions(request, runtime) {
         tea_util_1.default.validateModel(request);
+        let query = {};
+        query["DBInstanceName"] = request.DBInstanceName;
+        query["RegionId"] = request.regionId;
         let req = new $OpenApi.OpenApiRequest({
+            query: openapi_util_1.default.query(query),
             body: tea_util_1.default.toMap(request),
         });
-        return $tea.cast(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(await this.callApi(params, req, runtime), new UpgradeDBInstanceKernelVersionResponse({}));
     }
     async upgradeDBInstanceKernelVersion(request) {
         let runtime = new $Util.RuntimeOptions({});