@alicloud/rds20140815 2.3.5 → 2.3.7
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/client.d.ts +753 -19
- package/dist/client.js +1466 -0
- package/dist/client.js.map +1 -1
- package/package.json +1 -1
- package/src/client.ts +1836 -0
package/dist/client.js
CHANGED
|
@@ -303,6 +303,74 @@ class AllocateReadWriteSplittingConnectionResponse extends $tea.Model {
|
|
|
303
303
|
}
|
|
304
304
|
}
|
|
305
305
|
exports.AllocateReadWriteSplittingConnectionResponse = AllocateReadWriteSplittingConnectionResponse;
|
|
306
|
+
class AttachWhitelistTemplateToInstanceRequest extends $tea.Model {
|
|
307
|
+
constructor(map) {
|
|
308
|
+
super(map);
|
|
309
|
+
}
|
|
310
|
+
static names() {
|
|
311
|
+
return {
|
|
312
|
+
insName: 'InsName',
|
|
313
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
314
|
+
resourceOwnerId: 'ResourceOwnerId',
|
|
315
|
+
templateId: 'TemplateId',
|
|
316
|
+
};
|
|
317
|
+
}
|
|
318
|
+
static types() {
|
|
319
|
+
return {
|
|
320
|
+
insName: 'string',
|
|
321
|
+
resourceOwnerAccount: 'string',
|
|
322
|
+
resourceOwnerId: 'number',
|
|
323
|
+
templateId: 'number',
|
|
324
|
+
};
|
|
325
|
+
}
|
|
326
|
+
}
|
|
327
|
+
exports.AttachWhitelistTemplateToInstanceRequest = AttachWhitelistTemplateToInstanceRequest;
|
|
328
|
+
class AttachWhitelistTemplateToInstanceResponseBody extends $tea.Model {
|
|
329
|
+
constructor(map) {
|
|
330
|
+
super(map);
|
|
331
|
+
}
|
|
332
|
+
static names() {
|
|
333
|
+
return {
|
|
334
|
+
code: 'Code',
|
|
335
|
+
data: 'Data',
|
|
336
|
+
httpStatusCode: 'HttpStatusCode',
|
|
337
|
+
message: 'Message',
|
|
338
|
+
requestId: 'RequestId',
|
|
339
|
+
success: 'Success',
|
|
340
|
+
};
|
|
341
|
+
}
|
|
342
|
+
static types() {
|
|
343
|
+
return {
|
|
344
|
+
code: 'string',
|
|
345
|
+
data: AttachWhitelistTemplateToInstanceResponseBodyData,
|
|
346
|
+
httpStatusCode: 'number',
|
|
347
|
+
message: 'string',
|
|
348
|
+
requestId: 'string',
|
|
349
|
+
success: 'boolean',
|
|
350
|
+
};
|
|
351
|
+
}
|
|
352
|
+
}
|
|
353
|
+
exports.AttachWhitelistTemplateToInstanceResponseBody = AttachWhitelistTemplateToInstanceResponseBody;
|
|
354
|
+
class AttachWhitelistTemplateToInstanceResponse extends $tea.Model {
|
|
355
|
+
constructor(map) {
|
|
356
|
+
super(map);
|
|
357
|
+
}
|
|
358
|
+
static names() {
|
|
359
|
+
return {
|
|
360
|
+
headers: 'headers',
|
|
361
|
+
statusCode: 'statusCode',
|
|
362
|
+
body: 'body',
|
|
363
|
+
};
|
|
364
|
+
}
|
|
365
|
+
static types() {
|
|
366
|
+
return {
|
|
367
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
368
|
+
statusCode: 'number',
|
|
369
|
+
body: AttachWhitelistTemplateToInstanceResponseBody,
|
|
370
|
+
};
|
|
371
|
+
}
|
|
372
|
+
}
|
|
373
|
+
exports.AttachWhitelistTemplateToInstanceResponse = AttachWhitelistTemplateToInstanceResponse;
|
|
306
374
|
class CalculateDBInstanceWeightRequest extends $tea.Model {
|
|
307
375
|
constructor(map) {
|
|
308
376
|
super(map);
|
|
@@ -2895,6 +2963,78 @@ class CreateParameterGroupResponse extends $tea.Model {
|
|
|
2895
2963
|
}
|
|
2896
2964
|
}
|
|
2897
2965
|
exports.CreateParameterGroupResponse = CreateParameterGroupResponse;
|
|
2966
|
+
class CreatePostgresExtensionsRequest extends $tea.Model {
|
|
2967
|
+
constructor(map) {
|
|
2968
|
+
super(map);
|
|
2969
|
+
}
|
|
2970
|
+
static names() {
|
|
2971
|
+
return {
|
|
2972
|
+
accountName: 'AccountName',
|
|
2973
|
+
clientToken: 'ClientToken',
|
|
2974
|
+
DBInstanceId: 'DBInstanceId',
|
|
2975
|
+
DBNames: 'DBNames',
|
|
2976
|
+
extensions: 'Extensions',
|
|
2977
|
+
ownerAccount: 'OwnerAccount',
|
|
2978
|
+
ownerId: 'OwnerId',
|
|
2979
|
+
resourceGroupId: 'ResourceGroupId',
|
|
2980
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
2981
|
+
resourceOwnerId: 'ResourceOwnerId',
|
|
2982
|
+
sourceDatabase: 'SourceDatabase',
|
|
2983
|
+
};
|
|
2984
|
+
}
|
|
2985
|
+
static types() {
|
|
2986
|
+
return {
|
|
2987
|
+
accountName: 'string',
|
|
2988
|
+
clientToken: 'string',
|
|
2989
|
+
DBInstanceId: 'string',
|
|
2990
|
+
DBNames: 'string',
|
|
2991
|
+
extensions: 'string',
|
|
2992
|
+
ownerAccount: 'string',
|
|
2993
|
+
ownerId: 'number',
|
|
2994
|
+
resourceGroupId: 'string',
|
|
2995
|
+
resourceOwnerAccount: 'string',
|
|
2996
|
+
resourceOwnerId: 'number',
|
|
2997
|
+
sourceDatabase: 'string',
|
|
2998
|
+
};
|
|
2999
|
+
}
|
|
3000
|
+
}
|
|
3001
|
+
exports.CreatePostgresExtensionsRequest = CreatePostgresExtensionsRequest;
|
|
3002
|
+
class CreatePostgresExtensionsResponseBody extends $tea.Model {
|
|
3003
|
+
constructor(map) {
|
|
3004
|
+
super(map);
|
|
3005
|
+
}
|
|
3006
|
+
static names() {
|
|
3007
|
+
return {
|
|
3008
|
+
requestId: 'RequestId',
|
|
3009
|
+
};
|
|
3010
|
+
}
|
|
3011
|
+
static types() {
|
|
3012
|
+
return {
|
|
3013
|
+
requestId: 'string',
|
|
3014
|
+
};
|
|
3015
|
+
}
|
|
3016
|
+
}
|
|
3017
|
+
exports.CreatePostgresExtensionsResponseBody = CreatePostgresExtensionsResponseBody;
|
|
3018
|
+
class CreatePostgresExtensionsResponse extends $tea.Model {
|
|
3019
|
+
constructor(map) {
|
|
3020
|
+
super(map);
|
|
3021
|
+
}
|
|
3022
|
+
static names() {
|
|
3023
|
+
return {
|
|
3024
|
+
headers: 'headers',
|
|
3025
|
+
statusCode: 'statusCode',
|
|
3026
|
+
body: 'body',
|
|
3027
|
+
};
|
|
3028
|
+
}
|
|
3029
|
+
static types() {
|
|
3030
|
+
return {
|
|
3031
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3032
|
+
statusCode: 'number',
|
|
3033
|
+
body: CreatePostgresExtensionsResponseBody,
|
|
3034
|
+
};
|
|
3035
|
+
}
|
|
3036
|
+
}
|
|
3037
|
+
exports.CreatePostgresExtensionsResponse = CreatePostgresExtensionsResponse;
|
|
2898
3038
|
class CreateReadOnlyDBInstanceRequest extends $tea.Model {
|
|
2899
3039
|
constructor(map) {
|
|
2900
3040
|
super(map);
|
|
@@ -3997,6 +4137,74 @@ class DeleteParameterGroupResponse extends $tea.Model {
|
|
|
3997
4137
|
}
|
|
3998
4138
|
}
|
|
3999
4139
|
exports.DeleteParameterGroupResponse = DeleteParameterGroupResponse;
|
|
4140
|
+
class DeletePostgresExtensionsRequest extends $tea.Model {
|
|
4141
|
+
constructor(map) {
|
|
4142
|
+
super(map);
|
|
4143
|
+
}
|
|
4144
|
+
static names() {
|
|
4145
|
+
return {
|
|
4146
|
+
clientToken: 'ClientToken',
|
|
4147
|
+
DBInstanceId: 'DBInstanceId',
|
|
4148
|
+
DBNames: 'DBNames',
|
|
4149
|
+
extensions: 'Extensions',
|
|
4150
|
+
ownerAccount: 'OwnerAccount',
|
|
4151
|
+
ownerId: 'OwnerId',
|
|
4152
|
+
resourceGroupId: 'ResourceGroupId',
|
|
4153
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
4154
|
+
resourceOwnerId: 'ResourceOwnerId',
|
|
4155
|
+
};
|
|
4156
|
+
}
|
|
4157
|
+
static types() {
|
|
4158
|
+
return {
|
|
4159
|
+
clientToken: 'string',
|
|
4160
|
+
DBInstanceId: 'string',
|
|
4161
|
+
DBNames: 'string',
|
|
4162
|
+
extensions: 'string',
|
|
4163
|
+
ownerAccount: 'string',
|
|
4164
|
+
ownerId: 'number',
|
|
4165
|
+
resourceGroupId: 'string',
|
|
4166
|
+
resourceOwnerAccount: 'string',
|
|
4167
|
+
resourceOwnerId: 'number',
|
|
4168
|
+
};
|
|
4169
|
+
}
|
|
4170
|
+
}
|
|
4171
|
+
exports.DeletePostgresExtensionsRequest = DeletePostgresExtensionsRequest;
|
|
4172
|
+
class DeletePostgresExtensionsResponseBody extends $tea.Model {
|
|
4173
|
+
constructor(map) {
|
|
4174
|
+
super(map);
|
|
4175
|
+
}
|
|
4176
|
+
static names() {
|
|
4177
|
+
return {
|
|
4178
|
+
requestId: 'RequestId',
|
|
4179
|
+
};
|
|
4180
|
+
}
|
|
4181
|
+
static types() {
|
|
4182
|
+
return {
|
|
4183
|
+
requestId: 'string',
|
|
4184
|
+
};
|
|
4185
|
+
}
|
|
4186
|
+
}
|
|
4187
|
+
exports.DeletePostgresExtensionsResponseBody = DeletePostgresExtensionsResponseBody;
|
|
4188
|
+
class DeletePostgresExtensionsResponse extends $tea.Model {
|
|
4189
|
+
constructor(map) {
|
|
4190
|
+
super(map);
|
|
4191
|
+
}
|
|
4192
|
+
static names() {
|
|
4193
|
+
return {
|
|
4194
|
+
headers: 'headers',
|
|
4195
|
+
statusCode: 'statusCode',
|
|
4196
|
+
body: 'body',
|
|
4197
|
+
};
|
|
4198
|
+
}
|
|
4199
|
+
static types() {
|
|
4200
|
+
return {
|
|
4201
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
4202
|
+
statusCode: 'number',
|
|
4203
|
+
body: DeletePostgresExtensionsResponseBody,
|
|
4204
|
+
};
|
|
4205
|
+
}
|
|
4206
|
+
}
|
|
4207
|
+
exports.DeletePostgresExtensionsResponse = DeletePostgresExtensionsResponse;
|
|
4000
4208
|
class DeleteSecretRequest extends $tea.Model {
|
|
4001
4209
|
constructor(map) {
|
|
4002
4210
|
super(map);
|
|
@@ -4581,6 +4789,78 @@ class DescribeActiveOperationTasksResponse extends $tea.Model {
|
|
|
4581
4789
|
}
|
|
4582
4790
|
}
|
|
4583
4791
|
exports.DescribeActiveOperationTasksResponse = DescribeActiveOperationTasksResponse;
|
|
4792
|
+
class DescribeAllWhitelistTemplateRequest extends $tea.Model {
|
|
4793
|
+
constructor(map) {
|
|
4794
|
+
super(map);
|
|
4795
|
+
}
|
|
4796
|
+
static names() {
|
|
4797
|
+
return {
|
|
4798
|
+
fuzzySearch: 'FuzzySearch',
|
|
4799
|
+
maxRecordsPerPage: 'MaxRecordsPerPage',
|
|
4800
|
+
pageNumbers: 'PageNumbers',
|
|
4801
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
4802
|
+
resourceOwnerId: 'ResourceOwnerId',
|
|
4803
|
+
templateName: 'TemplateName',
|
|
4804
|
+
};
|
|
4805
|
+
}
|
|
4806
|
+
static types() {
|
|
4807
|
+
return {
|
|
4808
|
+
fuzzySearch: 'boolean',
|
|
4809
|
+
maxRecordsPerPage: 'number',
|
|
4810
|
+
pageNumbers: 'number',
|
|
4811
|
+
resourceOwnerAccount: 'string',
|
|
4812
|
+
resourceOwnerId: 'number',
|
|
4813
|
+
templateName: 'string',
|
|
4814
|
+
};
|
|
4815
|
+
}
|
|
4816
|
+
}
|
|
4817
|
+
exports.DescribeAllWhitelistTemplateRequest = DescribeAllWhitelistTemplateRequest;
|
|
4818
|
+
class DescribeAllWhitelistTemplateResponseBody extends $tea.Model {
|
|
4819
|
+
constructor(map) {
|
|
4820
|
+
super(map);
|
|
4821
|
+
}
|
|
4822
|
+
static names() {
|
|
4823
|
+
return {
|
|
4824
|
+
code: 'Code',
|
|
4825
|
+
data: 'Data',
|
|
4826
|
+
httpStatusCode: 'HttpStatusCode',
|
|
4827
|
+
message: 'Message',
|
|
4828
|
+
requestId: 'RequestId',
|
|
4829
|
+
success: 'Success',
|
|
4830
|
+
};
|
|
4831
|
+
}
|
|
4832
|
+
static types() {
|
|
4833
|
+
return {
|
|
4834
|
+
code: 'string',
|
|
4835
|
+
data: DescribeAllWhitelistTemplateResponseBodyData,
|
|
4836
|
+
httpStatusCode: 'number',
|
|
4837
|
+
message: 'string',
|
|
4838
|
+
requestId: 'string',
|
|
4839
|
+
success: 'boolean',
|
|
4840
|
+
};
|
|
4841
|
+
}
|
|
4842
|
+
}
|
|
4843
|
+
exports.DescribeAllWhitelistTemplateResponseBody = DescribeAllWhitelistTemplateResponseBody;
|
|
4844
|
+
class DescribeAllWhitelistTemplateResponse extends $tea.Model {
|
|
4845
|
+
constructor(map) {
|
|
4846
|
+
super(map);
|
|
4847
|
+
}
|
|
4848
|
+
static names() {
|
|
4849
|
+
return {
|
|
4850
|
+
headers: 'headers',
|
|
4851
|
+
statusCode: 'statusCode',
|
|
4852
|
+
body: 'body',
|
|
4853
|
+
};
|
|
4854
|
+
}
|
|
4855
|
+
static types() {
|
|
4856
|
+
return {
|
|
4857
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
4858
|
+
statusCode: 'number',
|
|
4859
|
+
body: DescribeAllWhitelistTemplateResponseBody,
|
|
4860
|
+
};
|
|
4861
|
+
}
|
|
4862
|
+
}
|
|
4863
|
+
exports.DescribeAllWhitelistTemplateResponse = DescribeAllWhitelistTemplateResponse;
|
|
4584
4864
|
class DescribeAnalyticdbByPrimaryDBInstanceRequest extends $tea.Model {
|
|
4585
4865
|
constructor(map) {
|
|
4586
4866
|
super(map);
|
|
@@ -9233,6 +9513,72 @@ class DescribeInstanceKeywordsResponse extends $tea.Model {
|
|
|
9233
9513
|
}
|
|
9234
9514
|
}
|
|
9235
9515
|
exports.DescribeInstanceKeywordsResponse = DescribeInstanceKeywordsResponse;
|
|
9516
|
+
class DescribeInstanceLinkedWhitelistTemplateRequest extends $tea.Model {
|
|
9517
|
+
constructor(map) {
|
|
9518
|
+
super(map);
|
|
9519
|
+
}
|
|
9520
|
+
static names() {
|
|
9521
|
+
return {
|
|
9522
|
+
insName: 'InsName',
|
|
9523
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
9524
|
+
resourceOwnerId: 'ResourceOwnerId',
|
|
9525
|
+
};
|
|
9526
|
+
}
|
|
9527
|
+
static types() {
|
|
9528
|
+
return {
|
|
9529
|
+
insName: 'string',
|
|
9530
|
+
resourceOwnerAccount: 'string',
|
|
9531
|
+
resourceOwnerId: 'number',
|
|
9532
|
+
};
|
|
9533
|
+
}
|
|
9534
|
+
}
|
|
9535
|
+
exports.DescribeInstanceLinkedWhitelistTemplateRequest = DescribeInstanceLinkedWhitelistTemplateRequest;
|
|
9536
|
+
class DescribeInstanceLinkedWhitelistTemplateResponseBody extends $tea.Model {
|
|
9537
|
+
constructor(map) {
|
|
9538
|
+
super(map);
|
|
9539
|
+
}
|
|
9540
|
+
static names() {
|
|
9541
|
+
return {
|
|
9542
|
+
code: 'Code',
|
|
9543
|
+
data: 'Data',
|
|
9544
|
+
httpStatusCode: 'HttpStatusCode',
|
|
9545
|
+
message: 'Message',
|
|
9546
|
+
requestId: 'RequestId',
|
|
9547
|
+
success: 'Success',
|
|
9548
|
+
};
|
|
9549
|
+
}
|
|
9550
|
+
static types() {
|
|
9551
|
+
return {
|
|
9552
|
+
code: 'string',
|
|
9553
|
+
data: DescribeInstanceLinkedWhitelistTemplateResponseBodyData,
|
|
9554
|
+
httpStatusCode: 'number',
|
|
9555
|
+
message: 'string',
|
|
9556
|
+
requestId: 'string',
|
|
9557
|
+
success: 'boolean',
|
|
9558
|
+
};
|
|
9559
|
+
}
|
|
9560
|
+
}
|
|
9561
|
+
exports.DescribeInstanceLinkedWhitelistTemplateResponseBody = DescribeInstanceLinkedWhitelistTemplateResponseBody;
|
|
9562
|
+
class DescribeInstanceLinkedWhitelistTemplateResponse extends $tea.Model {
|
|
9563
|
+
constructor(map) {
|
|
9564
|
+
super(map);
|
|
9565
|
+
}
|
|
9566
|
+
static names() {
|
|
9567
|
+
return {
|
|
9568
|
+
headers: 'headers',
|
|
9569
|
+
statusCode: 'statusCode',
|
|
9570
|
+
body: 'body',
|
|
9571
|
+
};
|
|
9572
|
+
}
|
|
9573
|
+
static types() {
|
|
9574
|
+
return {
|
|
9575
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
9576
|
+
statusCode: 'number',
|
|
9577
|
+
body: DescribeInstanceLinkedWhitelistTemplateResponseBody,
|
|
9578
|
+
};
|
|
9579
|
+
}
|
|
9580
|
+
}
|
|
9581
|
+
exports.DescribeInstanceLinkedWhitelistTemplateResponse = DescribeInstanceLinkedWhitelistTemplateResponse;
|
|
9236
9582
|
class DescribeLocalAvailableRecoveryTimeRequest extends $tea.Model {
|
|
9237
9583
|
constructor(map) {
|
|
9238
9584
|
super(map);
|
|
@@ -10203,6 +10549,78 @@ class DescribeParametersResponse extends $tea.Model {
|
|
|
10203
10549
|
}
|
|
10204
10550
|
}
|
|
10205
10551
|
exports.DescribeParametersResponse = DescribeParametersResponse;
|
|
10552
|
+
class DescribePostgresExtensionsRequest extends $tea.Model {
|
|
10553
|
+
constructor(map) {
|
|
10554
|
+
super(map);
|
|
10555
|
+
}
|
|
10556
|
+
static names() {
|
|
10557
|
+
return {
|
|
10558
|
+
clientToken: 'ClientToken',
|
|
10559
|
+
DBInstanceId: 'DBInstanceId',
|
|
10560
|
+
DBName: 'DBName',
|
|
10561
|
+
ownerAccount: 'OwnerAccount',
|
|
10562
|
+
ownerId: 'OwnerId',
|
|
10563
|
+
resourceGroupId: 'ResourceGroupId',
|
|
10564
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
10565
|
+
resourceOwnerId: 'ResourceOwnerId',
|
|
10566
|
+
};
|
|
10567
|
+
}
|
|
10568
|
+
static types() {
|
|
10569
|
+
return {
|
|
10570
|
+
clientToken: 'string',
|
|
10571
|
+
DBInstanceId: 'string',
|
|
10572
|
+
DBName: 'string',
|
|
10573
|
+
ownerAccount: 'string',
|
|
10574
|
+
ownerId: 'number',
|
|
10575
|
+
resourceGroupId: 'string',
|
|
10576
|
+
resourceOwnerAccount: 'string',
|
|
10577
|
+
resourceOwnerId: 'number',
|
|
10578
|
+
};
|
|
10579
|
+
}
|
|
10580
|
+
}
|
|
10581
|
+
exports.DescribePostgresExtensionsRequest = DescribePostgresExtensionsRequest;
|
|
10582
|
+
class DescribePostgresExtensionsResponseBody extends $tea.Model {
|
|
10583
|
+
constructor(map) {
|
|
10584
|
+
super(map);
|
|
10585
|
+
}
|
|
10586
|
+
static names() {
|
|
10587
|
+
return {
|
|
10588
|
+
installedExtensions: 'InstalledExtensions',
|
|
10589
|
+
overview: 'Overview',
|
|
10590
|
+
requestId: 'RequestId',
|
|
10591
|
+
uninstalledExtensions: 'UninstalledExtensions',
|
|
10592
|
+
};
|
|
10593
|
+
}
|
|
10594
|
+
static types() {
|
|
10595
|
+
return {
|
|
10596
|
+
installedExtensions: { 'type': 'array', 'itemType': DescribePostgresExtensionsResponseBodyInstalledExtensions },
|
|
10597
|
+
overview: { 'type': 'map', 'keyType': 'string', 'valueType': 'any' },
|
|
10598
|
+
requestId: 'string',
|
|
10599
|
+
uninstalledExtensions: { 'type': 'array', 'itemType': DescribePostgresExtensionsResponseBodyUninstalledExtensions },
|
|
10600
|
+
};
|
|
10601
|
+
}
|
|
10602
|
+
}
|
|
10603
|
+
exports.DescribePostgresExtensionsResponseBody = DescribePostgresExtensionsResponseBody;
|
|
10604
|
+
class DescribePostgresExtensionsResponse extends $tea.Model {
|
|
10605
|
+
constructor(map) {
|
|
10606
|
+
super(map);
|
|
10607
|
+
}
|
|
10608
|
+
static names() {
|
|
10609
|
+
return {
|
|
10610
|
+
headers: 'headers',
|
|
10611
|
+
statusCode: 'statusCode',
|
|
10612
|
+
body: 'body',
|
|
10613
|
+
};
|
|
10614
|
+
}
|
|
10615
|
+
static types() {
|
|
10616
|
+
return {
|
|
10617
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
10618
|
+
statusCode: 'number',
|
|
10619
|
+
body: DescribePostgresExtensionsResponseBody,
|
|
10620
|
+
};
|
|
10621
|
+
}
|
|
10622
|
+
}
|
|
10623
|
+
exports.DescribePostgresExtensionsResponse = DescribePostgresExtensionsResponse;
|
|
10206
10624
|
class DescribePriceRequest extends $tea.Model {
|
|
10207
10625
|
constructor(map) {
|
|
10208
10626
|
super(map);
|
|
@@ -11989,6 +12407,138 @@ class DescribeVSwitchesResponse extends $tea.Model {
|
|
|
11989
12407
|
}
|
|
11990
12408
|
}
|
|
11991
12409
|
exports.DescribeVSwitchesResponse = DescribeVSwitchesResponse;
|
|
12410
|
+
class DescribeWhitelistTemplateRequest extends $tea.Model {
|
|
12411
|
+
constructor(map) {
|
|
12412
|
+
super(map);
|
|
12413
|
+
}
|
|
12414
|
+
static names() {
|
|
12415
|
+
return {
|
|
12416
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
12417
|
+
resourceOwnerId: 'ResourceOwnerId',
|
|
12418
|
+
templateId: 'TemplateId',
|
|
12419
|
+
};
|
|
12420
|
+
}
|
|
12421
|
+
static types() {
|
|
12422
|
+
return {
|
|
12423
|
+
resourceOwnerAccount: 'string',
|
|
12424
|
+
resourceOwnerId: 'number',
|
|
12425
|
+
templateId: 'number',
|
|
12426
|
+
};
|
|
12427
|
+
}
|
|
12428
|
+
}
|
|
12429
|
+
exports.DescribeWhitelistTemplateRequest = DescribeWhitelistTemplateRequest;
|
|
12430
|
+
class DescribeWhitelistTemplateResponseBody extends $tea.Model {
|
|
12431
|
+
constructor(map) {
|
|
12432
|
+
super(map);
|
|
12433
|
+
}
|
|
12434
|
+
static names() {
|
|
12435
|
+
return {
|
|
12436
|
+
code: 'Code',
|
|
12437
|
+
data: 'Data',
|
|
12438
|
+
httpStatusCode: 'HttpStatusCode',
|
|
12439
|
+
message: 'Message',
|
|
12440
|
+
requestId: 'RequestId',
|
|
12441
|
+
success: 'Success',
|
|
12442
|
+
};
|
|
12443
|
+
}
|
|
12444
|
+
static types() {
|
|
12445
|
+
return {
|
|
12446
|
+
code: 'string',
|
|
12447
|
+
data: DescribeWhitelistTemplateResponseBodyData,
|
|
12448
|
+
httpStatusCode: 'number',
|
|
12449
|
+
message: 'string',
|
|
12450
|
+
requestId: 'string',
|
|
12451
|
+
success: 'boolean',
|
|
12452
|
+
};
|
|
12453
|
+
}
|
|
12454
|
+
}
|
|
12455
|
+
exports.DescribeWhitelistTemplateResponseBody = DescribeWhitelistTemplateResponseBody;
|
|
12456
|
+
class DescribeWhitelistTemplateResponse extends $tea.Model {
|
|
12457
|
+
constructor(map) {
|
|
12458
|
+
super(map);
|
|
12459
|
+
}
|
|
12460
|
+
static names() {
|
|
12461
|
+
return {
|
|
12462
|
+
headers: 'headers',
|
|
12463
|
+
statusCode: 'statusCode',
|
|
12464
|
+
body: 'body',
|
|
12465
|
+
};
|
|
12466
|
+
}
|
|
12467
|
+
static types() {
|
|
12468
|
+
return {
|
|
12469
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
12470
|
+
statusCode: 'number',
|
|
12471
|
+
body: DescribeWhitelistTemplateResponseBody,
|
|
12472
|
+
};
|
|
12473
|
+
}
|
|
12474
|
+
}
|
|
12475
|
+
exports.DescribeWhitelistTemplateResponse = DescribeWhitelistTemplateResponse;
|
|
12476
|
+
class DescribeWhitelistTemplateLinkedInstanceRequest extends $tea.Model {
|
|
12477
|
+
constructor(map) {
|
|
12478
|
+
super(map);
|
|
12479
|
+
}
|
|
12480
|
+
static names() {
|
|
12481
|
+
return {
|
|
12482
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
12483
|
+
resourceOwnerId: 'ResourceOwnerId',
|
|
12484
|
+
templateId: 'TemplateId',
|
|
12485
|
+
};
|
|
12486
|
+
}
|
|
12487
|
+
static types() {
|
|
12488
|
+
return {
|
|
12489
|
+
resourceOwnerAccount: 'string',
|
|
12490
|
+
resourceOwnerId: 'number',
|
|
12491
|
+
templateId: 'number',
|
|
12492
|
+
};
|
|
12493
|
+
}
|
|
12494
|
+
}
|
|
12495
|
+
exports.DescribeWhitelistTemplateLinkedInstanceRequest = DescribeWhitelistTemplateLinkedInstanceRequest;
|
|
12496
|
+
class DescribeWhitelistTemplateLinkedInstanceResponseBody extends $tea.Model {
|
|
12497
|
+
constructor(map) {
|
|
12498
|
+
super(map);
|
|
12499
|
+
}
|
|
12500
|
+
static names() {
|
|
12501
|
+
return {
|
|
12502
|
+
code: 'Code',
|
|
12503
|
+
data: 'Data',
|
|
12504
|
+
httpStatusCode: 'HttpStatusCode',
|
|
12505
|
+
message: 'Message',
|
|
12506
|
+
requestId: 'RequestId',
|
|
12507
|
+
success: 'Success',
|
|
12508
|
+
};
|
|
12509
|
+
}
|
|
12510
|
+
static types() {
|
|
12511
|
+
return {
|
|
12512
|
+
code: 'string',
|
|
12513
|
+
data: DescribeWhitelistTemplateLinkedInstanceResponseBodyData,
|
|
12514
|
+
httpStatusCode: 'number',
|
|
12515
|
+
message: 'string',
|
|
12516
|
+
requestId: 'string',
|
|
12517
|
+
success: 'boolean',
|
|
12518
|
+
};
|
|
12519
|
+
}
|
|
12520
|
+
}
|
|
12521
|
+
exports.DescribeWhitelistTemplateLinkedInstanceResponseBody = DescribeWhitelistTemplateLinkedInstanceResponseBody;
|
|
12522
|
+
class DescribeWhitelistTemplateLinkedInstanceResponse extends $tea.Model {
|
|
12523
|
+
constructor(map) {
|
|
12524
|
+
super(map);
|
|
12525
|
+
}
|
|
12526
|
+
static names() {
|
|
12527
|
+
return {
|
|
12528
|
+
headers: 'headers',
|
|
12529
|
+
statusCode: 'statusCode',
|
|
12530
|
+
body: 'body',
|
|
12531
|
+
};
|
|
12532
|
+
}
|
|
12533
|
+
static types() {
|
|
12534
|
+
return {
|
|
12535
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
12536
|
+
statusCode: 'number',
|
|
12537
|
+
body: DescribeWhitelistTemplateLinkedInstanceResponseBody,
|
|
12538
|
+
};
|
|
12539
|
+
}
|
|
12540
|
+
}
|
|
12541
|
+
exports.DescribeWhitelistTemplateLinkedInstanceResponse = DescribeWhitelistTemplateLinkedInstanceResponse;
|
|
11992
12542
|
class DestroyDBInstanceRequest extends $tea.Model {
|
|
11993
12543
|
constructor(map) {
|
|
11994
12544
|
super(map);
|
|
@@ -12107,6 +12657,74 @@ class DetachGadInstanceMemberResponse extends $tea.Model {
|
|
|
12107
12657
|
}
|
|
12108
12658
|
}
|
|
12109
12659
|
exports.DetachGadInstanceMemberResponse = DetachGadInstanceMemberResponse;
|
|
12660
|
+
class DetachWhitelistTemplateToInstanceRequest extends $tea.Model {
|
|
12661
|
+
constructor(map) {
|
|
12662
|
+
super(map);
|
|
12663
|
+
}
|
|
12664
|
+
static names() {
|
|
12665
|
+
return {
|
|
12666
|
+
insName: 'InsName',
|
|
12667
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
12668
|
+
resourceOwnerId: 'ResourceOwnerId',
|
|
12669
|
+
templateId: 'TemplateId',
|
|
12670
|
+
};
|
|
12671
|
+
}
|
|
12672
|
+
static types() {
|
|
12673
|
+
return {
|
|
12674
|
+
insName: 'string',
|
|
12675
|
+
resourceOwnerAccount: 'string',
|
|
12676
|
+
resourceOwnerId: 'number',
|
|
12677
|
+
templateId: 'number',
|
|
12678
|
+
};
|
|
12679
|
+
}
|
|
12680
|
+
}
|
|
12681
|
+
exports.DetachWhitelistTemplateToInstanceRequest = DetachWhitelistTemplateToInstanceRequest;
|
|
12682
|
+
class DetachWhitelistTemplateToInstanceResponseBody extends $tea.Model {
|
|
12683
|
+
constructor(map) {
|
|
12684
|
+
super(map);
|
|
12685
|
+
}
|
|
12686
|
+
static names() {
|
|
12687
|
+
return {
|
|
12688
|
+
code: 'Code',
|
|
12689
|
+
data: 'Data',
|
|
12690
|
+
httpStatusCode: 'HttpStatusCode',
|
|
12691
|
+
message: 'Message',
|
|
12692
|
+
requestId: 'RequestId',
|
|
12693
|
+
success: 'Success',
|
|
12694
|
+
};
|
|
12695
|
+
}
|
|
12696
|
+
static types() {
|
|
12697
|
+
return {
|
|
12698
|
+
code: 'string',
|
|
12699
|
+
data: DetachWhitelistTemplateToInstanceResponseBodyData,
|
|
12700
|
+
httpStatusCode: 'number',
|
|
12701
|
+
message: 'string',
|
|
12702
|
+
requestId: 'string',
|
|
12703
|
+
success: 'boolean',
|
|
12704
|
+
};
|
|
12705
|
+
}
|
|
12706
|
+
}
|
|
12707
|
+
exports.DetachWhitelistTemplateToInstanceResponseBody = DetachWhitelistTemplateToInstanceResponseBody;
|
|
12708
|
+
class DetachWhitelistTemplateToInstanceResponse extends $tea.Model {
|
|
12709
|
+
constructor(map) {
|
|
12710
|
+
super(map);
|
|
12711
|
+
}
|
|
12712
|
+
static names() {
|
|
12713
|
+
return {
|
|
12714
|
+
headers: 'headers',
|
|
12715
|
+
statusCode: 'statusCode',
|
|
12716
|
+
body: 'body',
|
|
12717
|
+
};
|
|
12718
|
+
}
|
|
12719
|
+
static types() {
|
|
12720
|
+
return {
|
|
12721
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
12722
|
+
statusCode: 'number',
|
|
12723
|
+
body: DetachWhitelistTemplateToInstanceResponseBody,
|
|
12724
|
+
};
|
|
12725
|
+
}
|
|
12726
|
+
}
|
|
12727
|
+
exports.DetachWhitelistTemplateToInstanceResponse = DetachWhitelistTemplateToInstanceResponse;
|
|
12110
12728
|
class GetDBInstanceTopologyRequest extends $tea.Model {
|
|
12111
12729
|
constructor(map) {
|
|
12112
12730
|
super(map);
|
|
@@ -16463,6 +17081,76 @@ class ModifySecurityIpsResponse extends $tea.Model {
|
|
|
16463
17081
|
}
|
|
16464
17082
|
}
|
|
16465
17083
|
exports.ModifySecurityIpsResponse = ModifySecurityIpsResponse;
|
|
17084
|
+
class ModifyWhitelistTemplateRequest extends $tea.Model {
|
|
17085
|
+
constructor(map) {
|
|
17086
|
+
super(map);
|
|
17087
|
+
}
|
|
17088
|
+
static names() {
|
|
17089
|
+
return {
|
|
17090
|
+
ipWhitelist: 'IpWhitelist',
|
|
17091
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
17092
|
+
resourceOwnerId: 'ResourceOwnerId',
|
|
17093
|
+
templateId: 'TemplateId',
|
|
17094
|
+
templateName: 'TemplateName',
|
|
17095
|
+
};
|
|
17096
|
+
}
|
|
17097
|
+
static types() {
|
|
17098
|
+
return {
|
|
17099
|
+
ipWhitelist: 'string',
|
|
17100
|
+
resourceOwnerAccount: 'string',
|
|
17101
|
+
resourceOwnerId: 'number',
|
|
17102
|
+
templateId: 'number',
|
|
17103
|
+
templateName: 'string',
|
|
17104
|
+
};
|
|
17105
|
+
}
|
|
17106
|
+
}
|
|
17107
|
+
exports.ModifyWhitelistTemplateRequest = ModifyWhitelistTemplateRequest;
|
|
17108
|
+
class ModifyWhitelistTemplateResponseBody extends $tea.Model {
|
|
17109
|
+
constructor(map) {
|
|
17110
|
+
super(map);
|
|
17111
|
+
}
|
|
17112
|
+
static names() {
|
|
17113
|
+
return {
|
|
17114
|
+
code: 'Code',
|
|
17115
|
+
data: 'Data',
|
|
17116
|
+
httpStatusCode: 'HttpStatusCode',
|
|
17117
|
+
message: 'Message',
|
|
17118
|
+
requestId: 'RequestId',
|
|
17119
|
+
success: 'Success',
|
|
17120
|
+
};
|
|
17121
|
+
}
|
|
17122
|
+
static types() {
|
|
17123
|
+
return {
|
|
17124
|
+
code: 'string',
|
|
17125
|
+
data: ModifyWhitelistTemplateResponseBodyData,
|
|
17126
|
+
httpStatusCode: 'number',
|
|
17127
|
+
message: 'string',
|
|
17128
|
+
requestId: 'string',
|
|
17129
|
+
success: 'boolean',
|
|
17130
|
+
};
|
|
17131
|
+
}
|
|
17132
|
+
}
|
|
17133
|
+
exports.ModifyWhitelistTemplateResponseBody = ModifyWhitelistTemplateResponseBody;
|
|
17134
|
+
class ModifyWhitelistTemplateResponse extends $tea.Model {
|
|
17135
|
+
constructor(map) {
|
|
17136
|
+
super(map);
|
|
17137
|
+
}
|
|
17138
|
+
static names() {
|
|
17139
|
+
return {
|
|
17140
|
+
headers: 'headers',
|
|
17141
|
+
statusCode: 'statusCode',
|
|
17142
|
+
body: 'body',
|
|
17143
|
+
};
|
|
17144
|
+
}
|
|
17145
|
+
static types() {
|
|
17146
|
+
return {
|
|
17147
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
17148
|
+
statusCode: 'number',
|
|
17149
|
+
body: ModifyWhitelistTemplateResponseBody,
|
|
17150
|
+
};
|
|
17151
|
+
}
|
|
17152
|
+
}
|
|
17153
|
+
exports.ModifyWhitelistTemplateResponse = ModifyWhitelistTemplateResponse;
|
|
16466
17154
|
class PurgeDBInstanceLogRequest extends $tea.Model {
|
|
16467
17155
|
constructor(map) {
|
|
16468
17156
|
super(map);
|
|
@@ -18333,6 +19021,74 @@ class UntagResourcesResponse extends $tea.Model {
|
|
|
18333
19021
|
}
|
|
18334
19022
|
}
|
|
18335
19023
|
exports.UntagResourcesResponse = UntagResourcesResponse;
|
|
19024
|
+
class UpdatePostgresExtensionsRequest extends $tea.Model {
|
|
19025
|
+
constructor(map) {
|
|
19026
|
+
super(map);
|
|
19027
|
+
}
|
|
19028
|
+
static names() {
|
|
19029
|
+
return {
|
|
19030
|
+
clientToken: 'ClientToken',
|
|
19031
|
+
DBInstanceId: 'DBInstanceId',
|
|
19032
|
+
DBNames: 'DBNames',
|
|
19033
|
+
extensions: 'Extensions',
|
|
19034
|
+
ownerAccount: 'OwnerAccount',
|
|
19035
|
+
ownerId: 'OwnerId',
|
|
19036
|
+
resourceGroupId: 'ResourceGroupId',
|
|
19037
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
19038
|
+
resourceOwnerId: 'ResourceOwnerId',
|
|
19039
|
+
};
|
|
19040
|
+
}
|
|
19041
|
+
static types() {
|
|
19042
|
+
return {
|
|
19043
|
+
clientToken: 'string',
|
|
19044
|
+
DBInstanceId: 'string',
|
|
19045
|
+
DBNames: 'string',
|
|
19046
|
+
extensions: 'string',
|
|
19047
|
+
ownerAccount: 'string',
|
|
19048
|
+
ownerId: 'number',
|
|
19049
|
+
resourceGroupId: 'string',
|
|
19050
|
+
resourceOwnerAccount: 'string',
|
|
19051
|
+
resourceOwnerId: 'number',
|
|
19052
|
+
};
|
|
19053
|
+
}
|
|
19054
|
+
}
|
|
19055
|
+
exports.UpdatePostgresExtensionsRequest = UpdatePostgresExtensionsRequest;
|
|
19056
|
+
class UpdatePostgresExtensionsResponseBody extends $tea.Model {
|
|
19057
|
+
constructor(map) {
|
|
19058
|
+
super(map);
|
|
19059
|
+
}
|
|
19060
|
+
static names() {
|
|
19061
|
+
return {
|
|
19062
|
+
requestId: 'RequestId',
|
|
19063
|
+
};
|
|
19064
|
+
}
|
|
19065
|
+
static types() {
|
|
19066
|
+
return {
|
|
19067
|
+
requestId: 'string',
|
|
19068
|
+
};
|
|
19069
|
+
}
|
|
19070
|
+
}
|
|
19071
|
+
exports.UpdatePostgresExtensionsResponseBody = UpdatePostgresExtensionsResponseBody;
|
|
19072
|
+
class UpdatePostgresExtensionsResponse extends $tea.Model {
|
|
19073
|
+
constructor(map) {
|
|
19074
|
+
super(map);
|
|
19075
|
+
}
|
|
19076
|
+
static names() {
|
|
19077
|
+
return {
|
|
19078
|
+
headers: 'headers',
|
|
19079
|
+
statusCode: 'statusCode',
|
|
19080
|
+
body: 'body',
|
|
19081
|
+
};
|
|
19082
|
+
}
|
|
19083
|
+
static types() {
|
|
19084
|
+
return {
|
|
19085
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
19086
|
+
statusCode: 'number',
|
|
19087
|
+
body: UpdatePostgresExtensionsResponseBody,
|
|
19088
|
+
};
|
|
19089
|
+
}
|
|
19090
|
+
}
|
|
19091
|
+
exports.UpdatePostgresExtensionsResponse = UpdatePostgresExtensionsResponse;
|
|
18336
19092
|
class UpdateUserBackupFileRequest extends $tea.Model {
|
|
18337
19093
|
constructor(map) {
|
|
18338
19094
|
super(map);
|
|
@@ -18781,6 +19537,22 @@ class AddTagsToResourceRequestTag extends $tea.Model {
|
|
|
18781
19537
|
}
|
|
18782
19538
|
}
|
|
18783
19539
|
exports.AddTagsToResourceRequestTag = AddTagsToResourceRequestTag;
|
|
19540
|
+
class AttachWhitelistTemplateToInstanceResponseBodyData extends $tea.Model {
|
|
19541
|
+
constructor(map) {
|
|
19542
|
+
super(map);
|
|
19543
|
+
}
|
|
19544
|
+
static names() {
|
|
19545
|
+
return {
|
|
19546
|
+
status: 'Status',
|
|
19547
|
+
};
|
|
19548
|
+
}
|
|
19549
|
+
static types() {
|
|
19550
|
+
return {
|
|
19551
|
+
status: 'string',
|
|
19552
|
+
};
|
|
19553
|
+
}
|
|
19554
|
+
}
|
|
19555
|
+
exports.AttachWhitelistTemplateToInstanceResponseBodyData = AttachWhitelistTemplateToInstanceResponseBodyData;
|
|
18784
19556
|
class CalculateDBInstanceWeightResponseBodyItemsDBInstanceWeight extends $tea.Model {
|
|
18785
19557
|
constructor(map) {
|
|
18786
19558
|
super(map);
|
|
@@ -19375,6 +20147,58 @@ class DescribeActiveOperationTasksResponseBodyItems extends $tea.Model {
|
|
|
19375
20147
|
}
|
|
19376
20148
|
}
|
|
19377
20149
|
exports.DescribeActiveOperationTasksResponseBodyItems = DescribeActiveOperationTasksResponseBodyItems;
|
|
20150
|
+
class DescribeAllWhitelistTemplateResponseBodyDataTemplates extends $tea.Model {
|
|
20151
|
+
constructor(map) {
|
|
20152
|
+
super(map);
|
|
20153
|
+
}
|
|
20154
|
+
static names() {
|
|
20155
|
+
return {
|
|
20156
|
+
id: 'Id',
|
|
20157
|
+
ips: 'Ips',
|
|
20158
|
+
templateId: 'TemplateId',
|
|
20159
|
+
templateName: 'TemplateName',
|
|
20160
|
+
userId: 'UserId',
|
|
20161
|
+
};
|
|
20162
|
+
}
|
|
20163
|
+
static types() {
|
|
20164
|
+
return {
|
|
20165
|
+
id: 'number',
|
|
20166
|
+
ips: 'string',
|
|
20167
|
+
templateId: 'number',
|
|
20168
|
+
templateName: 'string',
|
|
20169
|
+
userId: 'number',
|
|
20170
|
+
};
|
|
20171
|
+
}
|
|
20172
|
+
}
|
|
20173
|
+
exports.DescribeAllWhitelistTemplateResponseBodyDataTemplates = DescribeAllWhitelistTemplateResponseBodyDataTemplates;
|
|
20174
|
+
class DescribeAllWhitelistTemplateResponseBodyData extends $tea.Model {
|
|
20175
|
+
constructor(map) {
|
|
20176
|
+
super(map);
|
|
20177
|
+
}
|
|
20178
|
+
static names() {
|
|
20179
|
+
return {
|
|
20180
|
+
currPageNumbers: 'CurrPageNumbers',
|
|
20181
|
+
hasNext: 'HasNext',
|
|
20182
|
+
hasPrev: 'HasPrev',
|
|
20183
|
+
maxRecordsPerPage: 'MaxRecordsPerPage',
|
|
20184
|
+
templates: 'Templates',
|
|
20185
|
+
totalPageNumbers: 'TotalPageNumbers',
|
|
20186
|
+
totalRecords: 'TotalRecords',
|
|
20187
|
+
};
|
|
20188
|
+
}
|
|
20189
|
+
static types() {
|
|
20190
|
+
return {
|
|
20191
|
+
currPageNumbers: 'number',
|
|
20192
|
+
hasNext: 'boolean',
|
|
20193
|
+
hasPrev: 'boolean',
|
|
20194
|
+
maxRecordsPerPage: 'number',
|
|
20195
|
+
templates: { 'type': 'array', 'itemType': DescribeAllWhitelistTemplateResponseBodyDataTemplates },
|
|
20196
|
+
totalPageNumbers: 'number',
|
|
20197
|
+
totalRecords: 'number',
|
|
20198
|
+
};
|
|
20199
|
+
}
|
|
20200
|
+
}
|
|
20201
|
+
exports.DescribeAllWhitelistTemplateResponseBodyData = DescribeAllWhitelistTemplateResponseBodyData;
|
|
19378
20202
|
class DescribeAvailableClassesResponseBodyDBInstanceClassesDBInstanceStorageRange extends $tea.Model {
|
|
19379
20203
|
constructor(map) {
|
|
19380
20204
|
super(map);
|
|
@@ -22667,6 +23491,48 @@ class DescribeInstanceKeywordsResponseBodyWords extends $tea.Model {
|
|
|
22667
23491
|
}
|
|
22668
23492
|
}
|
|
22669
23493
|
exports.DescribeInstanceKeywordsResponseBodyWords = DescribeInstanceKeywordsResponseBodyWords;
|
|
23494
|
+
class DescribeInstanceLinkedWhitelistTemplateResponseBodyDataTemplates extends $tea.Model {
|
|
23495
|
+
constructor(map) {
|
|
23496
|
+
super(map);
|
|
23497
|
+
}
|
|
23498
|
+
static names() {
|
|
23499
|
+
return {
|
|
23500
|
+
id: 'Id',
|
|
23501
|
+
ips: 'Ips',
|
|
23502
|
+
templateId: 'TemplateId',
|
|
23503
|
+
templateName: 'TemplateName',
|
|
23504
|
+
userId: 'UserId',
|
|
23505
|
+
};
|
|
23506
|
+
}
|
|
23507
|
+
static types() {
|
|
23508
|
+
return {
|
|
23509
|
+
id: 'number',
|
|
23510
|
+
ips: 'string',
|
|
23511
|
+
templateId: 'number',
|
|
23512
|
+
templateName: 'string',
|
|
23513
|
+
userId: 'number',
|
|
23514
|
+
};
|
|
23515
|
+
}
|
|
23516
|
+
}
|
|
23517
|
+
exports.DescribeInstanceLinkedWhitelistTemplateResponseBodyDataTemplates = DescribeInstanceLinkedWhitelistTemplateResponseBodyDataTemplates;
|
|
23518
|
+
class DescribeInstanceLinkedWhitelistTemplateResponseBodyData extends $tea.Model {
|
|
23519
|
+
constructor(map) {
|
|
23520
|
+
super(map);
|
|
23521
|
+
}
|
|
23522
|
+
static names() {
|
|
23523
|
+
return {
|
|
23524
|
+
insName: 'InsName',
|
|
23525
|
+
templates: 'Templates',
|
|
23526
|
+
};
|
|
23527
|
+
}
|
|
23528
|
+
static types() {
|
|
23529
|
+
return {
|
|
23530
|
+
insName: 'string',
|
|
23531
|
+
templates: { 'type': 'array', 'itemType': DescribeInstanceLinkedWhitelistTemplateResponseBodyDataTemplates },
|
|
23532
|
+
};
|
|
23533
|
+
}
|
|
23534
|
+
}
|
|
23535
|
+
exports.DescribeInstanceLinkedWhitelistTemplateResponseBodyData = DescribeInstanceLinkedWhitelistTemplateResponseBodyData;
|
|
22670
23536
|
class DescribeLogBackupFilesResponseBodyItemsBinLogFile extends $tea.Model {
|
|
22671
23537
|
constructor(map) {
|
|
22672
23538
|
super(map);
|
|
@@ -23407,6 +24273,66 @@ class DescribeParametersResponseBodyRunningParameters extends $tea.Model {
|
|
|
23407
24273
|
}
|
|
23408
24274
|
}
|
|
23409
24275
|
exports.DescribeParametersResponseBodyRunningParameters = DescribeParametersResponseBodyRunningParameters;
|
|
24276
|
+
class DescribePostgresExtensionsResponseBodyInstalledExtensions extends $tea.Model {
|
|
24277
|
+
constructor(map) {
|
|
24278
|
+
super(map);
|
|
24279
|
+
}
|
|
24280
|
+
static names() {
|
|
24281
|
+
return {
|
|
24282
|
+
category: 'Category',
|
|
24283
|
+
comment: 'Comment',
|
|
24284
|
+
defaultVersion: 'DefaultVersion',
|
|
24285
|
+
installedVersion: 'InstalledVersion',
|
|
24286
|
+
name: 'Name',
|
|
24287
|
+
owner: 'Owner',
|
|
24288
|
+
priority: 'Priority',
|
|
24289
|
+
requires: 'Requires',
|
|
24290
|
+
};
|
|
24291
|
+
}
|
|
24292
|
+
static types() {
|
|
24293
|
+
return {
|
|
24294
|
+
category: 'string',
|
|
24295
|
+
comment: 'string',
|
|
24296
|
+
defaultVersion: 'string',
|
|
24297
|
+
installedVersion: 'string',
|
|
24298
|
+
name: 'string',
|
|
24299
|
+
owner: 'string',
|
|
24300
|
+
priority: 'string',
|
|
24301
|
+
requires: 'string',
|
|
24302
|
+
};
|
|
24303
|
+
}
|
|
24304
|
+
}
|
|
24305
|
+
exports.DescribePostgresExtensionsResponseBodyInstalledExtensions = DescribePostgresExtensionsResponseBodyInstalledExtensions;
|
|
24306
|
+
class DescribePostgresExtensionsResponseBodyUninstalledExtensions extends $tea.Model {
|
|
24307
|
+
constructor(map) {
|
|
24308
|
+
super(map);
|
|
24309
|
+
}
|
|
24310
|
+
static names() {
|
|
24311
|
+
return {
|
|
24312
|
+
category: 'Category',
|
|
24313
|
+
comment: 'Comment',
|
|
24314
|
+
defaultVersion: 'DefaultVersion',
|
|
24315
|
+
installedVersion: 'InstalledVersion',
|
|
24316
|
+
name: 'Name',
|
|
24317
|
+
owner: 'Owner',
|
|
24318
|
+
priority: 'Priority',
|
|
24319
|
+
requires: 'Requires',
|
|
24320
|
+
};
|
|
24321
|
+
}
|
|
24322
|
+
static types() {
|
|
24323
|
+
return {
|
|
24324
|
+
category: 'string',
|
|
24325
|
+
comment: 'string',
|
|
24326
|
+
defaultVersion: 'string',
|
|
24327
|
+
installedVersion: 'string',
|
|
24328
|
+
name: 'string',
|
|
24329
|
+
owner: 'string',
|
|
24330
|
+
priority: 'string',
|
|
24331
|
+
requires: 'string',
|
|
24332
|
+
};
|
|
24333
|
+
}
|
|
24334
|
+
}
|
|
24335
|
+
exports.DescribePostgresExtensionsResponseBodyUninstalledExtensions = DescribePostgresExtensionsResponseBodyUninstalledExtensions;
|
|
23410
24336
|
class DescribePriceRequestDBNode extends $tea.Model {
|
|
23411
24337
|
constructor(map) {
|
|
23412
24338
|
super(map);
|
|
@@ -24641,6 +25567,80 @@ class DescribeVSwitchesResponseBodyVSwitchs extends $tea.Model {
|
|
|
24641
25567
|
}
|
|
24642
25568
|
}
|
|
24643
25569
|
exports.DescribeVSwitchesResponseBodyVSwitchs = DescribeVSwitchesResponseBodyVSwitchs;
|
|
25570
|
+
class DescribeWhitelistTemplateResponseBodyDataTemplate extends $tea.Model {
|
|
25571
|
+
constructor(map) {
|
|
25572
|
+
super(map);
|
|
25573
|
+
}
|
|
25574
|
+
static names() {
|
|
25575
|
+
return {
|
|
25576
|
+
id: 'Id',
|
|
25577
|
+
ips: 'Ips',
|
|
25578
|
+
templateId: 'TemplateId',
|
|
25579
|
+
templateName: 'TemplateName',
|
|
25580
|
+
userId: 'UserId',
|
|
25581
|
+
};
|
|
25582
|
+
}
|
|
25583
|
+
static types() {
|
|
25584
|
+
return {
|
|
25585
|
+
id: 'number',
|
|
25586
|
+
ips: 'string',
|
|
25587
|
+
templateId: 'number',
|
|
25588
|
+
templateName: 'string',
|
|
25589
|
+
userId: 'number',
|
|
25590
|
+
};
|
|
25591
|
+
}
|
|
25592
|
+
}
|
|
25593
|
+
exports.DescribeWhitelistTemplateResponseBodyDataTemplate = DescribeWhitelistTemplateResponseBodyDataTemplate;
|
|
25594
|
+
class DescribeWhitelistTemplateResponseBodyData extends $tea.Model {
|
|
25595
|
+
constructor(map) {
|
|
25596
|
+
super(map);
|
|
25597
|
+
}
|
|
25598
|
+
static names() {
|
|
25599
|
+
return {
|
|
25600
|
+
template: 'Template',
|
|
25601
|
+
};
|
|
25602
|
+
}
|
|
25603
|
+
static types() {
|
|
25604
|
+
return {
|
|
25605
|
+
template: DescribeWhitelistTemplateResponseBodyDataTemplate,
|
|
25606
|
+
};
|
|
25607
|
+
}
|
|
25608
|
+
}
|
|
25609
|
+
exports.DescribeWhitelistTemplateResponseBodyData = DescribeWhitelistTemplateResponseBodyData;
|
|
25610
|
+
class DescribeWhitelistTemplateLinkedInstanceResponseBodyData extends $tea.Model {
|
|
25611
|
+
constructor(map) {
|
|
25612
|
+
super(map);
|
|
25613
|
+
}
|
|
25614
|
+
static names() {
|
|
25615
|
+
return {
|
|
25616
|
+
insName: 'InsName',
|
|
25617
|
+
templateId: 'TemplateId',
|
|
25618
|
+
};
|
|
25619
|
+
}
|
|
25620
|
+
static types() {
|
|
25621
|
+
return {
|
|
25622
|
+
insName: { 'type': 'array', 'itemType': 'string' },
|
|
25623
|
+
templateId: 'number',
|
|
25624
|
+
};
|
|
25625
|
+
}
|
|
25626
|
+
}
|
|
25627
|
+
exports.DescribeWhitelistTemplateLinkedInstanceResponseBodyData = DescribeWhitelistTemplateLinkedInstanceResponseBodyData;
|
|
25628
|
+
class DetachWhitelistTemplateToInstanceResponseBodyData extends $tea.Model {
|
|
25629
|
+
constructor(map) {
|
|
25630
|
+
super(map);
|
|
25631
|
+
}
|
|
25632
|
+
static names() {
|
|
25633
|
+
return {
|
|
25634
|
+
status: 'Status',
|
|
25635
|
+
};
|
|
25636
|
+
}
|
|
25637
|
+
static types() {
|
|
25638
|
+
return {
|
|
25639
|
+
status: 'string',
|
|
25640
|
+
};
|
|
25641
|
+
}
|
|
25642
|
+
}
|
|
25643
|
+
exports.DetachWhitelistTemplateToInstanceResponseBodyData = DetachWhitelistTemplateToInstanceResponseBodyData;
|
|
24644
25644
|
class GetDBInstanceTopologyResponseBodyDataConnections extends $tea.Model {
|
|
24645
25645
|
constructor(map) {
|
|
24646
25646
|
super(map);
|
|
@@ -25035,6 +26035,22 @@ class ModifySecurityGroupConfigurationResponseBodyItems extends $tea.Model {
|
|
|
25035
26035
|
}
|
|
25036
26036
|
}
|
|
25037
26037
|
exports.ModifySecurityGroupConfigurationResponseBodyItems = ModifySecurityGroupConfigurationResponseBodyItems;
|
|
26038
|
+
class ModifyWhitelistTemplateResponseBodyData extends $tea.Model {
|
|
26039
|
+
constructor(map) {
|
|
26040
|
+
super(map);
|
|
26041
|
+
}
|
|
26042
|
+
static names() {
|
|
26043
|
+
return {
|
|
26044
|
+
status: 'Status',
|
|
26045
|
+
};
|
|
26046
|
+
}
|
|
26047
|
+
static types() {
|
|
26048
|
+
return {
|
|
26049
|
+
status: 'string',
|
|
26050
|
+
};
|
|
26051
|
+
}
|
|
26052
|
+
}
|
|
26053
|
+
exports.ModifyWhitelistTemplateResponseBodyData = ModifyWhitelistTemplateResponseBodyData;
|
|
25038
26054
|
class QueryNotifyResponseBodyDataNotifyItemList extends $tea.Model {
|
|
25039
26055
|
constructor(map) {
|
|
25040
26056
|
super(map);
|
|
@@ -25478,6 +26494,41 @@ class Client extends openapi_client_1.default {
|
|
|
25478
26494
|
let runtime = new $Util.RuntimeOptions({});
|
|
25479
26495
|
return await this.allocateReadWriteSplittingConnectionWithOptions(request, runtime);
|
|
25480
26496
|
}
|
|
26497
|
+
async attachWhitelistTemplateToInstanceWithOptions(request, runtime) {
|
|
26498
|
+
tea_util_1.default.validateModel(request);
|
|
26499
|
+
let query = {};
|
|
26500
|
+
if (!tea_util_1.default.isUnset(request.insName)) {
|
|
26501
|
+
query["InsName"] = request.insName;
|
|
26502
|
+
}
|
|
26503
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
26504
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
26505
|
+
}
|
|
26506
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerId)) {
|
|
26507
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
26508
|
+
}
|
|
26509
|
+
if (!tea_util_1.default.isUnset(request.templateId)) {
|
|
26510
|
+
query["TemplateId"] = request.templateId;
|
|
26511
|
+
}
|
|
26512
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
26513
|
+
query: openapi_util_1.default.query(query),
|
|
26514
|
+
});
|
|
26515
|
+
let params = new $OpenApi.Params({
|
|
26516
|
+
action: "AttachWhitelistTemplateToInstance",
|
|
26517
|
+
version: "2014-08-15",
|
|
26518
|
+
protocol: "HTTPS",
|
|
26519
|
+
pathname: "/",
|
|
26520
|
+
method: "POST",
|
|
26521
|
+
authType: "AK",
|
|
26522
|
+
style: "RPC",
|
|
26523
|
+
reqBodyType: "formData",
|
|
26524
|
+
bodyType: "json",
|
|
26525
|
+
});
|
|
26526
|
+
return $tea.cast(await this.callApi(params, req, runtime), new AttachWhitelistTemplateToInstanceResponse({}));
|
|
26527
|
+
}
|
|
26528
|
+
async attachWhitelistTemplateToInstance(request) {
|
|
26529
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
26530
|
+
return await this.attachWhitelistTemplateToInstanceWithOptions(request, runtime);
|
|
26531
|
+
}
|
|
25481
26532
|
/**
|
|
25482
26533
|
* When the [read/write splitting](~~51073~~) feature is enabled, this operation is used to calculate system-assigned read weights. For more information about custom read weights, see [DescribeDBInstanceNetInfo](~~26237~~).
|
|
25483
26534
|
* Before you call this operation, make sure that the following requirements are met:
|
|
@@ -27709,6 +28760,62 @@ class Client extends openapi_client_1.default {
|
|
|
27709
28760
|
let runtime = new $Util.RuntimeOptions({});
|
|
27710
28761
|
return await this.createParameterGroupWithOptions(request, runtime);
|
|
27711
28762
|
}
|
|
28763
|
+
async createPostgresExtensionsWithOptions(request, runtime) {
|
|
28764
|
+
tea_util_1.default.validateModel(request);
|
|
28765
|
+
let query = {};
|
|
28766
|
+
if (!tea_util_1.default.isUnset(request.accountName)) {
|
|
28767
|
+
query["AccountName"] = request.accountName;
|
|
28768
|
+
}
|
|
28769
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
28770
|
+
query["ClientToken"] = request.clientToken;
|
|
28771
|
+
}
|
|
28772
|
+
if (!tea_util_1.default.isUnset(request.DBInstanceId)) {
|
|
28773
|
+
query["DBInstanceId"] = request.DBInstanceId;
|
|
28774
|
+
}
|
|
28775
|
+
if (!tea_util_1.default.isUnset(request.DBNames)) {
|
|
28776
|
+
query["DBNames"] = request.DBNames;
|
|
28777
|
+
}
|
|
28778
|
+
if (!tea_util_1.default.isUnset(request.extensions)) {
|
|
28779
|
+
query["Extensions"] = request.extensions;
|
|
28780
|
+
}
|
|
28781
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
28782
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
28783
|
+
}
|
|
28784
|
+
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
28785
|
+
query["OwnerId"] = request.ownerId;
|
|
28786
|
+
}
|
|
28787
|
+
if (!tea_util_1.default.isUnset(request.resourceGroupId)) {
|
|
28788
|
+
query["ResourceGroupId"] = request.resourceGroupId;
|
|
28789
|
+
}
|
|
28790
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
28791
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
28792
|
+
}
|
|
28793
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerId)) {
|
|
28794
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
28795
|
+
}
|
|
28796
|
+
if (!tea_util_1.default.isUnset(request.sourceDatabase)) {
|
|
28797
|
+
query["SourceDatabase"] = request.sourceDatabase;
|
|
28798
|
+
}
|
|
28799
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
28800
|
+
query: openapi_util_1.default.query(query),
|
|
28801
|
+
});
|
|
28802
|
+
let params = new $OpenApi.Params({
|
|
28803
|
+
action: "CreatePostgresExtensions",
|
|
28804
|
+
version: "2014-08-15",
|
|
28805
|
+
protocol: "HTTPS",
|
|
28806
|
+
pathname: "/",
|
|
28807
|
+
method: "POST",
|
|
28808
|
+
authType: "AK",
|
|
28809
|
+
style: "RPC",
|
|
28810
|
+
reqBodyType: "formData",
|
|
28811
|
+
bodyType: "json",
|
|
28812
|
+
});
|
|
28813
|
+
return $tea.cast(await this.callApi(params, req, runtime), new CreatePostgresExtensionsResponse({}));
|
|
28814
|
+
}
|
|
28815
|
+
async createPostgresExtensions(request) {
|
|
28816
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
28817
|
+
return await this.createPostgresExtensionsWithOptions(request, runtime);
|
|
28818
|
+
}
|
|
27712
28819
|
/**
|
|
27713
28820
|
* **Before you call this operation, take note of the following limits:**
|
|
27714
28821
|
* * The primary instance cannot belong to a dedicated cluster and must run one of the following database engine versions and RDS editions:
|
|
@@ -28683,6 +29790,56 @@ class Client extends openapi_client_1.default {
|
|
|
28683
29790
|
let runtime = new $Util.RuntimeOptions({});
|
|
28684
29791
|
return await this.deleteParameterGroupWithOptions(request, runtime);
|
|
28685
29792
|
}
|
|
29793
|
+
async deletePostgresExtensionsWithOptions(request, runtime) {
|
|
29794
|
+
tea_util_1.default.validateModel(request);
|
|
29795
|
+
let query = {};
|
|
29796
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
29797
|
+
query["ClientToken"] = request.clientToken;
|
|
29798
|
+
}
|
|
29799
|
+
if (!tea_util_1.default.isUnset(request.DBInstanceId)) {
|
|
29800
|
+
query["DBInstanceId"] = request.DBInstanceId;
|
|
29801
|
+
}
|
|
29802
|
+
if (!tea_util_1.default.isUnset(request.DBNames)) {
|
|
29803
|
+
query["DBNames"] = request.DBNames;
|
|
29804
|
+
}
|
|
29805
|
+
if (!tea_util_1.default.isUnset(request.extensions)) {
|
|
29806
|
+
query["Extensions"] = request.extensions;
|
|
29807
|
+
}
|
|
29808
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
29809
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
29810
|
+
}
|
|
29811
|
+
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
29812
|
+
query["OwnerId"] = request.ownerId;
|
|
29813
|
+
}
|
|
29814
|
+
if (!tea_util_1.default.isUnset(request.resourceGroupId)) {
|
|
29815
|
+
query["ResourceGroupId"] = request.resourceGroupId;
|
|
29816
|
+
}
|
|
29817
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
29818
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
29819
|
+
}
|
|
29820
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerId)) {
|
|
29821
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
29822
|
+
}
|
|
29823
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
29824
|
+
query: openapi_util_1.default.query(query),
|
|
29825
|
+
});
|
|
29826
|
+
let params = new $OpenApi.Params({
|
|
29827
|
+
action: "DeletePostgresExtensions",
|
|
29828
|
+
version: "2014-08-15",
|
|
29829
|
+
protocol: "HTTPS",
|
|
29830
|
+
pathname: "/",
|
|
29831
|
+
method: "POST",
|
|
29832
|
+
authType: "AK",
|
|
29833
|
+
style: "RPC",
|
|
29834
|
+
reqBodyType: "formData",
|
|
29835
|
+
bodyType: "json",
|
|
29836
|
+
});
|
|
29837
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DeletePostgresExtensionsResponse({}));
|
|
29838
|
+
}
|
|
29839
|
+
async deletePostgresExtensions(request) {
|
|
29840
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
29841
|
+
return await this.deletePostgresExtensionsWithOptions(request, runtime);
|
|
29842
|
+
}
|
|
28686
29843
|
async deleteSecretWithOptions(request, runtime) {
|
|
28687
29844
|
tea_util_1.default.validateModel(request);
|
|
28688
29845
|
let query = {};
|
|
@@ -29165,6 +30322,47 @@ class Client extends openapi_client_1.default {
|
|
|
29165
30322
|
let runtime = new $Util.RuntimeOptions({});
|
|
29166
30323
|
return await this.describeActiveOperationTasksWithOptions(request, runtime);
|
|
29167
30324
|
}
|
|
30325
|
+
async describeAllWhitelistTemplateWithOptions(request, runtime) {
|
|
30326
|
+
tea_util_1.default.validateModel(request);
|
|
30327
|
+
let query = {};
|
|
30328
|
+
if (!tea_util_1.default.isUnset(request.fuzzySearch)) {
|
|
30329
|
+
query["FuzzySearch"] = request.fuzzySearch;
|
|
30330
|
+
}
|
|
30331
|
+
if (!tea_util_1.default.isUnset(request.maxRecordsPerPage)) {
|
|
30332
|
+
query["MaxRecordsPerPage"] = request.maxRecordsPerPage;
|
|
30333
|
+
}
|
|
30334
|
+
if (!tea_util_1.default.isUnset(request.pageNumbers)) {
|
|
30335
|
+
query["PageNumbers"] = request.pageNumbers;
|
|
30336
|
+
}
|
|
30337
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
30338
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
30339
|
+
}
|
|
30340
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerId)) {
|
|
30341
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
30342
|
+
}
|
|
30343
|
+
if (!tea_util_1.default.isUnset(request.templateName)) {
|
|
30344
|
+
query["TemplateName"] = request.templateName;
|
|
30345
|
+
}
|
|
30346
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
30347
|
+
query: openapi_util_1.default.query(query),
|
|
30348
|
+
});
|
|
30349
|
+
let params = new $OpenApi.Params({
|
|
30350
|
+
action: "DescribeAllWhitelistTemplate",
|
|
30351
|
+
version: "2014-08-15",
|
|
30352
|
+
protocol: "HTTPS",
|
|
30353
|
+
pathname: "/",
|
|
30354
|
+
method: "POST",
|
|
30355
|
+
authType: "AK",
|
|
30356
|
+
style: "RPC",
|
|
30357
|
+
reqBodyType: "formData",
|
|
30358
|
+
bodyType: "json",
|
|
30359
|
+
});
|
|
30360
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DescribeAllWhitelistTemplateResponse({}));
|
|
30361
|
+
}
|
|
30362
|
+
async describeAllWhitelistTemplate(request) {
|
|
30363
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
30364
|
+
return await this.describeAllWhitelistTemplateWithOptions(request, runtime);
|
|
30365
|
+
}
|
|
29168
30366
|
async describeAnalyticdbByPrimaryDBInstanceWithOptions(request, runtime) {
|
|
29169
30367
|
tea_util_1.default.validateModel(request);
|
|
29170
30368
|
let query = {};
|
|
@@ -32860,6 +34058,38 @@ class Client extends openapi_client_1.default {
|
|
|
32860
34058
|
let runtime = new $Util.RuntimeOptions({});
|
|
32861
34059
|
return await this.describeInstanceKeywordsWithOptions(request, runtime);
|
|
32862
34060
|
}
|
|
34061
|
+
async describeInstanceLinkedWhitelistTemplateWithOptions(request, runtime) {
|
|
34062
|
+
tea_util_1.default.validateModel(request);
|
|
34063
|
+
let query = {};
|
|
34064
|
+
if (!tea_util_1.default.isUnset(request.insName)) {
|
|
34065
|
+
query["InsName"] = request.insName;
|
|
34066
|
+
}
|
|
34067
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
34068
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
34069
|
+
}
|
|
34070
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerId)) {
|
|
34071
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
34072
|
+
}
|
|
34073
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
34074
|
+
query: openapi_util_1.default.query(query),
|
|
34075
|
+
});
|
|
34076
|
+
let params = new $OpenApi.Params({
|
|
34077
|
+
action: "DescribeInstanceLinkedWhitelistTemplate",
|
|
34078
|
+
version: "2014-08-15",
|
|
34079
|
+
protocol: "HTTPS",
|
|
34080
|
+
pathname: "/",
|
|
34081
|
+
method: "POST",
|
|
34082
|
+
authType: "AK",
|
|
34083
|
+
style: "RPC",
|
|
34084
|
+
reqBodyType: "formData",
|
|
34085
|
+
bodyType: "json",
|
|
34086
|
+
});
|
|
34087
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DescribeInstanceLinkedWhitelistTemplateResponse({}));
|
|
34088
|
+
}
|
|
34089
|
+
async describeInstanceLinkedWhitelistTemplate(request) {
|
|
34090
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
34091
|
+
return await this.describeInstanceLinkedWhitelistTemplateWithOptions(request, runtime);
|
|
34092
|
+
}
|
|
32863
34093
|
async describeLocalAvailableRecoveryTimeWithOptions(request, runtime) {
|
|
32864
34094
|
tea_util_1.default.validateModel(request);
|
|
32865
34095
|
let query = {};
|
|
@@ -33578,6 +34808,53 @@ class Client extends openapi_client_1.default {
|
|
|
33578
34808
|
let runtime = new $Util.RuntimeOptions({});
|
|
33579
34809
|
return await this.describeParametersWithOptions(request, runtime);
|
|
33580
34810
|
}
|
|
34811
|
+
async describePostgresExtensionsWithOptions(request, runtime) {
|
|
34812
|
+
tea_util_1.default.validateModel(request);
|
|
34813
|
+
let query = {};
|
|
34814
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
34815
|
+
query["ClientToken"] = request.clientToken;
|
|
34816
|
+
}
|
|
34817
|
+
if (!tea_util_1.default.isUnset(request.DBInstanceId)) {
|
|
34818
|
+
query["DBInstanceId"] = request.DBInstanceId;
|
|
34819
|
+
}
|
|
34820
|
+
if (!tea_util_1.default.isUnset(request.DBName)) {
|
|
34821
|
+
query["DBName"] = request.DBName;
|
|
34822
|
+
}
|
|
34823
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
34824
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
34825
|
+
}
|
|
34826
|
+
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
34827
|
+
query["OwnerId"] = request.ownerId;
|
|
34828
|
+
}
|
|
34829
|
+
if (!tea_util_1.default.isUnset(request.resourceGroupId)) {
|
|
34830
|
+
query["ResourceGroupId"] = request.resourceGroupId;
|
|
34831
|
+
}
|
|
34832
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
34833
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
34834
|
+
}
|
|
34835
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerId)) {
|
|
34836
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
34837
|
+
}
|
|
34838
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
34839
|
+
query: openapi_util_1.default.query(query),
|
|
34840
|
+
});
|
|
34841
|
+
let params = new $OpenApi.Params({
|
|
34842
|
+
action: "DescribePostgresExtensions",
|
|
34843
|
+
version: "2014-08-15",
|
|
34844
|
+
protocol: "HTTPS",
|
|
34845
|
+
pathname: "/",
|
|
34846
|
+
method: "POST",
|
|
34847
|
+
authType: "AK",
|
|
34848
|
+
style: "RPC",
|
|
34849
|
+
reqBodyType: "formData",
|
|
34850
|
+
bodyType: "json",
|
|
34851
|
+
});
|
|
34852
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DescribePostgresExtensionsResponse({}));
|
|
34853
|
+
}
|
|
34854
|
+
async describePostgresExtensions(request) {
|
|
34855
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
34856
|
+
return await this.describePostgresExtensionsWithOptions(request, runtime);
|
|
34857
|
+
}
|
|
33581
34858
|
async describePriceWithOptions(tmpReq, runtime) {
|
|
33582
34859
|
tea_util_1.default.validateModel(tmpReq);
|
|
33583
34860
|
let request = new DescribePriceShrinkRequest({});
|
|
@@ -34994,6 +36271,72 @@ class Client extends openapi_client_1.default {
|
|
|
34994
36271
|
let runtime = new $Util.RuntimeOptions({});
|
|
34995
36272
|
return await this.describeVSwitchesWithOptions(request, runtime);
|
|
34996
36273
|
}
|
|
36274
|
+
async describeWhitelistTemplateWithOptions(request, runtime) {
|
|
36275
|
+
tea_util_1.default.validateModel(request);
|
|
36276
|
+
let query = {};
|
|
36277
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
36278
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
36279
|
+
}
|
|
36280
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerId)) {
|
|
36281
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
36282
|
+
}
|
|
36283
|
+
if (!tea_util_1.default.isUnset(request.templateId)) {
|
|
36284
|
+
query["TemplateId"] = request.templateId;
|
|
36285
|
+
}
|
|
36286
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
36287
|
+
query: openapi_util_1.default.query(query),
|
|
36288
|
+
});
|
|
36289
|
+
let params = new $OpenApi.Params({
|
|
36290
|
+
action: "DescribeWhitelistTemplate",
|
|
36291
|
+
version: "2014-08-15",
|
|
36292
|
+
protocol: "HTTPS",
|
|
36293
|
+
pathname: "/",
|
|
36294
|
+
method: "POST",
|
|
36295
|
+
authType: "AK",
|
|
36296
|
+
style: "RPC",
|
|
36297
|
+
reqBodyType: "formData",
|
|
36298
|
+
bodyType: "json",
|
|
36299
|
+
});
|
|
36300
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DescribeWhitelistTemplateResponse({}));
|
|
36301
|
+
}
|
|
36302
|
+
async describeWhitelistTemplate(request) {
|
|
36303
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
36304
|
+
return await this.describeWhitelistTemplateWithOptions(request, runtime);
|
|
36305
|
+
}
|
|
36306
|
+
async describeWhitelistTemplateLinkedInstanceWithOptions(request, runtime) {
|
|
36307
|
+
tea_util_1.default.validateModel(request);
|
|
36308
|
+
let query = {};
|
|
36309
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
36310
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
36311
|
+
}
|
|
36312
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerId)) {
|
|
36313
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
36314
|
+
}
|
|
36315
|
+
let body = {};
|
|
36316
|
+
if (!tea_util_1.default.isUnset(request.templateId)) {
|
|
36317
|
+
body["TemplateId"] = request.templateId;
|
|
36318
|
+
}
|
|
36319
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
36320
|
+
query: openapi_util_1.default.query(query),
|
|
36321
|
+
body: openapi_util_1.default.parseToMap(body),
|
|
36322
|
+
});
|
|
36323
|
+
let params = new $OpenApi.Params({
|
|
36324
|
+
action: "DescribeWhitelistTemplateLinkedInstance",
|
|
36325
|
+
version: "2014-08-15",
|
|
36326
|
+
protocol: "HTTPS",
|
|
36327
|
+
pathname: "/",
|
|
36328
|
+
method: "POST",
|
|
36329
|
+
authType: "AK",
|
|
36330
|
+
style: "RPC",
|
|
36331
|
+
reqBodyType: "formData",
|
|
36332
|
+
bodyType: "json",
|
|
36333
|
+
});
|
|
36334
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DescribeWhitelistTemplateLinkedInstanceResponse({}));
|
|
36335
|
+
}
|
|
36336
|
+
async describeWhitelistTemplateLinkedInstance(request) {
|
|
36337
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
36338
|
+
return await this.describeWhitelistTemplateLinkedInstanceWithOptions(request, runtime);
|
|
36339
|
+
}
|
|
34997
36340
|
/**
|
|
34998
36341
|
* The DestroyDBInstance operation is phased out.
|
|
34999
36342
|
*
|
|
@@ -35095,6 +36438,41 @@ class Client extends openapi_client_1.default {
|
|
|
35095
36438
|
let runtime = new $Util.RuntimeOptions({});
|
|
35096
36439
|
return await this.detachGadInstanceMemberWithOptions(request, runtime);
|
|
35097
36440
|
}
|
|
36441
|
+
async detachWhitelistTemplateToInstanceWithOptions(request, runtime) {
|
|
36442
|
+
tea_util_1.default.validateModel(request);
|
|
36443
|
+
let query = {};
|
|
36444
|
+
if (!tea_util_1.default.isUnset(request.insName)) {
|
|
36445
|
+
query["InsName"] = request.insName;
|
|
36446
|
+
}
|
|
36447
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
36448
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
36449
|
+
}
|
|
36450
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerId)) {
|
|
36451
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
36452
|
+
}
|
|
36453
|
+
if (!tea_util_1.default.isUnset(request.templateId)) {
|
|
36454
|
+
query["TemplateId"] = request.templateId;
|
|
36455
|
+
}
|
|
36456
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
36457
|
+
query: openapi_util_1.default.query(query),
|
|
36458
|
+
});
|
|
36459
|
+
let params = new $OpenApi.Params({
|
|
36460
|
+
action: "DetachWhitelistTemplateToInstance",
|
|
36461
|
+
version: "2014-08-15",
|
|
36462
|
+
protocol: "HTTPS",
|
|
36463
|
+
pathname: "/",
|
|
36464
|
+
method: "POST",
|
|
36465
|
+
authType: "AK",
|
|
36466
|
+
style: "RPC",
|
|
36467
|
+
reqBodyType: "formData",
|
|
36468
|
+
bodyType: "json",
|
|
36469
|
+
});
|
|
36470
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DetachWhitelistTemplateToInstanceResponse({}));
|
|
36471
|
+
}
|
|
36472
|
+
async detachWhitelistTemplateToInstance(request) {
|
|
36473
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
36474
|
+
return await this.detachWhitelistTemplateToInstanceWithOptions(request, runtime);
|
|
36475
|
+
}
|
|
35098
36476
|
async getDBInstanceTopologyWithOptions(request, runtime) {
|
|
35099
36477
|
tea_util_1.default.validateModel(request);
|
|
35100
36478
|
let query = {};
|
|
@@ -39074,6 +40452,44 @@ class Client extends openapi_client_1.default {
|
|
|
39074
40452
|
let runtime = new $Util.RuntimeOptions({});
|
|
39075
40453
|
return await this.modifySecurityIpsWithOptions(request, runtime);
|
|
39076
40454
|
}
|
|
40455
|
+
async modifyWhitelistTemplateWithOptions(request, runtime) {
|
|
40456
|
+
tea_util_1.default.validateModel(request);
|
|
40457
|
+
let query = {};
|
|
40458
|
+
if (!tea_util_1.default.isUnset(request.ipWhitelist)) {
|
|
40459
|
+
query["IpWhitelist"] = request.ipWhitelist;
|
|
40460
|
+
}
|
|
40461
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
40462
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
40463
|
+
}
|
|
40464
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerId)) {
|
|
40465
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
40466
|
+
}
|
|
40467
|
+
if (!tea_util_1.default.isUnset(request.templateId)) {
|
|
40468
|
+
query["TemplateId"] = request.templateId;
|
|
40469
|
+
}
|
|
40470
|
+
if (!tea_util_1.default.isUnset(request.templateName)) {
|
|
40471
|
+
query["TemplateName"] = request.templateName;
|
|
40472
|
+
}
|
|
40473
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
40474
|
+
query: openapi_util_1.default.query(query),
|
|
40475
|
+
});
|
|
40476
|
+
let params = new $OpenApi.Params({
|
|
40477
|
+
action: "ModifyWhitelistTemplate",
|
|
40478
|
+
version: "2014-08-15",
|
|
40479
|
+
protocol: "HTTPS",
|
|
40480
|
+
pathname: "/",
|
|
40481
|
+
method: "POST",
|
|
40482
|
+
authType: "AK",
|
|
40483
|
+
style: "RPC",
|
|
40484
|
+
reqBodyType: "formData",
|
|
40485
|
+
bodyType: "json",
|
|
40486
|
+
});
|
|
40487
|
+
return $tea.cast(await this.callApi(params, req, runtime), new ModifyWhitelistTemplateResponse({}));
|
|
40488
|
+
}
|
|
40489
|
+
async modifyWhitelistTemplate(request) {
|
|
40490
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
40491
|
+
return await this.modifyWhitelistTemplateWithOptions(request, runtime);
|
|
40492
|
+
}
|
|
39077
40493
|
/**
|
|
39078
40494
|
* ApsaraDB RDS automatically uploads log backup files to Object Storage Service (OSS) buckets. If the remaining storage of an instance is insufficient, you can upload the log backup files of the instance to OSS buckets. After you upload the log backup files of an instance, ApsaraDB RDS deletes these files from the instance to release storage. This operation is called to upload log backup files from an instance to OSS buckets and then delete these files from the instance. If the instance runs SQL Server, transaction log backup files are compressed before they are uploaded. For more information about log backups, see [Back up an ApsaraDB RDS for MySQL instance](~~98818~~) or [Back up an ApsaraDB RDS for SQL Server instance](~~95717~~).
|
|
39079
40495
|
* >
|
|
@@ -40827,6 +42243,56 @@ class Client extends openapi_client_1.default {
|
|
|
40827
42243
|
let runtime = new $Util.RuntimeOptions({});
|
|
40828
42244
|
return await this.untagResourcesWithOptions(request, runtime);
|
|
40829
42245
|
}
|
|
42246
|
+
async updatePostgresExtensionsWithOptions(request, runtime) {
|
|
42247
|
+
tea_util_1.default.validateModel(request);
|
|
42248
|
+
let query = {};
|
|
42249
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
42250
|
+
query["ClientToken"] = request.clientToken;
|
|
42251
|
+
}
|
|
42252
|
+
if (!tea_util_1.default.isUnset(request.DBInstanceId)) {
|
|
42253
|
+
query["DBInstanceId"] = request.DBInstanceId;
|
|
42254
|
+
}
|
|
42255
|
+
if (!tea_util_1.default.isUnset(request.DBNames)) {
|
|
42256
|
+
query["DBNames"] = request.DBNames;
|
|
42257
|
+
}
|
|
42258
|
+
if (!tea_util_1.default.isUnset(request.extensions)) {
|
|
42259
|
+
query["Extensions"] = request.extensions;
|
|
42260
|
+
}
|
|
42261
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
42262
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
42263
|
+
}
|
|
42264
|
+
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
42265
|
+
query["OwnerId"] = request.ownerId;
|
|
42266
|
+
}
|
|
42267
|
+
if (!tea_util_1.default.isUnset(request.resourceGroupId)) {
|
|
42268
|
+
query["ResourceGroupId"] = request.resourceGroupId;
|
|
42269
|
+
}
|
|
42270
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
42271
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
42272
|
+
}
|
|
42273
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerId)) {
|
|
42274
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
42275
|
+
}
|
|
42276
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
42277
|
+
query: openapi_util_1.default.query(query),
|
|
42278
|
+
});
|
|
42279
|
+
let params = new $OpenApi.Params({
|
|
42280
|
+
action: "UpdatePostgresExtensions",
|
|
42281
|
+
version: "2014-08-15",
|
|
42282
|
+
protocol: "HTTPS",
|
|
42283
|
+
pathname: "/",
|
|
42284
|
+
method: "POST",
|
|
42285
|
+
authType: "AK",
|
|
42286
|
+
style: "RPC",
|
|
42287
|
+
reqBodyType: "formData",
|
|
42288
|
+
bodyType: "json",
|
|
42289
|
+
});
|
|
42290
|
+
return $tea.cast(await this.callApi(params, req, runtime), new UpdatePostgresExtensionsResponse({}));
|
|
42291
|
+
}
|
|
42292
|
+
async updatePostgresExtensions(request) {
|
|
42293
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
42294
|
+
return await this.updatePostgresExtensionsWithOptions(request, runtime);
|
|
42295
|
+
}
|
|
40830
42296
|
/**
|
|
40831
42297
|
* > A full backup file contains the data of a self-managed MySQL database. You can restore the data of a self-managed MySQL database from a full backup file to an ApsaraDB RDS for MySQL instance. For more information, see [Migrate the data of a self-managed MySQL 5.7 instance to the cloud](~~251779~~).
|
|
40832
42298
|
*
|