@alicloud/vpc20160428 6.0.2 → 6.1.1
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 +1120 -214
- package/dist/client.js +2225 -340
- package/dist/client.js.map +1 -1
- package/package.json +2 -2
- package/src/client.ts +3017 -653
package/dist/client.js
CHANGED
|
@@ -1336,7 +1336,9 @@ class AssociateNetworkAclRequest extends $tea.Model {
|
|
|
1336
1336
|
static names() {
|
|
1337
1337
|
return {
|
|
1338
1338
|
clientToken: 'ClientToken',
|
|
1339
|
+
dryRun: 'DryRun',
|
|
1339
1340
|
networkAclId: 'NetworkAclId',
|
|
1341
|
+
ownerAccount: 'OwnerAccount',
|
|
1340
1342
|
ownerId: 'OwnerId',
|
|
1341
1343
|
regionId: 'RegionId',
|
|
1342
1344
|
resource: 'Resource',
|
|
@@ -1347,7 +1349,9 @@ class AssociateNetworkAclRequest extends $tea.Model {
|
|
|
1347
1349
|
static types() {
|
|
1348
1350
|
return {
|
|
1349
1351
|
clientToken: 'string',
|
|
1352
|
+
dryRun: 'boolean',
|
|
1350
1353
|
networkAclId: 'string',
|
|
1354
|
+
ownerAccount: 'string',
|
|
1351
1355
|
ownerId: 'number',
|
|
1352
1356
|
regionId: 'string',
|
|
1353
1357
|
resource: { 'type': 'array', 'itemType': AssociateNetworkAclRequestResource },
|
|
@@ -2530,7 +2534,9 @@ class CopyNetworkAclEntriesRequest extends $tea.Model {
|
|
|
2530
2534
|
static names() {
|
|
2531
2535
|
return {
|
|
2532
2536
|
clientToken: 'ClientToken',
|
|
2537
|
+
dryRun: 'DryRun',
|
|
2533
2538
|
networkAclId: 'NetworkAclId',
|
|
2539
|
+
ownerAccount: 'OwnerAccount',
|
|
2534
2540
|
ownerId: 'OwnerId',
|
|
2535
2541
|
regionId: 'RegionId',
|
|
2536
2542
|
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
@@ -2541,7 +2547,9 @@ class CopyNetworkAclEntriesRequest extends $tea.Model {
|
|
|
2541
2547
|
static types() {
|
|
2542
2548
|
return {
|
|
2543
2549
|
clientToken: 'string',
|
|
2550
|
+
dryRun: 'boolean',
|
|
2544
2551
|
networkAclId: 'string',
|
|
2552
|
+
ownerAccount: 'string',
|
|
2545
2553
|
ownerId: 'number',
|
|
2546
2554
|
regionId: 'string',
|
|
2547
2555
|
resourceOwnerAccount: 'string',
|
|
@@ -3223,6 +3231,80 @@ class CreateExpressCloudConnectionResponse extends $tea.Model {
|
|
|
3223
3231
|
}
|
|
3224
3232
|
}
|
|
3225
3233
|
exports.CreateExpressCloudConnectionResponse = CreateExpressCloudConnectionResponse;
|
|
3234
|
+
class CreateFailoverTestJobRequest extends $tea.Model {
|
|
3235
|
+
constructor(map) {
|
|
3236
|
+
super(map);
|
|
3237
|
+
}
|
|
3238
|
+
static names() {
|
|
3239
|
+
return {
|
|
3240
|
+
clientToken: 'ClientToken',
|
|
3241
|
+
description: 'Description',
|
|
3242
|
+
jobDuration: 'JobDuration',
|
|
3243
|
+
jobType: 'JobType',
|
|
3244
|
+
name: 'Name',
|
|
3245
|
+
ownerAccount: 'OwnerAccount',
|
|
3246
|
+
ownerId: 'OwnerId',
|
|
3247
|
+
regionId: 'RegionId',
|
|
3248
|
+
resourceId: 'ResourceId',
|
|
3249
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
3250
|
+
resourceType: 'ResourceType',
|
|
3251
|
+
};
|
|
3252
|
+
}
|
|
3253
|
+
static types() {
|
|
3254
|
+
return {
|
|
3255
|
+
clientToken: 'string',
|
|
3256
|
+
description: 'string',
|
|
3257
|
+
jobDuration: 'number',
|
|
3258
|
+
jobType: 'string',
|
|
3259
|
+
name: 'string',
|
|
3260
|
+
ownerAccount: 'string',
|
|
3261
|
+
ownerId: 'number',
|
|
3262
|
+
regionId: 'string',
|
|
3263
|
+
resourceId: { 'type': 'array', 'itemType': 'string' },
|
|
3264
|
+
resourceOwnerAccount: 'string',
|
|
3265
|
+
resourceType: 'string',
|
|
3266
|
+
};
|
|
3267
|
+
}
|
|
3268
|
+
}
|
|
3269
|
+
exports.CreateFailoverTestJobRequest = CreateFailoverTestJobRequest;
|
|
3270
|
+
class CreateFailoverTestJobResponseBody extends $tea.Model {
|
|
3271
|
+
constructor(map) {
|
|
3272
|
+
super(map);
|
|
3273
|
+
}
|
|
3274
|
+
static names() {
|
|
3275
|
+
return {
|
|
3276
|
+
jobId: 'JobId',
|
|
3277
|
+
requestId: 'RequestId',
|
|
3278
|
+
};
|
|
3279
|
+
}
|
|
3280
|
+
static types() {
|
|
3281
|
+
return {
|
|
3282
|
+
jobId: 'string',
|
|
3283
|
+
requestId: 'string',
|
|
3284
|
+
};
|
|
3285
|
+
}
|
|
3286
|
+
}
|
|
3287
|
+
exports.CreateFailoverTestJobResponseBody = CreateFailoverTestJobResponseBody;
|
|
3288
|
+
class CreateFailoverTestJobResponse extends $tea.Model {
|
|
3289
|
+
constructor(map) {
|
|
3290
|
+
super(map);
|
|
3291
|
+
}
|
|
3292
|
+
static names() {
|
|
3293
|
+
return {
|
|
3294
|
+
headers: 'headers',
|
|
3295
|
+
statusCode: 'statusCode',
|
|
3296
|
+
body: 'body',
|
|
3297
|
+
};
|
|
3298
|
+
}
|
|
3299
|
+
static types() {
|
|
3300
|
+
return {
|
|
3301
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3302
|
+
statusCode: 'number',
|
|
3303
|
+
body: CreateFailoverTestJobResponseBody,
|
|
3304
|
+
};
|
|
3305
|
+
}
|
|
3306
|
+
}
|
|
3307
|
+
exports.CreateFailoverTestJobResponse = CreateFailoverTestJobResponse;
|
|
3226
3308
|
class CreateFlowLogRequest extends $tea.Model {
|
|
3227
3309
|
constructor(map) {
|
|
3228
3310
|
super(map);
|
|
@@ -4519,7 +4601,9 @@ class CreateNetworkAclRequest extends $tea.Model {
|
|
|
4519
4601
|
return {
|
|
4520
4602
|
clientToken: 'ClientToken',
|
|
4521
4603
|
description: 'Description',
|
|
4604
|
+
dryRun: 'DryRun',
|
|
4522
4605
|
networkAclName: 'NetworkAclName',
|
|
4606
|
+
ownerAccount: 'OwnerAccount',
|
|
4523
4607
|
ownerId: 'OwnerId',
|
|
4524
4608
|
regionId: 'RegionId',
|
|
4525
4609
|
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
@@ -4532,7 +4616,9 @@ class CreateNetworkAclRequest extends $tea.Model {
|
|
|
4532
4616
|
return {
|
|
4533
4617
|
clientToken: 'string',
|
|
4534
4618
|
description: 'string',
|
|
4619
|
+
dryRun: 'boolean',
|
|
4535
4620
|
networkAclName: 'string',
|
|
4621
|
+
ownerAccount: 'string',
|
|
4536
4622
|
ownerId: 'number',
|
|
4537
4623
|
regionId: 'string',
|
|
4538
4624
|
resourceOwnerAccount: 'string',
|
|
@@ -5799,6 +5885,88 @@ class CreateVSwitchResponse extends $tea.Model {
|
|
|
5799
5885
|
}
|
|
5800
5886
|
}
|
|
5801
5887
|
exports.CreateVSwitchResponse = CreateVSwitchResponse;
|
|
5888
|
+
class CreateVSwitchCidrReservationRequest extends $tea.Model {
|
|
5889
|
+
constructor(map) {
|
|
5890
|
+
super(map);
|
|
5891
|
+
}
|
|
5892
|
+
static names() {
|
|
5893
|
+
return {
|
|
5894
|
+
clientToken: 'ClientToken',
|
|
5895
|
+
dryRun: 'DryRun',
|
|
5896
|
+
ipVersion: 'IpVersion',
|
|
5897
|
+
ownerAccount: 'OwnerAccount',
|
|
5898
|
+
ownerId: 'OwnerId',
|
|
5899
|
+
regionId: 'RegionId',
|
|
5900
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
5901
|
+
resourceOwnerId: 'ResourceOwnerId',
|
|
5902
|
+
tag: 'Tag',
|
|
5903
|
+
vSwitchCidrReservationCidr: 'VSwitchCidrReservationCidr',
|
|
5904
|
+
vSwitchCidrReservationDescription: 'VSwitchCidrReservationDescription',
|
|
5905
|
+
vSwitchCidrReservationMask: 'VSwitchCidrReservationMask',
|
|
5906
|
+
vSwitchCidrReservationName: 'VSwitchCidrReservationName',
|
|
5907
|
+
vSwitchCidrReservationType: 'VSwitchCidrReservationType',
|
|
5908
|
+
vSwitchId: 'VSwitchId',
|
|
5909
|
+
};
|
|
5910
|
+
}
|
|
5911
|
+
static types() {
|
|
5912
|
+
return {
|
|
5913
|
+
clientToken: 'string',
|
|
5914
|
+
dryRun: 'boolean',
|
|
5915
|
+
ipVersion: 'string',
|
|
5916
|
+
ownerAccount: 'string',
|
|
5917
|
+
ownerId: 'number',
|
|
5918
|
+
regionId: 'string',
|
|
5919
|
+
resourceOwnerAccount: 'string',
|
|
5920
|
+
resourceOwnerId: 'number',
|
|
5921
|
+
tag: { 'type': 'array', 'itemType': CreateVSwitchCidrReservationRequestTag },
|
|
5922
|
+
vSwitchCidrReservationCidr: 'string',
|
|
5923
|
+
vSwitchCidrReservationDescription: 'string',
|
|
5924
|
+
vSwitchCidrReservationMask: 'string',
|
|
5925
|
+
vSwitchCidrReservationName: 'string',
|
|
5926
|
+
vSwitchCidrReservationType: 'string',
|
|
5927
|
+
vSwitchId: 'string',
|
|
5928
|
+
};
|
|
5929
|
+
}
|
|
5930
|
+
}
|
|
5931
|
+
exports.CreateVSwitchCidrReservationRequest = CreateVSwitchCidrReservationRequest;
|
|
5932
|
+
class CreateVSwitchCidrReservationResponseBody extends $tea.Model {
|
|
5933
|
+
constructor(map) {
|
|
5934
|
+
super(map);
|
|
5935
|
+
}
|
|
5936
|
+
static names() {
|
|
5937
|
+
return {
|
|
5938
|
+
requestId: 'RequestId',
|
|
5939
|
+
vSwitchCidrReservationId: 'VSwitchCidrReservationId',
|
|
5940
|
+
};
|
|
5941
|
+
}
|
|
5942
|
+
static types() {
|
|
5943
|
+
return {
|
|
5944
|
+
requestId: 'string',
|
|
5945
|
+
vSwitchCidrReservationId: 'string',
|
|
5946
|
+
};
|
|
5947
|
+
}
|
|
5948
|
+
}
|
|
5949
|
+
exports.CreateVSwitchCidrReservationResponseBody = CreateVSwitchCidrReservationResponseBody;
|
|
5950
|
+
class CreateVSwitchCidrReservationResponse extends $tea.Model {
|
|
5951
|
+
constructor(map) {
|
|
5952
|
+
super(map);
|
|
5953
|
+
}
|
|
5954
|
+
static names() {
|
|
5955
|
+
return {
|
|
5956
|
+
headers: 'headers',
|
|
5957
|
+
statusCode: 'statusCode',
|
|
5958
|
+
body: 'body',
|
|
5959
|
+
};
|
|
5960
|
+
}
|
|
5961
|
+
static types() {
|
|
5962
|
+
return {
|
|
5963
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
5964
|
+
statusCode: 'number',
|
|
5965
|
+
body: CreateVSwitchCidrReservationResponseBody,
|
|
5966
|
+
};
|
|
5967
|
+
}
|
|
5968
|
+
}
|
|
5969
|
+
exports.CreateVSwitchCidrReservationResponse = CreateVSwitchCidrReservationResponse;
|
|
5802
5970
|
class CreateVbrHaRequest extends $tea.Model {
|
|
5803
5971
|
constructor(map) {
|
|
5804
5972
|
super(map);
|
|
@@ -7463,6 +7631,68 @@ class DeleteDhcpOptionsSetResponse extends $tea.Model {
|
|
|
7463
7631
|
}
|
|
7464
7632
|
}
|
|
7465
7633
|
exports.DeleteDhcpOptionsSetResponse = DeleteDhcpOptionsSetResponse;
|
|
7634
|
+
class DeleteFailoverTestJobRequest extends $tea.Model {
|
|
7635
|
+
constructor(map) {
|
|
7636
|
+
super(map);
|
|
7637
|
+
}
|
|
7638
|
+
static names() {
|
|
7639
|
+
return {
|
|
7640
|
+
clientToken: 'ClientToken',
|
|
7641
|
+
jobId: 'JobId',
|
|
7642
|
+
ownerAccount: 'OwnerAccount',
|
|
7643
|
+
ownerId: 'OwnerId',
|
|
7644
|
+
regionId: 'RegionId',
|
|
7645
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
7646
|
+
};
|
|
7647
|
+
}
|
|
7648
|
+
static types() {
|
|
7649
|
+
return {
|
|
7650
|
+
clientToken: 'string',
|
|
7651
|
+
jobId: 'string',
|
|
7652
|
+
ownerAccount: 'string',
|
|
7653
|
+
ownerId: 'number',
|
|
7654
|
+
regionId: 'string',
|
|
7655
|
+
resourceOwnerAccount: 'string',
|
|
7656
|
+
};
|
|
7657
|
+
}
|
|
7658
|
+
}
|
|
7659
|
+
exports.DeleteFailoverTestJobRequest = DeleteFailoverTestJobRequest;
|
|
7660
|
+
class DeleteFailoverTestJobResponseBody extends $tea.Model {
|
|
7661
|
+
constructor(map) {
|
|
7662
|
+
super(map);
|
|
7663
|
+
}
|
|
7664
|
+
static names() {
|
|
7665
|
+
return {
|
|
7666
|
+
requestId: 'RequestId',
|
|
7667
|
+
};
|
|
7668
|
+
}
|
|
7669
|
+
static types() {
|
|
7670
|
+
return {
|
|
7671
|
+
requestId: 'string',
|
|
7672
|
+
};
|
|
7673
|
+
}
|
|
7674
|
+
}
|
|
7675
|
+
exports.DeleteFailoverTestJobResponseBody = DeleteFailoverTestJobResponseBody;
|
|
7676
|
+
class DeleteFailoverTestJobResponse extends $tea.Model {
|
|
7677
|
+
constructor(map) {
|
|
7678
|
+
super(map);
|
|
7679
|
+
}
|
|
7680
|
+
static names() {
|
|
7681
|
+
return {
|
|
7682
|
+
headers: 'headers',
|
|
7683
|
+
statusCode: 'statusCode',
|
|
7684
|
+
body: 'body',
|
|
7685
|
+
};
|
|
7686
|
+
}
|
|
7687
|
+
static types() {
|
|
7688
|
+
return {
|
|
7689
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
7690
|
+
statusCode: 'number',
|
|
7691
|
+
body: DeleteFailoverTestJobResponseBody,
|
|
7692
|
+
};
|
|
7693
|
+
}
|
|
7694
|
+
}
|
|
7695
|
+
exports.DeleteFailoverTestJobResponse = DeleteFailoverTestJobResponse;
|
|
7466
7696
|
class DeleteFlowLogRequest extends $tea.Model {
|
|
7467
7697
|
constructor(map) {
|
|
7468
7698
|
super(map);
|
|
@@ -8500,7 +8730,9 @@ class DeleteNetworkAclRequest extends $tea.Model {
|
|
|
8500
8730
|
static names() {
|
|
8501
8731
|
return {
|
|
8502
8732
|
clientToken: 'ClientToken',
|
|
8733
|
+
dryRun: 'DryRun',
|
|
8503
8734
|
networkAclId: 'NetworkAclId',
|
|
8735
|
+
ownerAccount: 'OwnerAccount',
|
|
8504
8736
|
ownerId: 'OwnerId',
|
|
8505
8737
|
regionId: 'RegionId',
|
|
8506
8738
|
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
@@ -8510,7 +8742,9 @@ class DeleteNetworkAclRequest extends $tea.Model {
|
|
|
8510
8742
|
static types() {
|
|
8511
8743
|
return {
|
|
8512
8744
|
clientToken: 'string',
|
|
8745
|
+
dryRun: 'boolean',
|
|
8513
8746
|
networkAclId: 'string',
|
|
8747
|
+
ownerAccount: 'string',
|
|
8514
8748
|
ownerId: 'number',
|
|
8515
8749
|
regionId: 'string',
|
|
8516
8750
|
resourceOwnerAccount: 'string',
|
|
@@ -11279,6 +11513,146 @@ class DescribeEipSegmentResponse extends $tea.Model {
|
|
|
11279
11513
|
}
|
|
11280
11514
|
}
|
|
11281
11515
|
exports.DescribeEipSegmentResponse = DescribeEipSegmentResponse;
|
|
11516
|
+
class DescribeFailoverTestJobRequest extends $tea.Model {
|
|
11517
|
+
constructor(map) {
|
|
11518
|
+
super(map);
|
|
11519
|
+
}
|
|
11520
|
+
static names() {
|
|
11521
|
+
return {
|
|
11522
|
+
clientToken: 'ClientToken',
|
|
11523
|
+
jobId: 'JobId',
|
|
11524
|
+
ownerAccount: 'OwnerAccount',
|
|
11525
|
+
ownerId: 'OwnerId',
|
|
11526
|
+
regionId: 'RegionId',
|
|
11527
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
11528
|
+
};
|
|
11529
|
+
}
|
|
11530
|
+
static types() {
|
|
11531
|
+
return {
|
|
11532
|
+
clientToken: 'string',
|
|
11533
|
+
jobId: 'string',
|
|
11534
|
+
ownerAccount: 'string',
|
|
11535
|
+
ownerId: 'number',
|
|
11536
|
+
regionId: 'string',
|
|
11537
|
+
resourceOwnerAccount: 'string',
|
|
11538
|
+
};
|
|
11539
|
+
}
|
|
11540
|
+
}
|
|
11541
|
+
exports.DescribeFailoverTestJobRequest = DescribeFailoverTestJobRequest;
|
|
11542
|
+
class DescribeFailoverTestJobResponseBody extends $tea.Model {
|
|
11543
|
+
constructor(map) {
|
|
11544
|
+
super(map);
|
|
11545
|
+
}
|
|
11546
|
+
static names() {
|
|
11547
|
+
return {
|
|
11548
|
+
failoverTestJobModel: 'FailoverTestJobModel',
|
|
11549
|
+
requestId: 'RequestId',
|
|
11550
|
+
};
|
|
11551
|
+
}
|
|
11552
|
+
static types() {
|
|
11553
|
+
return {
|
|
11554
|
+
failoverTestJobModel: DescribeFailoverTestJobResponseBodyFailoverTestJobModel,
|
|
11555
|
+
requestId: 'string',
|
|
11556
|
+
};
|
|
11557
|
+
}
|
|
11558
|
+
}
|
|
11559
|
+
exports.DescribeFailoverTestJobResponseBody = DescribeFailoverTestJobResponseBody;
|
|
11560
|
+
class DescribeFailoverTestJobResponse extends $tea.Model {
|
|
11561
|
+
constructor(map) {
|
|
11562
|
+
super(map);
|
|
11563
|
+
}
|
|
11564
|
+
static names() {
|
|
11565
|
+
return {
|
|
11566
|
+
headers: 'headers',
|
|
11567
|
+
statusCode: 'statusCode',
|
|
11568
|
+
body: 'body',
|
|
11569
|
+
};
|
|
11570
|
+
}
|
|
11571
|
+
static types() {
|
|
11572
|
+
return {
|
|
11573
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
11574
|
+
statusCode: 'number',
|
|
11575
|
+
body: DescribeFailoverTestJobResponseBody,
|
|
11576
|
+
};
|
|
11577
|
+
}
|
|
11578
|
+
}
|
|
11579
|
+
exports.DescribeFailoverTestJobResponse = DescribeFailoverTestJobResponse;
|
|
11580
|
+
class DescribeFailoverTestJobsRequest extends $tea.Model {
|
|
11581
|
+
constructor(map) {
|
|
11582
|
+
super(map);
|
|
11583
|
+
}
|
|
11584
|
+
static names() {
|
|
11585
|
+
return {
|
|
11586
|
+
clientToken: 'ClientToken',
|
|
11587
|
+
filter: 'Filter',
|
|
11588
|
+
maxResults: 'MaxResults',
|
|
11589
|
+
nextToken: 'NextToken',
|
|
11590
|
+
ownerAccount: 'OwnerAccount',
|
|
11591
|
+
ownerId: 'OwnerId',
|
|
11592
|
+
regionId: 'RegionId',
|
|
11593
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
11594
|
+
};
|
|
11595
|
+
}
|
|
11596
|
+
static types() {
|
|
11597
|
+
return {
|
|
11598
|
+
clientToken: 'string',
|
|
11599
|
+
filter: { 'type': 'array', 'itemType': DescribeFailoverTestJobsRequestFilter },
|
|
11600
|
+
maxResults: 'number',
|
|
11601
|
+
nextToken: 'string',
|
|
11602
|
+
ownerAccount: 'string',
|
|
11603
|
+
ownerId: 'number',
|
|
11604
|
+
regionId: 'string',
|
|
11605
|
+
resourceOwnerAccount: 'string',
|
|
11606
|
+
};
|
|
11607
|
+
}
|
|
11608
|
+
}
|
|
11609
|
+
exports.DescribeFailoverTestJobsRequest = DescribeFailoverTestJobsRequest;
|
|
11610
|
+
class DescribeFailoverTestJobsResponseBody extends $tea.Model {
|
|
11611
|
+
constructor(map) {
|
|
11612
|
+
super(map);
|
|
11613
|
+
}
|
|
11614
|
+
static names() {
|
|
11615
|
+
return {
|
|
11616
|
+
count: 'Count',
|
|
11617
|
+
failoverTestJobList: 'FailoverTestJobList',
|
|
11618
|
+
maxResults: 'MaxResults',
|
|
11619
|
+
nextToken: 'NextToken',
|
|
11620
|
+
requestId: 'RequestId',
|
|
11621
|
+
totalCount: 'TotalCount',
|
|
11622
|
+
};
|
|
11623
|
+
}
|
|
11624
|
+
static types() {
|
|
11625
|
+
return {
|
|
11626
|
+
count: 'number',
|
|
11627
|
+
failoverTestJobList: { 'type': 'array', 'itemType': DescribeFailoverTestJobsResponseBodyFailoverTestJobList },
|
|
11628
|
+
maxResults: 'number',
|
|
11629
|
+
nextToken: 'string',
|
|
11630
|
+
requestId: 'string',
|
|
11631
|
+
totalCount: 'number',
|
|
11632
|
+
};
|
|
11633
|
+
}
|
|
11634
|
+
}
|
|
11635
|
+
exports.DescribeFailoverTestJobsResponseBody = DescribeFailoverTestJobsResponseBody;
|
|
11636
|
+
class DescribeFailoverTestJobsResponse extends $tea.Model {
|
|
11637
|
+
constructor(map) {
|
|
11638
|
+
super(map);
|
|
11639
|
+
}
|
|
11640
|
+
static names() {
|
|
11641
|
+
return {
|
|
11642
|
+
headers: 'headers',
|
|
11643
|
+
statusCode: 'statusCode',
|
|
11644
|
+
body: 'body',
|
|
11645
|
+
};
|
|
11646
|
+
}
|
|
11647
|
+
static types() {
|
|
11648
|
+
return {
|
|
11649
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
11650
|
+
statusCode: 'number',
|
|
11651
|
+
body: DescribeFailoverTestJobsResponseBody,
|
|
11652
|
+
};
|
|
11653
|
+
}
|
|
11654
|
+
}
|
|
11655
|
+
exports.DescribeFailoverTestJobsResponse = DescribeFailoverTestJobsResponse;
|
|
11282
11656
|
class DescribeFlowLogsRequest extends $tea.Model {
|
|
11283
11657
|
constructor(map) {
|
|
11284
11658
|
super(map);
|
|
@@ -12577,6 +12951,7 @@ class DescribeNetworkAclAttributesRequest extends $tea.Model {
|
|
|
12577
12951
|
return {
|
|
12578
12952
|
clientToken: 'ClientToken',
|
|
12579
12953
|
networkAclId: 'NetworkAclId',
|
|
12954
|
+
ownerAccount: 'OwnerAccount',
|
|
12580
12955
|
ownerId: 'OwnerId',
|
|
12581
12956
|
regionId: 'RegionId',
|
|
12582
12957
|
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
@@ -12587,6 +12962,7 @@ class DescribeNetworkAclAttributesRequest extends $tea.Model {
|
|
|
12587
12962
|
return {
|
|
12588
12963
|
clientToken: 'string',
|
|
12589
12964
|
networkAclId: 'string',
|
|
12965
|
+
ownerAccount: 'string',
|
|
12590
12966
|
ownerId: 'number',
|
|
12591
12967
|
regionId: 'string',
|
|
12592
12968
|
resourceOwnerAccount: 'string',
|
|
@@ -12642,6 +13018,7 @@ class DescribeNetworkAclsRequest extends $tea.Model {
|
|
|
12642
13018
|
clientToken: 'ClientToken',
|
|
12643
13019
|
networkAclId: 'NetworkAclId',
|
|
12644
13020
|
networkAclName: 'NetworkAclName',
|
|
13021
|
+
ownerAccount: 'OwnerAccount',
|
|
12645
13022
|
ownerId: 'OwnerId',
|
|
12646
13023
|
pageNumber: 'PageNumber',
|
|
12647
13024
|
pageSize: 'PageSize',
|
|
@@ -12659,6 +13036,7 @@ class DescribeNetworkAclsRequest extends $tea.Model {
|
|
|
12659
13036
|
clientToken: 'string',
|
|
12660
13037
|
networkAclId: 'string',
|
|
12661
13038
|
networkAclName: 'string',
|
|
13039
|
+
ownerAccount: 'string',
|
|
12662
13040
|
ownerId: 'number',
|
|
12663
13041
|
pageNumber: 'number',
|
|
12664
13042
|
pageSize: 'number',
|
|
@@ -17143,6 +17521,80 @@ class GetTrafficMirrorServiceStatusResponse extends $tea.Model {
|
|
|
17143
17521
|
}
|
|
17144
17522
|
}
|
|
17145
17523
|
exports.GetTrafficMirrorServiceStatusResponse = GetTrafficMirrorServiceStatusResponse;
|
|
17524
|
+
class GetVSwitchCidrReservationUsageRequest extends $tea.Model {
|
|
17525
|
+
constructor(map) {
|
|
17526
|
+
super(map);
|
|
17527
|
+
}
|
|
17528
|
+
static names() {
|
|
17529
|
+
return {
|
|
17530
|
+
maxResults: 'MaxResults',
|
|
17531
|
+
nextToken: 'NextToken',
|
|
17532
|
+
ownerAccount: 'OwnerAccount',
|
|
17533
|
+
ownerId: 'OwnerId',
|
|
17534
|
+
regionId: 'RegionId',
|
|
17535
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
17536
|
+
resourceOwnerId: 'ResourceOwnerId',
|
|
17537
|
+
vSwitchCidrReservationId: 'VSwitchCidrReservationId',
|
|
17538
|
+
};
|
|
17539
|
+
}
|
|
17540
|
+
static types() {
|
|
17541
|
+
return {
|
|
17542
|
+
maxResults: 'number',
|
|
17543
|
+
nextToken: 'string',
|
|
17544
|
+
ownerAccount: 'string',
|
|
17545
|
+
ownerId: 'number',
|
|
17546
|
+
regionId: 'string',
|
|
17547
|
+
resourceOwnerAccount: 'string',
|
|
17548
|
+
resourceOwnerId: 'number',
|
|
17549
|
+
vSwitchCidrReservationId: 'string',
|
|
17550
|
+
};
|
|
17551
|
+
}
|
|
17552
|
+
}
|
|
17553
|
+
exports.GetVSwitchCidrReservationUsageRequest = GetVSwitchCidrReservationUsageRequest;
|
|
17554
|
+
class GetVSwitchCidrReservationUsageResponseBody extends $tea.Model {
|
|
17555
|
+
constructor(map) {
|
|
17556
|
+
super(map);
|
|
17557
|
+
}
|
|
17558
|
+
static names() {
|
|
17559
|
+
return {
|
|
17560
|
+
cidrReservationUsages: 'CidrReservationUsages',
|
|
17561
|
+
maxResults: 'MaxResults',
|
|
17562
|
+
nextToken: 'NextToken',
|
|
17563
|
+
requestId: 'RequestId',
|
|
17564
|
+
totalCount: 'TotalCount',
|
|
17565
|
+
};
|
|
17566
|
+
}
|
|
17567
|
+
static types() {
|
|
17568
|
+
return {
|
|
17569
|
+
cidrReservationUsages: { 'type': 'array', 'itemType': GetVSwitchCidrReservationUsageResponseBodyCidrReservationUsages },
|
|
17570
|
+
maxResults: 'number',
|
|
17571
|
+
nextToken: 'string',
|
|
17572
|
+
requestId: 'string',
|
|
17573
|
+
totalCount: 'number',
|
|
17574
|
+
};
|
|
17575
|
+
}
|
|
17576
|
+
}
|
|
17577
|
+
exports.GetVSwitchCidrReservationUsageResponseBody = GetVSwitchCidrReservationUsageResponseBody;
|
|
17578
|
+
class GetVSwitchCidrReservationUsageResponse extends $tea.Model {
|
|
17579
|
+
constructor(map) {
|
|
17580
|
+
super(map);
|
|
17581
|
+
}
|
|
17582
|
+
static names() {
|
|
17583
|
+
return {
|
|
17584
|
+
headers: 'headers',
|
|
17585
|
+
statusCode: 'statusCode',
|
|
17586
|
+
body: 'body',
|
|
17587
|
+
};
|
|
17588
|
+
}
|
|
17589
|
+
static types() {
|
|
17590
|
+
return {
|
|
17591
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
17592
|
+
statusCode: 'number',
|
|
17593
|
+
body: GetVSwitchCidrReservationUsageResponseBody,
|
|
17594
|
+
};
|
|
17595
|
+
}
|
|
17596
|
+
}
|
|
17597
|
+
exports.GetVSwitchCidrReservationUsageResponse = GetVSwitchCidrReservationUsageResponse;
|
|
17146
17598
|
class GetVpcGatewayEndpointAttributeRequest extends $tea.Model {
|
|
17147
17599
|
constructor(map) {
|
|
17148
17600
|
super(map);
|
|
@@ -19033,6 +19485,88 @@ class ListTrafficMirrorSessionsResponse extends $tea.Model {
|
|
|
19033
19485
|
}
|
|
19034
19486
|
}
|
|
19035
19487
|
exports.ListTrafficMirrorSessionsResponse = ListTrafficMirrorSessionsResponse;
|
|
19488
|
+
class ListVSwitchCidrReservationsRequest extends $tea.Model {
|
|
19489
|
+
constructor(map) {
|
|
19490
|
+
super(map);
|
|
19491
|
+
}
|
|
19492
|
+
static names() {
|
|
19493
|
+
return {
|
|
19494
|
+
ipVersion: 'IpVersion',
|
|
19495
|
+
maxResults: 'MaxResults',
|
|
19496
|
+
nextToken: 'NextToken',
|
|
19497
|
+
ownerAccount: 'OwnerAccount',
|
|
19498
|
+
ownerId: 'OwnerId',
|
|
19499
|
+
regionId: 'RegionId',
|
|
19500
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
19501
|
+
resourceOwnerId: 'ResourceOwnerId',
|
|
19502
|
+
tags: 'Tags',
|
|
19503
|
+
vSwitchCidrReservationIds: 'VSwitchCidrReservationIds',
|
|
19504
|
+
vSwitchCidrReservationType: 'VSwitchCidrReservationType',
|
|
19505
|
+
vSwitchId: 'VSwitchId',
|
|
19506
|
+
};
|
|
19507
|
+
}
|
|
19508
|
+
static types() {
|
|
19509
|
+
return {
|
|
19510
|
+
ipVersion: 'string',
|
|
19511
|
+
maxResults: 'number',
|
|
19512
|
+
nextToken: 'string',
|
|
19513
|
+
ownerAccount: 'string',
|
|
19514
|
+
ownerId: 'number',
|
|
19515
|
+
regionId: 'string',
|
|
19516
|
+
resourceOwnerAccount: 'string',
|
|
19517
|
+
resourceOwnerId: 'number',
|
|
19518
|
+
tags: { 'type': 'array', 'itemType': ListVSwitchCidrReservationsRequestTags },
|
|
19519
|
+
vSwitchCidrReservationIds: { 'type': 'array', 'itemType': 'string' },
|
|
19520
|
+
vSwitchCidrReservationType: 'string',
|
|
19521
|
+
vSwitchId: 'string',
|
|
19522
|
+
};
|
|
19523
|
+
}
|
|
19524
|
+
}
|
|
19525
|
+
exports.ListVSwitchCidrReservationsRequest = ListVSwitchCidrReservationsRequest;
|
|
19526
|
+
class ListVSwitchCidrReservationsResponseBody extends $tea.Model {
|
|
19527
|
+
constructor(map) {
|
|
19528
|
+
super(map);
|
|
19529
|
+
}
|
|
19530
|
+
static names() {
|
|
19531
|
+
return {
|
|
19532
|
+
maxResults: 'MaxResults',
|
|
19533
|
+
nextToken: 'NextToken',
|
|
19534
|
+
requestId: 'RequestId',
|
|
19535
|
+
totalCount: 'TotalCount',
|
|
19536
|
+
vSwitchCidrReservations: 'VSwitchCidrReservations',
|
|
19537
|
+
};
|
|
19538
|
+
}
|
|
19539
|
+
static types() {
|
|
19540
|
+
return {
|
|
19541
|
+
maxResults: 'number',
|
|
19542
|
+
nextToken: 'string',
|
|
19543
|
+
requestId: 'string',
|
|
19544
|
+
totalCount: 'number',
|
|
19545
|
+
vSwitchCidrReservations: { 'type': 'array', 'itemType': ListVSwitchCidrReservationsResponseBodyVSwitchCidrReservations },
|
|
19546
|
+
};
|
|
19547
|
+
}
|
|
19548
|
+
}
|
|
19549
|
+
exports.ListVSwitchCidrReservationsResponseBody = ListVSwitchCidrReservationsResponseBody;
|
|
19550
|
+
class ListVSwitchCidrReservationsResponse extends $tea.Model {
|
|
19551
|
+
constructor(map) {
|
|
19552
|
+
super(map);
|
|
19553
|
+
}
|
|
19554
|
+
static names() {
|
|
19555
|
+
return {
|
|
19556
|
+
headers: 'headers',
|
|
19557
|
+
statusCode: 'statusCode',
|
|
19558
|
+
body: 'body',
|
|
19559
|
+
};
|
|
19560
|
+
}
|
|
19561
|
+
static types() {
|
|
19562
|
+
return {
|
|
19563
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
19564
|
+
statusCode: 'number',
|
|
19565
|
+
body: ListVSwitchCidrReservationsResponseBody,
|
|
19566
|
+
};
|
|
19567
|
+
}
|
|
19568
|
+
}
|
|
19569
|
+
exports.ListVSwitchCidrReservationsResponse = ListVSwitchCidrReservationsResponse;
|
|
19036
19570
|
class ListVirtualPhysicalConnectionsRequest extends $tea.Model {
|
|
19037
19571
|
constructor(map) {
|
|
19038
19572
|
super(map);
|
|
@@ -21247,8 +21781,10 @@ class ModifyNetworkAclAttributesRequest extends $tea.Model {
|
|
|
21247
21781
|
return {
|
|
21248
21782
|
clientToken: 'ClientToken',
|
|
21249
21783
|
description: 'Description',
|
|
21784
|
+
dryRun: 'DryRun',
|
|
21250
21785
|
networkAclId: 'NetworkAclId',
|
|
21251
21786
|
networkAclName: 'NetworkAclName',
|
|
21787
|
+
ownerAccount: 'OwnerAccount',
|
|
21252
21788
|
ownerId: 'OwnerId',
|
|
21253
21789
|
regionId: 'RegionId',
|
|
21254
21790
|
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
@@ -21259,8 +21795,10 @@ class ModifyNetworkAclAttributesRequest extends $tea.Model {
|
|
|
21259
21795
|
return {
|
|
21260
21796
|
clientToken: 'string',
|
|
21261
21797
|
description: 'string',
|
|
21798
|
+
dryRun: 'boolean',
|
|
21262
21799
|
networkAclId: 'string',
|
|
21263
21800
|
networkAclName: 'string',
|
|
21801
|
+
ownerAccount: 'string',
|
|
21264
21802
|
ownerId: 'number',
|
|
21265
21803
|
regionId: 'string',
|
|
21266
21804
|
resourceOwnerAccount: 'string',
|
|
@@ -22159,6 +22697,72 @@ class ModifyVSwitchAttributeResponse extends $tea.Model {
|
|
|
22159
22697
|
}
|
|
22160
22698
|
}
|
|
22161
22699
|
exports.ModifyVSwitchAttributeResponse = ModifyVSwitchAttributeResponse;
|
|
22700
|
+
class ModifyVSwitchCidrReservationAttributeRequest extends $tea.Model {
|
|
22701
|
+
constructor(map) {
|
|
22702
|
+
super(map);
|
|
22703
|
+
}
|
|
22704
|
+
static names() {
|
|
22705
|
+
return {
|
|
22706
|
+
ownerAccount: 'OwnerAccount',
|
|
22707
|
+
ownerId: 'OwnerId',
|
|
22708
|
+
regionId: 'RegionId',
|
|
22709
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
22710
|
+
resourceOwnerId: 'ResourceOwnerId',
|
|
22711
|
+
vSwitchCidrReservationDescription: 'VSwitchCidrReservationDescription',
|
|
22712
|
+
vSwitchCidrReservationId: 'VSwitchCidrReservationId',
|
|
22713
|
+
vSwitchCidrReservationName: 'VSwitchCidrReservationName',
|
|
22714
|
+
};
|
|
22715
|
+
}
|
|
22716
|
+
static types() {
|
|
22717
|
+
return {
|
|
22718
|
+
ownerAccount: 'string',
|
|
22719
|
+
ownerId: 'number',
|
|
22720
|
+
regionId: 'string',
|
|
22721
|
+
resourceOwnerAccount: 'string',
|
|
22722
|
+
resourceOwnerId: 'number',
|
|
22723
|
+
vSwitchCidrReservationDescription: 'string',
|
|
22724
|
+
vSwitchCidrReservationId: 'string',
|
|
22725
|
+
vSwitchCidrReservationName: 'string',
|
|
22726
|
+
};
|
|
22727
|
+
}
|
|
22728
|
+
}
|
|
22729
|
+
exports.ModifyVSwitchCidrReservationAttributeRequest = ModifyVSwitchCidrReservationAttributeRequest;
|
|
22730
|
+
class ModifyVSwitchCidrReservationAttributeResponseBody extends $tea.Model {
|
|
22731
|
+
constructor(map) {
|
|
22732
|
+
super(map);
|
|
22733
|
+
}
|
|
22734
|
+
static names() {
|
|
22735
|
+
return {
|
|
22736
|
+
requestId: 'RequestId',
|
|
22737
|
+
};
|
|
22738
|
+
}
|
|
22739
|
+
static types() {
|
|
22740
|
+
return {
|
|
22741
|
+
requestId: 'string',
|
|
22742
|
+
};
|
|
22743
|
+
}
|
|
22744
|
+
}
|
|
22745
|
+
exports.ModifyVSwitchCidrReservationAttributeResponseBody = ModifyVSwitchCidrReservationAttributeResponseBody;
|
|
22746
|
+
class ModifyVSwitchCidrReservationAttributeResponse extends $tea.Model {
|
|
22747
|
+
constructor(map) {
|
|
22748
|
+
super(map);
|
|
22749
|
+
}
|
|
22750
|
+
static names() {
|
|
22751
|
+
return {
|
|
22752
|
+
headers: 'headers',
|
|
22753
|
+
statusCode: 'statusCode',
|
|
22754
|
+
body: 'body',
|
|
22755
|
+
};
|
|
22756
|
+
}
|
|
22757
|
+
static types() {
|
|
22758
|
+
return {
|
|
22759
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
22760
|
+
statusCode: 'number',
|
|
22761
|
+
body: ModifyVSwitchCidrReservationAttributeResponseBody,
|
|
22762
|
+
};
|
|
22763
|
+
}
|
|
22764
|
+
}
|
|
22765
|
+
exports.ModifyVSwitchCidrReservationAttributeResponse = ModifyVSwitchCidrReservationAttributeResponse;
|
|
22162
22766
|
class ModifyVcoRouteEntryWeightRequest extends $tea.Model {
|
|
22163
22767
|
constructor(map) {
|
|
22164
22768
|
super(map);
|
|
@@ -23217,6 +23821,72 @@ class MoveResourceGroupResponse extends $tea.Model {
|
|
|
23217
23821
|
}
|
|
23218
23822
|
}
|
|
23219
23823
|
exports.MoveResourceGroupResponse = MoveResourceGroupResponse;
|
|
23824
|
+
class MoveVpnResourceGroupRequest extends $tea.Model {
|
|
23825
|
+
constructor(map) {
|
|
23826
|
+
super(map);
|
|
23827
|
+
}
|
|
23828
|
+
static names() {
|
|
23829
|
+
return {
|
|
23830
|
+
instanceId: 'InstanceId',
|
|
23831
|
+
newResourceGroupId: 'NewResourceGroupId',
|
|
23832
|
+
ownerAccount: 'OwnerAccount',
|
|
23833
|
+
ownerId: 'OwnerId',
|
|
23834
|
+
regionId: 'RegionId',
|
|
23835
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
23836
|
+
resourceOwnerId: 'ResourceOwnerId',
|
|
23837
|
+
resourceType: 'ResourceType',
|
|
23838
|
+
};
|
|
23839
|
+
}
|
|
23840
|
+
static types() {
|
|
23841
|
+
return {
|
|
23842
|
+
instanceId: 'string',
|
|
23843
|
+
newResourceGroupId: 'string',
|
|
23844
|
+
ownerAccount: 'string',
|
|
23845
|
+
ownerId: 'number',
|
|
23846
|
+
regionId: 'string',
|
|
23847
|
+
resourceOwnerAccount: 'string',
|
|
23848
|
+
resourceOwnerId: 'number',
|
|
23849
|
+
resourceType: 'string',
|
|
23850
|
+
};
|
|
23851
|
+
}
|
|
23852
|
+
}
|
|
23853
|
+
exports.MoveVpnResourceGroupRequest = MoveVpnResourceGroupRequest;
|
|
23854
|
+
class MoveVpnResourceGroupResponseBody extends $tea.Model {
|
|
23855
|
+
constructor(map) {
|
|
23856
|
+
super(map);
|
|
23857
|
+
}
|
|
23858
|
+
static names() {
|
|
23859
|
+
return {
|
|
23860
|
+
requestId: 'RequestId',
|
|
23861
|
+
};
|
|
23862
|
+
}
|
|
23863
|
+
static types() {
|
|
23864
|
+
return {
|
|
23865
|
+
requestId: 'string',
|
|
23866
|
+
};
|
|
23867
|
+
}
|
|
23868
|
+
}
|
|
23869
|
+
exports.MoveVpnResourceGroupResponseBody = MoveVpnResourceGroupResponseBody;
|
|
23870
|
+
class MoveVpnResourceGroupResponse extends $tea.Model {
|
|
23871
|
+
constructor(map) {
|
|
23872
|
+
super(map);
|
|
23873
|
+
}
|
|
23874
|
+
static names() {
|
|
23875
|
+
return {
|
|
23876
|
+
headers: 'headers',
|
|
23877
|
+
statusCode: 'statusCode',
|
|
23878
|
+
body: 'body',
|
|
23879
|
+
};
|
|
23880
|
+
}
|
|
23881
|
+
static types() {
|
|
23882
|
+
return {
|
|
23883
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
23884
|
+
statusCode: 'number',
|
|
23885
|
+
body: MoveVpnResourceGroupResponseBody,
|
|
23886
|
+
};
|
|
23887
|
+
}
|
|
23888
|
+
}
|
|
23889
|
+
exports.MoveVpnResourceGroupResponse = MoveVpnResourceGroupResponse;
|
|
23220
23890
|
class OpenFlowLogServiceRequest extends $tea.Model {
|
|
23221
23891
|
constructor(map) {
|
|
23222
23892
|
super(map);
|
|
@@ -24439,6 +25109,130 @@ class SetHighDefinitionMonitorLogStatusResponse extends $tea.Model {
|
|
|
24439
25109
|
}
|
|
24440
25110
|
}
|
|
24441
25111
|
exports.SetHighDefinitionMonitorLogStatusResponse = SetHighDefinitionMonitorLogStatusResponse;
|
|
25112
|
+
class StartFailoverTestJobRequest extends $tea.Model {
|
|
25113
|
+
constructor(map) {
|
|
25114
|
+
super(map);
|
|
25115
|
+
}
|
|
25116
|
+
static names() {
|
|
25117
|
+
return {
|
|
25118
|
+
clientToken: 'ClientToken',
|
|
25119
|
+
jobId: 'JobId',
|
|
25120
|
+
ownerAccount: 'OwnerAccount',
|
|
25121
|
+
ownerId: 'OwnerId',
|
|
25122
|
+
regionId: 'RegionId',
|
|
25123
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
25124
|
+
};
|
|
25125
|
+
}
|
|
25126
|
+
static types() {
|
|
25127
|
+
return {
|
|
25128
|
+
clientToken: 'string',
|
|
25129
|
+
jobId: 'string',
|
|
25130
|
+
ownerAccount: 'string',
|
|
25131
|
+
ownerId: 'number',
|
|
25132
|
+
regionId: 'string',
|
|
25133
|
+
resourceOwnerAccount: 'string',
|
|
25134
|
+
};
|
|
25135
|
+
}
|
|
25136
|
+
}
|
|
25137
|
+
exports.StartFailoverTestJobRequest = StartFailoverTestJobRequest;
|
|
25138
|
+
class StartFailoverTestJobResponseBody extends $tea.Model {
|
|
25139
|
+
constructor(map) {
|
|
25140
|
+
super(map);
|
|
25141
|
+
}
|
|
25142
|
+
static names() {
|
|
25143
|
+
return {
|
|
25144
|
+
requestId: 'RequestId',
|
|
25145
|
+
};
|
|
25146
|
+
}
|
|
25147
|
+
static types() {
|
|
25148
|
+
return {
|
|
25149
|
+
requestId: 'string',
|
|
25150
|
+
};
|
|
25151
|
+
}
|
|
25152
|
+
}
|
|
25153
|
+
exports.StartFailoverTestJobResponseBody = StartFailoverTestJobResponseBody;
|
|
25154
|
+
class StartFailoverTestJobResponse extends $tea.Model {
|
|
25155
|
+
constructor(map) {
|
|
25156
|
+
super(map);
|
|
25157
|
+
}
|
|
25158
|
+
static names() {
|
|
25159
|
+
return {
|
|
25160
|
+
headers: 'headers',
|
|
25161
|
+
statusCode: 'statusCode',
|
|
25162
|
+
body: 'body',
|
|
25163
|
+
};
|
|
25164
|
+
}
|
|
25165
|
+
static types() {
|
|
25166
|
+
return {
|
|
25167
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
25168
|
+
statusCode: 'number',
|
|
25169
|
+
body: StartFailoverTestJobResponseBody,
|
|
25170
|
+
};
|
|
25171
|
+
}
|
|
25172
|
+
}
|
|
25173
|
+
exports.StartFailoverTestJobResponse = StartFailoverTestJobResponse;
|
|
25174
|
+
class StopFailoverTestJobRequest extends $tea.Model {
|
|
25175
|
+
constructor(map) {
|
|
25176
|
+
super(map);
|
|
25177
|
+
}
|
|
25178
|
+
static names() {
|
|
25179
|
+
return {
|
|
25180
|
+
clientToken: 'ClientToken',
|
|
25181
|
+
jobId: 'JobId',
|
|
25182
|
+
ownerAccount: 'OwnerAccount',
|
|
25183
|
+
ownerId: 'OwnerId',
|
|
25184
|
+
regionId: 'RegionId',
|
|
25185
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
25186
|
+
};
|
|
25187
|
+
}
|
|
25188
|
+
static types() {
|
|
25189
|
+
return {
|
|
25190
|
+
clientToken: 'string',
|
|
25191
|
+
jobId: 'string',
|
|
25192
|
+
ownerAccount: 'string',
|
|
25193
|
+
ownerId: 'number',
|
|
25194
|
+
regionId: 'string',
|
|
25195
|
+
resourceOwnerAccount: 'string',
|
|
25196
|
+
};
|
|
25197
|
+
}
|
|
25198
|
+
}
|
|
25199
|
+
exports.StopFailoverTestJobRequest = StopFailoverTestJobRequest;
|
|
25200
|
+
class StopFailoverTestJobResponseBody extends $tea.Model {
|
|
25201
|
+
constructor(map) {
|
|
25202
|
+
super(map);
|
|
25203
|
+
}
|
|
25204
|
+
static names() {
|
|
25205
|
+
return {
|
|
25206
|
+
requestId: 'RequestId',
|
|
25207
|
+
};
|
|
25208
|
+
}
|
|
25209
|
+
static types() {
|
|
25210
|
+
return {
|
|
25211
|
+
requestId: 'string',
|
|
25212
|
+
};
|
|
25213
|
+
}
|
|
25214
|
+
}
|
|
25215
|
+
exports.StopFailoverTestJobResponseBody = StopFailoverTestJobResponseBody;
|
|
25216
|
+
class StopFailoverTestJobResponse extends $tea.Model {
|
|
25217
|
+
constructor(map) {
|
|
25218
|
+
super(map);
|
|
25219
|
+
}
|
|
25220
|
+
static names() {
|
|
25221
|
+
return {
|
|
25222
|
+
headers: 'headers',
|
|
25223
|
+
statusCode: 'statusCode',
|
|
25224
|
+
body: 'body',
|
|
25225
|
+
};
|
|
25226
|
+
}
|
|
25227
|
+
static types() {
|
|
25228
|
+
return {
|
|
25229
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
25230
|
+
statusCode: 'number',
|
|
25231
|
+
body: StopFailoverTestJobResponseBody,
|
|
25232
|
+
};
|
|
25233
|
+
}
|
|
25234
|
+
}
|
|
25235
|
+
exports.StopFailoverTestJobResponse = StopFailoverTestJobResponse;
|
|
24442
25236
|
class TagResourcesRequest extends $tea.Model {
|
|
24443
25237
|
constructor(map) {
|
|
24444
25238
|
super(map);
|
|
@@ -24980,7 +25774,9 @@ class UnassociateNetworkAclRequest extends $tea.Model {
|
|
|
24980
25774
|
static names() {
|
|
24981
25775
|
return {
|
|
24982
25776
|
clientToken: 'ClientToken',
|
|
25777
|
+
dryRun: 'DryRun',
|
|
24983
25778
|
networkAclId: 'NetworkAclId',
|
|
25779
|
+
ownerAccount: 'OwnerAccount',
|
|
24984
25780
|
ownerId: 'OwnerId',
|
|
24985
25781
|
regionId: 'RegionId',
|
|
24986
25782
|
resource: 'Resource',
|
|
@@ -24991,7 +25787,9 @@ class UnassociateNetworkAclRequest extends $tea.Model {
|
|
|
24991
25787
|
static types() {
|
|
24992
25788
|
return {
|
|
24993
25789
|
clientToken: 'string',
|
|
25790
|
+
dryRun: 'boolean',
|
|
24994
25791
|
networkAclId: 'string',
|
|
25792
|
+
ownerAccount: 'string',
|
|
24995
25793
|
ownerId: 'number',
|
|
24996
25794
|
regionId: 'string',
|
|
24997
25795
|
resource: { 'type': 'array', 'itemType': UnassociateNetworkAclRequestResource },
|
|
@@ -25381,6 +26179,76 @@ class UpdateDhcpOptionsSetAttributeResponse extends $tea.Model {
|
|
|
25381
26179
|
}
|
|
25382
26180
|
}
|
|
25383
26181
|
exports.UpdateDhcpOptionsSetAttributeResponse = UpdateDhcpOptionsSetAttributeResponse;
|
|
26182
|
+
class UpdateFailoverTestJobRequest extends $tea.Model {
|
|
26183
|
+
constructor(map) {
|
|
26184
|
+
super(map);
|
|
26185
|
+
}
|
|
26186
|
+
static names() {
|
|
26187
|
+
return {
|
|
26188
|
+
clientToken: 'ClientToken',
|
|
26189
|
+
description: 'Description',
|
|
26190
|
+
jobDuration: 'JobDuration',
|
|
26191
|
+
jobId: 'JobId',
|
|
26192
|
+
name: 'Name',
|
|
26193
|
+
ownerAccount: 'OwnerAccount',
|
|
26194
|
+
ownerId: 'OwnerId',
|
|
26195
|
+
regionId: 'RegionId',
|
|
26196
|
+
resourceId: 'ResourceId',
|
|
26197
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
26198
|
+
};
|
|
26199
|
+
}
|
|
26200
|
+
static types() {
|
|
26201
|
+
return {
|
|
26202
|
+
clientToken: 'string',
|
|
26203
|
+
description: 'string',
|
|
26204
|
+
jobDuration: 'number',
|
|
26205
|
+
jobId: 'string',
|
|
26206
|
+
name: 'string',
|
|
26207
|
+
ownerAccount: 'string',
|
|
26208
|
+
ownerId: 'number',
|
|
26209
|
+
regionId: 'string',
|
|
26210
|
+
resourceId: { 'type': 'array', 'itemType': 'string' },
|
|
26211
|
+
resourceOwnerAccount: 'string',
|
|
26212
|
+
};
|
|
26213
|
+
}
|
|
26214
|
+
}
|
|
26215
|
+
exports.UpdateFailoverTestJobRequest = UpdateFailoverTestJobRequest;
|
|
26216
|
+
class UpdateFailoverTestJobResponseBody extends $tea.Model {
|
|
26217
|
+
constructor(map) {
|
|
26218
|
+
super(map);
|
|
26219
|
+
}
|
|
26220
|
+
static names() {
|
|
26221
|
+
return {
|
|
26222
|
+
requestId: 'RequestId',
|
|
26223
|
+
};
|
|
26224
|
+
}
|
|
26225
|
+
static types() {
|
|
26226
|
+
return {
|
|
26227
|
+
requestId: 'string',
|
|
26228
|
+
};
|
|
26229
|
+
}
|
|
26230
|
+
}
|
|
26231
|
+
exports.UpdateFailoverTestJobResponseBody = UpdateFailoverTestJobResponseBody;
|
|
26232
|
+
class UpdateFailoverTestJobResponse extends $tea.Model {
|
|
26233
|
+
constructor(map) {
|
|
26234
|
+
super(map);
|
|
26235
|
+
}
|
|
26236
|
+
static names() {
|
|
26237
|
+
return {
|
|
26238
|
+
headers: 'headers',
|
|
26239
|
+
statusCode: 'statusCode',
|
|
26240
|
+
body: 'body',
|
|
26241
|
+
};
|
|
26242
|
+
}
|
|
26243
|
+
static types() {
|
|
26244
|
+
return {
|
|
26245
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
26246
|
+
statusCode: 'number',
|
|
26247
|
+
body: UpdateFailoverTestJobResponseBody,
|
|
26248
|
+
};
|
|
26249
|
+
}
|
|
26250
|
+
}
|
|
26251
|
+
exports.UpdateFailoverTestJobResponse = UpdateFailoverTestJobResponse;
|
|
25384
26252
|
class UpdateGatewayRouteTableEntryAttributeRequest extends $tea.Model {
|
|
25385
26253
|
constructor(map) {
|
|
25386
26254
|
super(map);
|
|
@@ -25680,9 +26548,11 @@ class UpdateNetworkAclEntriesRequest extends $tea.Model {
|
|
|
25680
26548
|
static names() {
|
|
25681
26549
|
return {
|
|
25682
26550
|
clientToken: 'ClientToken',
|
|
26551
|
+
dryRun: 'DryRun',
|
|
25683
26552
|
egressAclEntries: 'EgressAclEntries',
|
|
25684
26553
|
ingressAclEntries: 'IngressAclEntries',
|
|
25685
26554
|
networkAclId: 'NetworkAclId',
|
|
26555
|
+
ownerAccount: 'OwnerAccount',
|
|
25686
26556
|
ownerId: 'OwnerId',
|
|
25687
26557
|
regionId: 'RegionId',
|
|
25688
26558
|
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
@@ -25694,9 +26564,11 @@ class UpdateNetworkAclEntriesRequest extends $tea.Model {
|
|
|
25694
26564
|
static types() {
|
|
25695
26565
|
return {
|
|
25696
26566
|
clientToken: 'string',
|
|
26567
|
+
dryRun: 'boolean',
|
|
25697
26568
|
egressAclEntries: { 'type': 'array', 'itemType': UpdateNetworkAclEntriesRequestEgressAclEntries },
|
|
25698
26569
|
ingressAclEntries: { 'type': 'array', 'itemType': UpdateNetworkAclEntriesRequestIngressAclEntries },
|
|
25699
26570
|
networkAclId: 'string',
|
|
26571
|
+
ownerAccount: 'string',
|
|
25700
26572
|
ownerId: 'number',
|
|
25701
26573
|
regionId: 'string',
|
|
25702
26574
|
resourceOwnerAccount: 'string',
|
|
@@ -27195,6 +28067,24 @@ class CreateVSwitchRequestTag extends $tea.Model {
|
|
|
27195
28067
|
}
|
|
27196
28068
|
}
|
|
27197
28069
|
exports.CreateVSwitchRequestTag = CreateVSwitchRequestTag;
|
|
28070
|
+
class CreateVSwitchCidrReservationRequestTag extends $tea.Model {
|
|
28071
|
+
constructor(map) {
|
|
28072
|
+
super(map);
|
|
28073
|
+
}
|
|
28074
|
+
static names() {
|
|
28075
|
+
return {
|
|
28076
|
+
key: 'Key',
|
|
28077
|
+
value: 'Value',
|
|
28078
|
+
};
|
|
28079
|
+
}
|
|
28080
|
+
static types() {
|
|
28081
|
+
return {
|
|
28082
|
+
key: 'string',
|
|
28083
|
+
value: 'string',
|
|
28084
|
+
};
|
|
28085
|
+
}
|
|
28086
|
+
}
|
|
28087
|
+
exports.CreateVSwitchCidrReservationRequestTag = CreateVSwitchCidrReservationRequestTag;
|
|
27198
28088
|
class CreateVirtualBorderRouterRequestTags extends $tea.Model {
|
|
27199
28089
|
constructor(map) {
|
|
27200
28090
|
super(map);
|
|
@@ -28467,6 +29357,92 @@ class DescribeEipSegmentResponseBodyEipSegments extends $tea.Model {
|
|
|
28467
29357
|
}
|
|
28468
29358
|
}
|
|
28469
29359
|
exports.DescribeEipSegmentResponseBodyEipSegments = DescribeEipSegmentResponseBodyEipSegments;
|
|
29360
|
+
class DescribeFailoverTestJobResponseBodyFailoverTestJobModel extends $tea.Model {
|
|
29361
|
+
constructor(map) {
|
|
29362
|
+
super(map);
|
|
29363
|
+
}
|
|
29364
|
+
static names() {
|
|
29365
|
+
return {
|
|
29366
|
+
description: 'Description',
|
|
29367
|
+
jobDuration: 'JobDuration',
|
|
29368
|
+
jobId: 'JobId',
|
|
29369
|
+
jobType: 'JobType',
|
|
29370
|
+
name: 'Name',
|
|
29371
|
+
resourceId: 'ResourceId',
|
|
29372
|
+
resourceType: 'ResourceType',
|
|
29373
|
+
startTime: 'StartTime',
|
|
29374
|
+
status: 'Status',
|
|
29375
|
+
stopTime: 'StopTime',
|
|
29376
|
+
};
|
|
29377
|
+
}
|
|
29378
|
+
static types() {
|
|
29379
|
+
return {
|
|
29380
|
+
description: 'string',
|
|
29381
|
+
jobDuration: 'string',
|
|
29382
|
+
jobId: 'string',
|
|
29383
|
+
jobType: 'string',
|
|
29384
|
+
name: 'string',
|
|
29385
|
+
resourceId: { 'type': 'array', 'itemType': 'string' },
|
|
29386
|
+
resourceType: 'string',
|
|
29387
|
+
startTime: 'string',
|
|
29388
|
+
status: 'string',
|
|
29389
|
+
stopTime: 'string',
|
|
29390
|
+
};
|
|
29391
|
+
}
|
|
29392
|
+
}
|
|
29393
|
+
exports.DescribeFailoverTestJobResponseBodyFailoverTestJobModel = DescribeFailoverTestJobResponseBodyFailoverTestJobModel;
|
|
29394
|
+
class DescribeFailoverTestJobsRequestFilter extends $tea.Model {
|
|
29395
|
+
constructor(map) {
|
|
29396
|
+
super(map);
|
|
29397
|
+
}
|
|
29398
|
+
static names() {
|
|
29399
|
+
return {
|
|
29400
|
+
key: 'Key',
|
|
29401
|
+
value: 'Value',
|
|
29402
|
+
};
|
|
29403
|
+
}
|
|
29404
|
+
static types() {
|
|
29405
|
+
return {
|
|
29406
|
+
key: 'string',
|
|
29407
|
+
value: { 'type': 'array', 'itemType': 'string' },
|
|
29408
|
+
};
|
|
29409
|
+
}
|
|
29410
|
+
}
|
|
29411
|
+
exports.DescribeFailoverTestJobsRequestFilter = DescribeFailoverTestJobsRequestFilter;
|
|
29412
|
+
class DescribeFailoverTestJobsResponseBodyFailoverTestJobList extends $tea.Model {
|
|
29413
|
+
constructor(map) {
|
|
29414
|
+
super(map);
|
|
29415
|
+
}
|
|
29416
|
+
static names() {
|
|
29417
|
+
return {
|
|
29418
|
+
description: 'Description',
|
|
29419
|
+
jobDuration: 'JobDuration',
|
|
29420
|
+
jobId: 'JobId',
|
|
29421
|
+
jobType: 'JobType',
|
|
29422
|
+
name: 'Name',
|
|
29423
|
+
resourceId: 'ResourceId',
|
|
29424
|
+
resourceType: 'ResourceType',
|
|
29425
|
+
startTime: 'StartTime',
|
|
29426
|
+
status: 'Status',
|
|
29427
|
+
stopTime: 'StopTime',
|
|
29428
|
+
};
|
|
29429
|
+
}
|
|
29430
|
+
static types() {
|
|
29431
|
+
return {
|
|
29432
|
+
description: 'string',
|
|
29433
|
+
jobDuration: 'string',
|
|
29434
|
+
jobId: 'string',
|
|
29435
|
+
jobType: 'string',
|
|
29436
|
+
name: 'string',
|
|
29437
|
+
resourceId: { 'type': 'array', 'itemType': 'string' },
|
|
29438
|
+
resourceType: 'string',
|
|
29439
|
+
startTime: 'string',
|
|
29440
|
+
status: 'string',
|
|
29441
|
+
stopTime: 'string',
|
|
29442
|
+
};
|
|
29443
|
+
}
|
|
29444
|
+
}
|
|
29445
|
+
exports.DescribeFailoverTestJobsResponseBodyFailoverTestJobList = DescribeFailoverTestJobsResponseBodyFailoverTestJobList;
|
|
28470
29446
|
class DescribeFlowLogsRequestTags extends $tea.Model {
|
|
28471
29447
|
constructor(map) {
|
|
28472
29448
|
super(map);
|
|
@@ -29791,6 +30767,8 @@ class DescribeNetworkAclAttributesResponseBodyNetworkAclAttributeEgressAclEntrie
|
|
|
29791
30767
|
return {
|
|
29792
30768
|
description: 'Description',
|
|
29793
30769
|
destinationCidrIp: 'DestinationCidrIp',
|
|
30770
|
+
entryType: 'EntryType',
|
|
30771
|
+
ipVersion: 'IpVersion',
|
|
29794
30772
|
networkAclEntryId: 'NetworkAclEntryId',
|
|
29795
30773
|
networkAclEntryName: 'NetworkAclEntryName',
|
|
29796
30774
|
policy: 'Policy',
|
|
@@ -29802,6 +30780,8 @@ class DescribeNetworkAclAttributesResponseBodyNetworkAclAttributeEgressAclEntrie
|
|
|
29802
30780
|
return {
|
|
29803
30781
|
description: 'string',
|
|
29804
30782
|
destinationCidrIp: 'string',
|
|
30783
|
+
entryType: 'string',
|
|
30784
|
+
ipVersion: 'string',
|
|
29805
30785
|
networkAclEntryId: 'string',
|
|
29806
30786
|
networkAclEntryName: 'string',
|
|
29807
30787
|
policy: 'string',
|
|
@@ -29834,6 +30814,8 @@ class DescribeNetworkAclAttributesResponseBodyNetworkAclAttributeIngressAclEntri
|
|
|
29834
30814
|
static names() {
|
|
29835
30815
|
return {
|
|
29836
30816
|
description: 'Description',
|
|
30817
|
+
entryType: 'EntryType',
|
|
30818
|
+
ipVersion: 'IpVersion',
|
|
29837
30819
|
networkAclEntryId: 'NetworkAclEntryId',
|
|
29838
30820
|
networkAclEntryName: 'NetworkAclEntryName',
|
|
29839
30821
|
policy: 'Policy',
|
|
@@ -29845,6 +30827,8 @@ class DescribeNetworkAclAttributesResponseBodyNetworkAclAttributeIngressAclEntri
|
|
|
29845
30827
|
static types() {
|
|
29846
30828
|
return {
|
|
29847
30829
|
description: 'string',
|
|
30830
|
+
entryType: 'string',
|
|
30831
|
+
ipVersion: 'string',
|
|
29848
30832
|
networkAclEntryId: 'string',
|
|
29849
30833
|
networkAclEntryName: 'string',
|
|
29850
30834
|
policy: 'string',
|
|
@@ -30005,6 +30989,8 @@ class DescribeNetworkAclsResponseBodyNetworkAclsNetworkAclEgressAclEntriesEgress
|
|
|
30005
30989
|
return {
|
|
30006
30990
|
description: 'Description',
|
|
30007
30991
|
destinationCidrIp: 'DestinationCidrIp',
|
|
30992
|
+
entryType: 'EntryType',
|
|
30993
|
+
ipVersion: 'IpVersion',
|
|
30008
30994
|
networkAclEntryId: 'NetworkAclEntryId',
|
|
30009
30995
|
networkAclEntryName: 'NetworkAclEntryName',
|
|
30010
30996
|
policy: 'Policy',
|
|
@@ -30016,6 +31002,8 @@ class DescribeNetworkAclsResponseBodyNetworkAclsNetworkAclEgressAclEntriesEgress
|
|
|
30016
31002
|
return {
|
|
30017
31003
|
description: 'string',
|
|
30018
31004
|
destinationCidrIp: 'string',
|
|
31005
|
+
entryType: 'string',
|
|
31006
|
+
ipVersion: 'string',
|
|
30019
31007
|
networkAclEntryId: 'string',
|
|
30020
31008
|
networkAclEntryName: 'string',
|
|
30021
31009
|
policy: 'string',
|
|
@@ -30048,6 +31036,8 @@ class DescribeNetworkAclsResponseBodyNetworkAclsNetworkAclIngressAclEntriesIngre
|
|
|
30048
31036
|
static names() {
|
|
30049
31037
|
return {
|
|
30050
31038
|
description: 'Description',
|
|
31039
|
+
entryType: 'EntryType',
|
|
31040
|
+
ipVersion: 'IpVersion',
|
|
30051
31041
|
networkAclEntryId: 'NetworkAclEntryId',
|
|
30052
31042
|
networkAclEntryName: 'NetworkAclEntryName',
|
|
30053
31043
|
policy: 'Policy',
|
|
@@ -30059,6 +31049,8 @@ class DescribeNetworkAclsResponseBodyNetworkAclsNetworkAclIngressAclEntriesIngre
|
|
|
30059
31049
|
static types() {
|
|
30060
31050
|
return {
|
|
30061
31051
|
description: 'string',
|
|
31052
|
+
entryType: 'string',
|
|
31053
|
+
ipVersion: 'string',
|
|
30062
31054
|
networkAclEntryId: 'string',
|
|
30063
31055
|
networkAclEntryName: 'string',
|
|
30064
31056
|
policy: 'string',
|
|
@@ -34043,6 +35035,32 @@ class GetNatGatewayAttributeResponseBodySnatTable extends $tea.Model {
|
|
|
34043
35035
|
}
|
|
34044
35036
|
}
|
|
34045
35037
|
exports.GetNatGatewayAttributeResponseBodySnatTable = GetNatGatewayAttributeResponseBodySnatTable;
|
|
35038
|
+
class GetVSwitchCidrReservationUsageResponseBodyCidrReservationUsages extends $tea.Model {
|
|
35039
|
+
constructor(map) {
|
|
35040
|
+
super(map);
|
|
35041
|
+
}
|
|
35042
|
+
static names() {
|
|
35043
|
+
return {
|
|
35044
|
+
ipPrefixCidr: 'IpPrefixCidr',
|
|
35045
|
+
ipPrefixId: 'IpPrefixId',
|
|
35046
|
+
resourceId: 'ResourceId',
|
|
35047
|
+
resourceType: 'ResourceType',
|
|
35048
|
+
vSwitchCidrReservationId: 'VSwitchCidrReservationId',
|
|
35049
|
+
vSwitchId: 'VSwitchId',
|
|
35050
|
+
};
|
|
35051
|
+
}
|
|
35052
|
+
static types() {
|
|
35053
|
+
return {
|
|
35054
|
+
ipPrefixCidr: 'string',
|
|
35055
|
+
ipPrefixId: 'string',
|
|
35056
|
+
resourceId: 'string',
|
|
35057
|
+
resourceType: 'string',
|
|
35058
|
+
vSwitchCidrReservationId: 'string',
|
|
35059
|
+
vSwitchId: 'string',
|
|
35060
|
+
};
|
|
35061
|
+
}
|
|
35062
|
+
}
|
|
35063
|
+
exports.GetVSwitchCidrReservationUsageResponseBodyCidrReservationUsages = GetVSwitchCidrReservationUsageResponseBodyCidrReservationUsages;
|
|
34046
35064
|
class GetVpcGatewayEndpointAttributeResponseBodyTags extends $tea.Model {
|
|
34047
35065
|
constructor(map) {
|
|
34048
35066
|
super(map);
|
|
@@ -35145,6 +36163,82 @@ class ListTrafficMirrorSessionsResponseBodyTrafficMirrorSessions extends $tea.Mo
|
|
|
35145
36163
|
}
|
|
35146
36164
|
}
|
|
35147
36165
|
exports.ListTrafficMirrorSessionsResponseBodyTrafficMirrorSessions = ListTrafficMirrorSessionsResponseBodyTrafficMirrorSessions;
|
|
36166
|
+
class ListVSwitchCidrReservationsRequestTags extends $tea.Model {
|
|
36167
|
+
constructor(map) {
|
|
36168
|
+
super(map);
|
|
36169
|
+
}
|
|
36170
|
+
static names() {
|
|
36171
|
+
return {
|
|
36172
|
+
key: 'Key',
|
|
36173
|
+
value: 'Value',
|
|
36174
|
+
};
|
|
36175
|
+
}
|
|
36176
|
+
static types() {
|
|
36177
|
+
return {
|
|
36178
|
+
key: 'string',
|
|
36179
|
+
value: 'string',
|
|
36180
|
+
};
|
|
36181
|
+
}
|
|
36182
|
+
}
|
|
36183
|
+
exports.ListVSwitchCidrReservationsRequestTags = ListVSwitchCidrReservationsRequestTags;
|
|
36184
|
+
class ListVSwitchCidrReservationsResponseBodyVSwitchCidrReservationsTags extends $tea.Model {
|
|
36185
|
+
constructor(map) {
|
|
36186
|
+
super(map);
|
|
36187
|
+
}
|
|
36188
|
+
static names() {
|
|
36189
|
+
return {
|
|
36190
|
+
key: 'Key',
|
|
36191
|
+
value: 'Value',
|
|
36192
|
+
};
|
|
36193
|
+
}
|
|
36194
|
+
static types() {
|
|
36195
|
+
return {
|
|
36196
|
+
key: 'string',
|
|
36197
|
+
value: 'string',
|
|
36198
|
+
};
|
|
36199
|
+
}
|
|
36200
|
+
}
|
|
36201
|
+
exports.ListVSwitchCidrReservationsResponseBodyVSwitchCidrReservationsTags = ListVSwitchCidrReservationsResponseBodyVSwitchCidrReservationsTags;
|
|
36202
|
+
class ListVSwitchCidrReservationsResponseBodyVSwitchCidrReservations extends $tea.Model {
|
|
36203
|
+
constructor(map) {
|
|
36204
|
+
super(map);
|
|
36205
|
+
}
|
|
36206
|
+
static names() {
|
|
36207
|
+
return {
|
|
36208
|
+
assignedCidrCount: 'AssignedCidrCount',
|
|
36209
|
+
availableCidrCount: 'AvailableCidrCount',
|
|
36210
|
+
creationTime: 'CreationTime',
|
|
36211
|
+
ipVersion: 'IpVersion',
|
|
36212
|
+
status: 'Status',
|
|
36213
|
+
tags: 'Tags',
|
|
36214
|
+
type: 'Type',
|
|
36215
|
+
vSwitchCidrReservationCidr: 'VSwitchCidrReservationCidr',
|
|
36216
|
+
vSwitchCidrReservationDescription: 'VSwitchCidrReservationDescription',
|
|
36217
|
+
vSwitchCidrReservationId: 'VSwitchCidrReservationId',
|
|
36218
|
+
vSwitchCidrReservationName: 'VSwitchCidrReservationName',
|
|
36219
|
+
vSwitchId: 'VSwitchId',
|
|
36220
|
+
vpcId: 'VpcId',
|
|
36221
|
+
};
|
|
36222
|
+
}
|
|
36223
|
+
static types() {
|
|
36224
|
+
return {
|
|
36225
|
+
assignedCidrCount: 'number',
|
|
36226
|
+
availableCidrCount: 'number',
|
|
36227
|
+
creationTime: 'string',
|
|
36228
|
+
ipVersion: 'string',
|
|
36229
|
+
status: 'string',
|
|
36230
|
+
tags: { 'type': 'array', 'itemType': ListVSwitchCidrReservationsResponseBodyVSwitchCidrReservationsTags },
|
|
36231
|
+
type: 'string',
|
|
36232
|
+
vSwitchCidrReservationCidr: 'string',
|
|
36233
|
+
vSwitchCidrReservationDescription: 'string',
|
|
36234
|
+
vSwitchCidrReservationId: 'string',
|
|
36235
|
+
vSwitchCidrReservationName: 'string',
|
|
36236
|
+
vSwitchId: 'string',
|
|
36237
|
+
vpcId: 'string',
|
|
36238
|
+
};
|
|
36239
|
+
}
|
|
36240
|
+
}
|
|
36241
|
+
exports.ListVSwitchCidrReservationsResponseBodyVSwitchCidrReservations = ListVSwitchCidrReservationsResponseBodyVSwitchCidrReservations;
|
|
35148
36242
|
class ListVirtualPhysicalConnectionsRequestTags extends $tea.Model {
|
|
35149
36243
|
constructor(map) {
|
|
35150
36244
|
super(map);
|
|
@@ -36130,6 +37224,7 @@ class UpdateNetworkAclEntriesRequestEgressAclEntries extends $tea.Model {
|
|
|
36130
37224
|
description: 'Description',
|
|
36131
37225
|
destinationCidrIp: 'DestinationCidrIp',
|
|
36132
37226
|
entryType: 'EntryType',
|
|
37227
|
+
ipVersion: 'IpVersion',
|
|
36133
37228
|
networkAclEntryId: 'NetworkAclEntryId',
|
|
36134
37229
|
networkAclEntryName: 'NetworkAclEntryName',
|
|
36135
37230
|
policy: 'Policy',
|
|
@@ -36142,6 +37237,7 @@ class UpdateNetworkAclEntriesRequestEgressAclEntries extends $tea.Model {
|
|
|
36142
37237
|
description: 'string',
|
|
36143
37238
|
destinationCidrIp: 'string',
|
|
36144
37239
|
entryType: 'string',
|
|
37240
|
+
ipVersion: 'string',
|
|
36145
37241
|
networkAclEntryId: 'string',
|
|
36146
37242
|
networkAclEntryName: 'string',
|
|
36147
37243
|
policy: 'string',
|
|
@@ -36159,6 +37255,7 @@ class UpdateNetworkAclEntriesRequestIngressAclEntries extends $tea.Model {
|
|
|
36159
37255
|
return {
|
|
36160
37256
|
description: 'Description',
|
|
36161
37257
|
entryType: 'EntryType',
|
|
37258
|
+
ipVersion: 'IpVersion',
|
|
36162
37259
|
networkAclEntryId: 'NetworkAclEntryId',
|
|
36163
37260
|
networkAclEntryName: 'NetworkAclEntryName',
|
|
36164
37261
|
policy: 'Policy',
|
|
@@ -36171,6 +37268,7 @@ class UpdateNetworkAclEntriesRequestIngressAclEntries extends $tea.Model {
|
|
|
36171
37268
|
return {
|
|
36172
37269
|
description: 'string',
|
|
36173
37270
|
entryType: 'string',
|
|
37271
|
+
ipVersion: 'string',
|
|
36174
37272
|
networkAclEntryId: 'string',
|
|
36175
37273
|
networkAclEntryName: 'string',
|
|
36176
37274
|
policy: 'string',
|
|
@@ -36244,7 +37342,7 @@ class Client extends openapi_client_1.default {
|
|
|
36244
37342
|
return endpoint_util_1.default.getEndpointRules(productId, regionId, endpointRule, network, suffix);
|
|
36245
37343
|
}
|
|
36246
37344
|
/**
|
|
36247
|
-
*
|
|
37345
|
+
* After you call this operation, the router interface enters the **Activating** state. After the router interface is activated, it enters the **Active** state.
|
|
36248
37346
|
* > You cannot activate a router interface that has overdue payments.
|
|
36249
37347
|
*
|
|
36250
37348
|
* @param request ActivateRouterInterfaceRequest
|
|
@@ -36286,7 +37384,7 @@ class Client extends openapi_client_1.default {
|
|
|
36286
37384
|
return $tea.cast(await this.callApi(params, req, runtime), new ActivateRouterInterfaceResponse({}));
|
|
36287
37385
|
}
|
|
36288
37386
|
/**
|
|
36289
|
-
*
|
|
37387
|
+
* After you call this operation, the router interface enters the **Activating** state. After the router interface is activated, it enters the **Active** state.
|
|
36290
37388
|
* > You cannot activate a router interface that has overdue payments.
|
|
36291
37389
|
*
|
|
36292
37390
|
* @param request ActivateRouterInterfaceRequest
|
|
@@ -37147,9 +38245,10 @@ class Client extends openapi_client_1.default {
|
|
|
37147
38245
|
return await this.allocateIpv6InternetBandwidthWithOptions(request, runtime);
|
|
37148
38246
|
}
|
|
37149
38247
|
/**
|
|
38248
|
+
* # [](#)
|
|
37150
38249
|
* The following section describes how to allocate an IPv6 CIDR block to a virtual private cloud (VPC):
|
|
37151
|
-
* 1
|
|
37152
|
-
* 2
|
|
38250
|
+
* 1. Call the AllocateVpcIpv6Cidr operation to reserve the IPv6 CIDR block.
|
|
38251
|
+
* 2. To allocate an IPv6 CIDR block to an existing VPC, call the [AssociateVpcCidrBlock](~~146745~~) operation. Set **RegionId**, **VpcId**, and **IPv6CidrBlock** to the IPv6 CIDR bock, and set **IpVersion** to **ipv6**. To allocate an IPv6 CIDR block when you create a VPC, call the [CreateVpc](~~35737~~) operation. Set **RegionId** and **Ipv6CidrBlock** to the IPv6 CIDR block, and set **EnableIpv6** to **true**.
|
|
37153
38252
|
*
|
|
37154
38253
|
* @param request AllocateVpcIpv6CidrRequest
|
|
37155
38254
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -37205,9 +38304,10 @@ class Client extends openapi_client_1.default {
|
|
|
37205
38304
|
return $tea.cast(await this.callApi(params, req, runtime), new AllocateVpcIpv6CidrResponse({}));
|
|
37206
38305
|
}
|
|
37207
38306
|
/**
|
|
38307
|
+
* # [](#)
|
|
37208
38308
|
* The following section describes how to allocate an IPv6 CIDR block to a virtual private cloud (VPC):
|
|
37209
|
-
* 1
|
|
37210
|
-
* 2
|
|
38309
|
+
* 1. Call the AllocateVpcIpv6Cidr operation to reserve the IPv6 CIDR block.
|
|
38310
|
+
* 2. To allocate an IPv6 CIDR block to an existing VPC, call the [AssociateVpcCidrBlock](~~146745~~) operation. Set **RegionId**, **VpcId**, and **IPv6CidrBlock** to the IPv6 CIDR bock, and set **IpVersion** to **ipv6**. To allocate an IPv6 CIDR block when you create a VPC, call the [CreateVpc](~~35737~~) operation. Set **RegionId** and **Ipv6CidrBlock** to the IPv6 CIDR block, and set **EnableIpv6** to **true**.
|
|
37211
38311
|
*
|
|
37212
38312
|
* @param request AllocateVpcIpv6CidrRequest
|
|
37213
38313
|
* @return AllocateVpcIpv6CidrResponse
|
|
@@ -37523,7 +38623,8 @@ class Client extends openapi_client_1.default {
|
|
|
37523
38623
|
return await this.associateHaVipWithOptions(request, runtime);
|
|
37524
38624
|
}
|
|
37525
38625
|
/**
|
|
37526
|
-
*
|
|
38626
|
+
* ## [](#)Description
|
|
38627
|
+
* * **AssociateNetworkAcl** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeNetworkAclAttributes](~~116542~~) operation to query the status of the task.
|
|
37527
38628
|
* * If the network ACL is in the **BINDING** state, the network ACL is being associated.
|
|
37528
38629
|
* * If the network ACL is in the **BINDED** state, the network ACL is associated.
|
|
37529
38630
|
* * You cannot repeatedly call the **AssociateNetworkAcl** operation to associate a network ACL within the specified period of time.
|
|
@@ -37538,9 +38639,15 @@ class Client extends openapi_client_1.default {
|
|
|
37538
38639
|
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
37539
38640
|
query["ClientToken"] = request.clientToken;
|
|
37540
38641
|
}
|
|
38642
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
38643
|
+
query["DryRun"] = request.dryRun;
|
|
38644
|
+
}
|
|
37541
38645
|
if (!tea_util_1.default.isUnset(request.networkAclId)) {
|
|
37542
38646
|
query["NetworkAclId"] = request.networkAclId;
|
|
37543
38647
|
}
|
|
38648
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
38649
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
38650
|
+
}
|
|
37544
38651
|
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
37545
38652
|
query["OwnerId"] = request.ownerId;
|
|
37546
38653
|
}
|
|
@@ -37576,7 +38683,8 @@ class Client extends openapi_client_1.default {
|
|
|
37576
38683
|
return $tea.cast(await this.callApi(params, req, runtime), new AssociateNetworkAclResponse({}));
|
|
37577
38684
|
}
|
|
37578
38685
|
/**
|
|
37579
|
-
*
|
|
38686
|
+
* ## [](#)Description
|
|
38687
|
+
* * **AssociateNetworkAcl** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeNetworkAclAttributes](~~116542~~) operation to query the status of the task.
|
|
37580
38688
|
* * If the network ACL is in the **BINDING** state, the network ACL is being associated.
|
|
37581
38689
|
* * If the network ACL is in the **BINDED** state, the network ACL is associated.
|
|
37582
38690
|
* * You cannot repeatedly call the **AssociateNetworkAcl** operation to associate a network ACL within the specified period of time.
|
|
@@ -37957,7 +39065,7 @@ class Client extends openapi_client_1.default {
|
|
|
37957
39065
|
* * If the VPN gateway is in the **updating** state, the SSL certificate is being associated.
|
|
37958
39066
|
* * If the VPN gateway is in the **active** state, the SSL certificate is being associated.
|
|
37959
39067
|
* * You cannot call **AssociateVpnGatewayWithCertificate** within a specific period of time.
|
|
37960
|
-
*
|
|
39068
|
+
* ### [](#)Prerequisites
|
|
37961
39069
|
* Make sure that you have two SSL certificates that use the SM algorithm in the Certificate Management Service console. For more information about SSL certificates, see [What is Certificate Management Service?](~~28535~~).
|
|
37962
39070
|
*
|
|
37963
39071
|
* @param request AssociateVpnGatewayWithCertificateRequest
|
|
@@ -38010,7 +39118,7 @@ class Client extends openapi_client_1.default {
|
|
|
38010
39118
|
* * If the VPN gateway is in the **updating** state, the SSL certificate is being associated.
|
|
38011
39119
|
* * If the VPN gateway is in the **active** state, the SSL certificate is being associated.
|
|
38012
39120
|
* * You cannot call **AssociateVpnGatewayWithCertificate** within a specific period of time.
|
|
38013
|
-
*
|
|
39121
|
+
* ### [](#)Prerequisites
|
|
38014
39122
|
* Make sure that you have two SSL certificates that use the SM algorithm in the Certificate Management Service console. For more information about SSL certificates, see [What is Certificate Management Service?](~~28535~~).
|
|
38015
39123
|
*
|
|
38016
39124
|
* @param request AssociateVpnGatewayWithCertificateRequest
|
|
@@ -38189,7 +39297,6 @@ class Client extends openapi_client_1.default {
|
|
|
38189
39297
|
return await this.cancelCommonBandwidthPackageIpBandwidthWithOptions(request, runtime);
|
|
38190
39298
|
}
|
|
38191
39299
|
/**
|
|
38192
|
-
* ## Limits
|
|
38193
39300
|
* You can cancel only an Express Connect circuit that is in the **Initial**, **Approved**, **Allocated**, or **Confirmed** state.
|
|
38194
39301
|
*
|
|
38195
39302
|
* @param request CancelPhysicalConnectionRequest
|
|
@@ -38237,7 +39344,6 @@ class Client extends openapi_client_1.default {
|
|
|
38237
39344
|
return $tea.cast(await this.callApi(params, req, runtime), new CancelPhysicalConnectionResponse({}));
|
|
38238
39345
|
}
|
|
38239
39346
|
/**
|
|
38240
|
-
* ## Limits
|
|
38241
39347
|
* You can cancel only an Express Connect circuit that is in the **Initial**, **Approved**, **Allocated**, or **Confirmed** state.
|
|
38242
39348
|
*
|
|
38243
39349
|
* @param request CancelPhysicalConnectionRequest
|
|
@@ -38248,7 +39354,8 @@ class Client extends openapi_client_1.default {
|
|
|
38248
39354
|
return await this.cancelPhysicalConnectionWithOptions(request, runtime);
|
|
38249
39355
|
}
|
|
38250
39356
|
/**
|
|
38251
|
-
*
|
|
39357
|
+
* ## [](#)
|
|
39358
|
+
* You cannot repeatedly call the **ChangeResourceGroup** operation to modify the resource group of the same Express Connect circuit.
|
|
38252
39359
|
*
|
|
38253
39360
|
* @param request ChangeResourceGroupRequest
|
|
38254
39361
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -38286,7 +39393,8 @@ class Client extends openapi_client_1.default {
|
|
|
38286
39393
|
return $tea.cast(await this.callApi(params, req, runtime), new ChangeResourceGroupResponse({}));
|
|
38287
39394
|
}
|
|
38288
39395
|
/**
|
|
38289
|
-
*
|
|
39396
|
+
* ## [](#)
|
|
39397
|
+
* You cannot repeatedly call the **ChangeResourceGroup** operation to modify the resource group of the same Express Connect circuit.
|
|
38290
39398
|
*
|
|
38291
39399
|
* @param request ChangeResourceGroupRequest
|
|
38292
39400
|
* @return ChangeResourceGroupResponse
|
|
@@ -38546,10 +39654,10 @@ class Client extends openapi_client_1.default {
|
|
|
38546
39654
|
return await this.connectRouterInterfaceWithOptions(request, runtime);
|
|
38547
39655
|
}
|
|
38548
39656
|
/**
|
|
38549
|
-
* Before you convert a NAT
|
|
38550
|
-
* *
|
|
38551
|
-
* *
|
|
38552
|
-
* * After the
|
|
39657
|
+
* Before you convert a NAT service plan to an Internet Shared Bandwidth instance, take note of the following limits:
|
|
39658
|
+
* * You are not charged for the conversion.
|
|
39659
|
+
* * When you convert a NAT service plan to an Internet Shared Bandwidth instance, you can continue to use the SNAT and DNAT features of the NAT gateway, and your workloads are not affected. However, we recommend that you convert your NAT service plan during off-peak hours.
|
|
39660
|
+
* * After the NAT service plan is converted to an Internet Shared Bandwidth instance, the public IP addresses in the NAT service plan are converted to elastic IP addresses (EIPs). The maximum bandwidth and billing method of the Internet Shared Bandwidth instance are the same as those of the NAT service plan.
|
|
38553
39661
|
*
|
|
38554
39662
|
* @param request ConvertBandwidthPackageRequest
|
|
38555
39663
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -38596,10 +39704,10 @@ class Client extends openapi_client_1.default {
|
|
|
38596
39704
|
return $tea.cast(await this.callApi(params, req, runtime), new ConvertBandwidthPackageResponse({}));
|
|
38597
39705
|
}
|
|
38598
39706
|
/**
|
|
38599
|
-
* Before you convert a NAT
|
|
38600
|
-
* *
|
|
38601
|
-
* *
|
|
38602
|
-
* * After the
|
|
39707
|
+
* Before you convert a NAT service plan to an Internet Shared Bandwidth instance, take note of the following limits:
|
|
39708
|
+
* * You are not charged for the conversion.
|
|
39709
|
+
* * When you convert a NAT service plan to an Internet Shared Bandwidth instance, you can continue to use the SNAT and DNAT features of the NAT gateway, and your workloads are not affected. However, we recommend that you convert your NAT service plan during off-peak hours.
|
|
39710
|
+
* * After the NAT service plan is converted to an Internet Shared Bandwidth instance, the public IP addresses in the NAT service plan are converted to elastic IP addresses (EIPs). The maximum bandwidth and billing method of the Internet Shared Bandwidth instance are the same as those of the NAT service plan.
|
|
38603
39711
|
*
|
|
38604
39712
|
* @param request ConvertBandwidthPackageRequest
|
|
38605
39713
|
* @return ConvertBandwidthPackageResponse
|
|
@@ -38624,9 +39732,15 @@ class Client extends openapi_client_1.default {
|
|
|
38624
39732
|
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
38625
39733
|
query["ClientToken"] = request.clientToken;
|
|
38626
39734
|
}
|
|
39735
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
39736
|
+
query["DryRun"] = request.dryRun;
|
|
39737
|
+
}
|
|
38627
39738
|
if (!tea_util_1.default.isUnset(request.networkAclId)) {
|
|
38628
39739
|
query["NetworkAclId"] = request.networkAclId;
|
|
38629
39740
|
}
|
|
39741
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
39742
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
39743
|
+
}
|
|
38630
39744
|
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
38631
39745
|
query["OwnerId"] = request.ownerId;
|
|
38632
39746
|
}
|
|
@@ -38675,7 +39789,7 @@ class Client extends openapi_client_1.default {
|
|
|
38675
39789
|
return await this.copyNetworkAclEntriesWithOptions(request, runtime);
|
|
38676
39790
|
}
|
|
38677
39791
|
/**
|
|
38678
|
-
* You can
|
|
39792
|
+
* You can connect a VBR to a data center through BGP. Each BGP group is associated with a VBR. You can add a BGP peer that needs to communicate with a VBR to a BGP group and advertise the BGP network in the VBR.
|
|
38679
39793
|
* BGP groups are used to simplify BGP configurations. You can add BGP peers that use the same configurations to one BGP group. Before you start, you must create a BGP group with the requested autonomous system number (ASN).
|
|
38680
39794
|
* When you call this operation, take note of the following limits:
|
|
38681
39795
|
* * You can specify only the data center that is connected to the VBR through an Express Connect circuit as a BGP peer.
|
|
@@ -38753,7 +39867,7 @@ class Client extends openapi_client_1.default {
|
|
|
38753
39867
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateBgpGroupResponse({}));
|
|
38754
39868
|
}
|
|
38755
39869
|
/**
|
|
38756
|
-
* You can
|
|
39870
|
+
* You can connect a VBR to a data center through BGP. Each BGP group is associated with a VBR. You can add a BGP peer that needs to communicate with a VBR to a BGP group and advertise the BGP network in the VBR.
|
|
38757
39871
|
* BGP groups are used to simplify BGP configurations. You can add BGP peers that use the same configurations to one BGP group. Before you start, you must create a BGP group with the requested autonomous system number (ASN).
|
|
38758
39872
|
* When you call this operation, take note of the following limits:
|
|
38759
39873
|
* * You can specify only the data center that is connected to the VBR through an Express Connect circuit as a BGP peer.
|
|
@@ -39274,6 +40388,65 @@ class Client extends openapi_client_1.default {
|
|
|
39274
40388
|
let runtime = new $Util.RuntimeOptions({});
|
|
39275
40389
|
return await this.createExpressCloudConnectionWithOptions(request, runtime);
|
|
39276
40390
|
}
|
|
40391
|
+
async createFailoverTestJobWithOptions(request, runtime) {
|
|
40392
|
+
tea_util_1.default.validateModel(request);
|
|
40393
|
+
let query = {};
|
|
40394
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
40395
|
+
query["ClientToken"] = request.clientToken;
|
|
40396
|
+
}
|
|
40397
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
40398
|
+
query["ClientToken"] = request.clientToken;
|
|
40399
|
+
}
|
|
40400
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
40401
|
+
query["Description"] = request.description;
|
|
40402
|
+
}
|
|
40403
|
+
if (!tea_util_1.default.isUnset(request.jobDuration)) {
|
|
40404
|
+
query["JobDuration"] = request.jobDuration;
|
|
40405
|
+
}
|
|
40406
|
+
if (!tea_util_1.default.isUnset(request.jobType)) {
|
|
40407
|
+
query["JobType"] = request.jobType;
|
|
40408
|
+
}
|
|
40409
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
40410
|
+
query["Name"] = request.name;
|
|
40411
|
+
}
|
|
40412
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
40413
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
40414
|
+
}
|
|
40415
|
+
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
40416
|
+
query["OwnerId"] = request.ownerId;
|
|
40417
|
+
}
|
|
40418
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
40419
|
+
query["RegionId"] = request.regionId;
|
|
40420
|
+
}
|
|
40421
|
+
if (!tea_util_1.default.isUnset(request.resourceId)) {
|
|
40422
|
+
query["ResourceId"] = request.resourceId;
|
|
40423
|
+
}
|
|
40424
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
40425
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
40426
|
+
}
|
|
40427
|
+
if (!tea_util_1.default.isUnset(request.resourceType)) {
|
|
40428
|
+
query["ResourceType"] = request.resourceType;
|
|
40429
|
+
}
|
|
40430
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
40431
|
+
query: openapi_util_1.default.query(query),
|
|
40432
|
+
});
|
|
40433
|
+
let params = new $OpenApi.Params({
|
|
40434
|
+
action: "CreateFailoverTestJob",
|
|
40435
|
+
version: "2016-04-28",
|
|
40436
|
+
protocol: "HTTPS",
|
|
40437
|
+
pathname: "/",
|
|
40438
|
+
method: "POST",
|
|
40439
|
+
authType: "AK",
|
|
40440
|
+
style: "RPC",
|
|
40441
|
+
reqBodyType: "formData",
|
|
40442
|
+
bodyType: "json",
|
|
40443
|
+
});
|
|
40444
|
+
return $tea.cast(await this.callApi(params, req, runtime), new CreateFailoverTestJobResponse({}));
|
|
40445
|
+
}
|
|
40446
|
+
async createFailoverTestJob(request) {
|
|
40447
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
40448
|
+
return await this.createFailoverTestJobWithOptions(request, runtime);
|
|
40449
|
+
}
|
|
39277
40450
|
/**
|
|
39278
40451
|
* **CreateFlowLog** is an asynchronous operation. After you send a request, the system returns a request ID and runs the task in the background. You can call the [DescribeFlowLogs](~~87923~~) operation to query the status of a flow log:
|
|
39279
40452
|
* * If the flow log is in the **Activating** state, the flow log is being created.
|
|
@@ -39363,12 +40536,13 @@ class Client extends openapi_client_1.default {
|
|
|
39363
40536
|
return await this.createFlowLogWithOptions(request, runtime);
|
|
39364
40537
|
}
|
|
39365
40538
|
/**
|
|
39366
|
-
*
|
|
40539
|
+
* ## [](#)
|
|
40540
|
+
* Each DNAT entry consists of the following parameters: **ExternalIp**, **ExternalPort**, **IpProtocol**, **InternalIp**, and **InternalPort**. After you add a DNAT entry, the NAT gateway forwards packets over the specified protocol from **ExternalIp:ExternalPort** to **InternalIp:InternalPort** and sends responses back through the same route.
|
|
39367
40541
|
* When you call this operation, take note of the following limits:
|
|
39368
|
-
* * **CreateForwardEntry** is an asynchronous operation. After
|
|
39369
|
-
* * If the DNAT entry is in the **Pending** state, the system is adding the DNAT entry. You can only query the
|
|
40542
|
+
* * **CreateForwardEntry** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeForwardTableEntries](~~36053~~) operation to query the status of the task.
|
|
40543
|
+
* * If the DNAT entry is in the **Pending** state, the system is adding the DNAT entry. You can only query the DNAT entry, but cannot perform other operations.
|
|
39370
40544
|
* * If the DNAT entry is in the **Available** state, the DNAT entry is added.
|
|
39371
|
-
* * You cannot repeatedly call the **CreateForwardEntry** operation to add a DNAT entry within
|
|
40545
|
+
* * You cannot repeatedly call the **CreateForwardEntry** operation to add a DNAT entry within a specific period of time.
|
|
39372
40546
|
* * All combinations of **ExternalIp**, **ExternalPort**, and **IpProtocol** used in DNAT entries must be unique. You cannot distribute requests to more than one Elastic Compute Service (ECS) instance if these requests are initiated from the same source IP address, received on the same port, and use the same protocol.
|
|
39373
40547
|
* * The combinations of **IpProtocol**, **InternalIp**, and **InternalPort** must be unique.
|
|
39374
40548
|
* * If one or more DNAT entries in the DNAT table are in the **Pending** or **Modifying** state, you cannot add DNAT entries to the DNAT table.
|
|
@@ -39441,12 +40615,13 @@ class Client extends openapi_client_1.default {
|
|
|
39441
40615
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateForwardEntryResponse({}));
|
|
39442
40616
|
}
|
|
39443
40617
|
/**
|
|
39444
|
-
*
|
|
40618
|
+
* ## [](#)
|
|
40619
|
+
* Each DNAT entry consists of the following parameters: **ExternalIp**, **ExternalPort**, **IpProtocol**, **InternalIp**, and **InternalPort**. After you add a DNAT entry, the NAT gateway forwards packets over the specified protocol from **ExternalIp:ExternalPort** to **InternalIp:InternalPort** and sends responses back through the same route.
|
|
39445
40620
|
* When you call this operation, take note of the following limits:
|
|
39446
|
-
* * **CreateForwardEntry** is an asynchronous operation. After
|
|
39447
|
-
* * If the DNAT entry is in the **Pending** state, the system is adding the DNAT entry. You can only query the
|
|
40621
|
+
* * **CreateForwardEntry** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeForwardTableEntries](~~36053~~) operation to query the status of the task.
|
|
40622
|
+
* * If the DNAT entry is in the **Pending** state, the system is adding the DNAT entry. You can only query the DNAT entry, but cannot perform other operations.
|
|
39448
40623
|
* * If the DNAT entry is in the **Available** state, the DNAT entry is added.
|
|
39449
|
-
* * You cannot repeatedly call the **CreateForwardEntry** operation to add a DNAT entry within
|
|
40624
|
+
* * You cannot repeatedly call the **CreateForwardEntry** operation to add a DNAT entry within a specific period of time.
|
|
39450
40625
|
* * All combinations of **ExternalIp**, **ExternalPort**, and **IpProtocol** used in DNAT entries must be unique. You cannot distribute requests to more than one Elastic Compute Service (ECS) instance if these requests are initiated from the same source IP address, received on the same port, and use the same protocol.
|
|
39451
40626
|
* * The combinations of **IpProtocol**, **InternalIp**, and **InternalPort** must be unique.
|
|
39452
40627
|
* * If one or more DNAT entries in the DNAT table are in the **Pending** or **Modifying** state, you cannot add DNAT entries to the DNAT table.
|
|
@@ -39989,7 +41164,7 @@ class Client extends openapi_client_1.default {
|
|
|
39989
41164
|
}
|
|
39990
41165
|
/**
|
|
39991
41166
|
* * Before you create an IPsec server, you must create a VPN gateway and enable the SSL-VPN feature for the VPN gateway. For more information, see [CreateVpnGateway](~~120363~~).
|
|
39992
|
-
* * **CreateIpsecServer** is an asynchronous operation. After
|
|
41167
|
+
* * **CreateIpsecServer** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call [DescribeVpnGateway](~~73720~~) to query the status of the task:
|
|
39993
41168
|
* * If the VPN gateway is in the **updating** state, the IPsec server is being created.
|
|
39994
41169
|
* * If the VPN gateway is in the **active** state, the IPsec server is created.
|
|
39995
41170
|
* * You cannot repeatedly call the **CreateIpsecServer** operation for the same VPN gateway within the specified period of time.
|
|
@@ -40055,7 +41230,7 @@ class Client extends openapi_client_1.default {
|
|
|
40055
41230
|
}
|
|
40056
41231
|
/**
|
|
40057
41232
|
* * Before you create an IPsec server, you must create a VPN gateway and enable the SSL-VPN feature for the VPN gateway. For more information, see [CreateVpnGateway](~~120363~~).
|
|
40058
|
-
* * **CreateIpsecServer** is an asynchronous operation. After
|
|
41233
|
+
* * **CreateIpsecServer** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call [DescribeVpnGateway](~~73720~~) to query the status of the task:
|
|
40059
41234
|
* * If the VPN gateway is in the **updating** state, the IPsec server is being created.
|
|
40060
41235
|
* * If the VPN gateway is in the **active** state, the IPsec server is created.
|
|
40061
41236
|
* * You cannot repeatedly call the **CreateIpsecServer** operation for the same VPN gateway within the specified period of time.
|
|
@@ -40227,10 +41402,10 @@ class Client extends openapi_client_1.default {
|
|
|
40227
41402
|
return await this.createIpv6EgressOnlyRuleWithOptions(request, runtime);
|
|
40228
41403
|
}
|
|
40229
41404
|
/**
|
|
40230
|
-
* * **CreateIpv6Gateway** is an asynchronous operation. After
|
|
41405
|
+
* * **CreateIpv6Gateway** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeIpv6GatewayAttribute](~~102226~~) operation to query the status of the task.
|
|
40231
41406
|
* * If the IPv6 gateway is in the **Creating** state, the IPv6 gateway is being created.
|
|
40232
41407
|
* * If the IPv6 gateway is in the **Created** state, the IPv6 gateway is created.
|
|
40233
|
-
* * You cannot call the **CreateIpv6Gateway** operation
|
|
41408
|
+
* * You cannot repeatedly call the **CreateIpv6Gateway** operation within a specific time period.
|
|
40234
41409
|
*
|
|
40235
41410
|
* @param request CreateIpv6GatewayRequest
|
|
40236
41411
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -40292,10 +41467,10 @@ class Client extends openapi_client_1.default {
|
|
|
40292
41467
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateIpv6GatewayResponse({}));
|
|
40293
41468
|
}
|
|
40294
41469
|
/**
|
|
40295
|
-
* * **CreateIpv6Gateway** is an asynchronous operation. After
|
|
41470
|
+
* * **CreateIpv6Gateway** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeIpv6GatewayAttribute](~~102226~~) operation to query the status of the task.
|
|
40296
41471
|
* * If the IPv6 gateway is in the **Creating** state, the IPv6 gateway is being created.
|
|
40297
41472
|
* * If the IPv6 gateway is in the **Created** state, the IPv6 gateway is created.
|
|
40298
|
-
* * You cannot call the **CreateIpv6Gateway** operation
|
|
41473
|
+
* * You cannot repeatedly call the **CreateIpv6Gateway** operation within a specific time period.
|
|
40299
41474
|
*
|
|
40300
41475
|
* @param request CreateIpv6GatewayRequest
|
|
40301
41476
|
* @return CreateIpv6GatewayResponse
|
|
@@ -40305,14 +41480,15 @@ class Client extends openapi_client_1.default {
|
|
|
40305
41480
|
return await this.createIpv6GatewayWithOptions(request, runtime);
|
|
40306
41481
|
}
|
|
40307
41482
|
/**
|
|
41483
|
+
* ## [](#)
|
|
40308
41484
|
* Before you call this operation, take note of the following items:
|
|
40309
|
-
* *
|
|
41485
|
+
* * The first time you create a NAT gateway, the system automatically creates the service-linked role AliyunServiceRoleForNatgw. Then, the system attaches the permission policy AliyunServiceRolePolicyForNatgw to the role. This allows the NAT gateway to access other resources on Alibaba Cloud. For more information, see [Service-linked roles](~~174251~~).
|
|
40310
41486
|
* * After you create an enhanced Internet NAT gateway, a route entry is automatically added to the route table of the VPC. The destination CIDR block of the route entry is 0.0.0.0/0 and the next hop is the NAT gateway. This ensures that traffic is routed to the NAT gateway.
|
|
40311
|
-
* * **CreateNatGateway** is an asynchronous operation. After
|
|
41487
|
+
* * **CreateNatGateway** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeNatGateways](~~36054~~) operation to query the status of the task.
|
|
40312
41488
|
* * If a NAT gateway is in the **Creating** state, the NAT gateway is being created. In this case, you can query the NAT gateway but cannot perform other operations.
|
|
40313
41489
|
* * If a NAT gateway is in the **Available** state, the NAT gateway is created.
|
|
40314
|
-
*
|
|
40315
|
-
* * You cannot repeatedly call the **CreateNatGateway** operation
|
|
41490
|
+
* It takes 1 to 3 minutes to create a NAT gateway.
|
|
41491
|
+
* * You cannot repeatedly call the **CreateNatGateway** operation within a specific period of time.
|
|
40316
41492
|
*
|
|
40317
41493
|
* @param request CreateNatGatewayRequest
|
|
40318
41494
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -40404,14 +41580,15 @@ class Client extends openapi_client_1.default {
|
|
|
40404
41580
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateNatGatewayResponse({}));
|
|
40405
41581
|
}
|
|
40406
41582
|
/**
|
|
41583
|
+
* ## [](#)
|
|
40407
41584
|
* Before you call this operation, take note of the following items:
|
|
40408
|
-
* *
|
|
41585
|
+
* * The first time you create a NAT gateway, the system automatically creates the service-linked role AliyunServiceRoleForNatgw. Then, the system attaches the permission policy AliyunServiceRolePolicyForNatgw to the role. This allows the NAT gateway to access other resources on Alibaba Cloud. For more information, see [Service-linked roles](~~174251~~).
|
|
40409
41586
|
* * After you create an enhanced Internet NAT gateway, a route entry is automatically added to the route table of the VPC. The destination CIDR block of the route entry is 0.0.0.0/0 and the next hop is the NAT gateway. This ensures that traffic is routed to the NAT gateway.
|
|
40410
|
-
* * **CreateNatGateway** is an asynchronous operation. After
|
|
41587
|
+
* * **CreateNatGateway** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeNatGateways](~~36054~~) operation to query the status of the task.
|
|
40411
41588
|
* * If a NAT gateway is in the **Creating** state, the NAT gateway is being created. In this case, you can query the NAT gateway but cannot perform other operations.
|
|
40412
41589
|
* * If a NAT gateway is in the **Available** state, the NAT gateway is created.
|
|
40413
|
-
*
|
|
40414
|
-
* * You cannot repeatedly call the **CreateNatGateway** operation
|
|
41590
|
+
* It takes 1 to 3 minutes to create a NAT gateway.
|
|
41591
|
+
* * You cannot repeatedly call the **CreateNatGateway** operation within a specific period of time.
|
|
40415
41592
|
*
|
|
40416
41593
|
* @param request CreateNatGatewayRequest
|
|
40417
41594
|
* @return CreateNatGatewayResponse
|
|
@@ -40421,10 +41598,11 @@ class Client extends openapi_client_1.default {
|
|
|
40421
41598
|
return await this.createNatGatewayWithOptions(request, runtime);
|
|
40422
41599
|
}
|
|
40423
41600
|
/**
|
|
40424
|
-
*
|
|
40425
|
-
*
|
|
41601
|
+
* ## [](#)
|
|
41602
|
+
* **CreateNatIp** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [ListNatIps](~~287000~~) operation to query the status of the task.
|
|
41603
|
+
* * If a NAT IP address is in the **Creating** state, the NAT IP address is being created. In this case, you can only query the NAT IP address and cannot perform other operations.
|
|
40426
41604
|
* * If a NAT IP address is in the **Available** state, the NAT IP address is created.
|
|
40427
|
-
* You cannot repeatedly call the **CreateNatIp** operation to create a NAT IP address within
|
|
41605
|
+
* You cannot repeatedly call the **CreateNatIp** operation to create a NAT IP address within a specific period of time.
|
|
40428
41606
|
*
|
|
40429
41607
|
* @param request CreateNatIpRequest
|
|
40430
41608
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -40489,10 +41667,11 @@ class Client extends openapi_client_1.default {
|
|
|
40489
41667
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateNatIpResponse({}));
|
|
40490
41668
|
}
|
|
40491
41669
|
/**
|
|
40492
|
-
*
|
|
40493
|
-
*
|
|
41670
|
+
* ## [](#)
|
|
41671
|
+
* **CreateNatIp** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [ListNatIps](~~287000~~) operation to query the status of the task.
|
|
41672
|
+
* * If a NAT IP address is in the **Creating** state, the NAT IP address is being created. In this case, you can only query the NAT IP address and cannot perform other operations.
|
|
40494
41673
|
* * If a NAT IP address is in the **Available** state, the NAT IP address is created.
|
|
40495
|
-
* You cannot repeatedly call the **CreateNatIp** operation to create a NAT IP address within
|
|
41674
|
+
* You cannot repeatedly call the **CreateNatIp** operation to create a NAT IP address within a specific period of time.
|
|
40496
41675
|
*
|
|
40497
41676
|
* @param request CreateNatIpRequest
|
|
40498
41677
|
* @return CreateNatIpResponse
|
|
@@ -40502,6 +41681,7 @@ class Client extends openapi_client_1.default {
|
|
|
40502
41681
|
return await this.createNatIpWithOptions(request, runtime);
|
|
40503
41682
|
}
|
|
40504
41683
|
/**
|
|
41684
|
+
* ## [](#)Description
|
|
40505
41685
|
* You cannot repeatedly call the **CreateNatIpCidr** operation to create a NAT CIDR block within the specified period of time.
|
|
40506
41686
|
*
|
|
40507
41687
|
* @param request CreateNatIpCidrRequest
|
|
@@ -40564,6 +41744,7 @@ class Client extends openapi_client_1.default {
|
|
|
40564
41744
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateNatIpCidrResponse({}));
|
|
40565
41745
|
}
|
|
40566
41746
|
/**
|
|
41747
|
+
* ## [](#)Description
|
|
40567
41748
|
* You cannot repeatedly call the **CreateNatIpCidr** operation to create a NAT CIDR block within the specified period of time.
|
|
40568
41749
|
*
|
|
40569
41750
|
* @param request CreateNatIpCidrRequest
|
|
@@ -40582,18 +41763,21 @@ class Client extends openapi_client_1.default {
|
|
|
40582
41763
|
if (!tea_util_1.default.isUnset(request.description)) {
|
|
40583
41764
|
query["Description"] = request.description;
|
|
40584
41765
|
}
|
|
41766
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
41767
|
+
query["DryRun"] = request.dryRun;
|
|
41768
|
+
}
|
|
40585
41769
|
if (!tea_util_1.default.isUnset(request.networkAclName)) {
|
|
40586
41770
|
query["NetworkAclName"] = request.networkAclName;
|
|
40587
41771
|
}
|
|
41772
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
41773
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
41774
|
+
}
|
|
40588
41775
|
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
40589
41776
|
query["OwnerId"] = request.ownerId;
|
|
40590
41777
|
}
|
|
40591
41778
|
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
40592
41779
|
query["RegionId"] = request.regionId;
|
|
40593
41780
|
}
|
|
40594
|
-
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
40595
|
-
query["RegionId"] = request.regionId;
|
|
40596
|
-
}
|
|
40597
41781
|
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
40598
41782
|
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
40599
41783
|
}
|
|
@@ -40935,13 +42119,14 @@ class Client extends openapi_client_1.default {
|
|
|
40935
42119
|
return await this.createPublicIpAddressPoolWithOptions(request, runtime);
|
|
40936
42120
|
}
|
|
40937
42121
|
/**
|
|
40938
|
-
*
|
|
42122
|
+
* ## [](#)References
|
|
42123
|
+
* * **CreateRouteEntries** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeRouteEntryList](~~138148~~) operation to query the status of the task.
|
|
40939
42124
|
* * If the route entry is in the **Creating** state, the route entry is being created.
|
|
40940
42125
|
* * If the route entry is in the **Created** state, the route entry is created.
|
|
40941
42126
|
* * You cannot repeatedly call the **CreateRouteEntries** operation to create the same route entry within the specified period of time.
|
|
40942
42127
|
* **When you call this operation to add custom route entries to the route table of a vRouter, take note of the following items:**
|
|
40943
42128
|
* * A route table can contain up to 200 custom route entries.
|
|
40944
|
-
* * The destination CIDR block (**DstCidrBlock**) of a custom route entry cannot be the same as or overlap with the CIDR block of a vSwitch in the
|
|
42129
|
+
* * The destination CIDR block (**DstCidrBlock**) of a custom route entry cannot be the same as or overlap with the CIDR block of a vSwitch in the VPC.
|
|
40945
42130
|
* * The destination CIDR block (**DstCidrBlock**) of a custom route entry cannot be 100.64.0.0/10 or its subnets.
|
|
40946
42131
|
* * The destination CIDR blocks (**DstCidrBlock**) of route entries in the same route table must be unique.
|
|
40947
42132
|
* * If you do not include the mask length when you specify the destination CIDR block (**DstCidrBlock**), the destination CIDR block is considered a host IP address whose mask length is 32 bits.
|
|
@@ -40993,13 +42178,14 @@ class Client extends openapi_client_1.default {
|
|
|
40993
42178
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateRouteEntriesResponse({}));
|
|
40994
42179
|
}
|
|
40995
42180
|
/**
|
|
40996
|
-
*
|
|
42181
|
+
* ## [](#)References
|
|
42182
|
+
* * **CreateRouteEntries** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeRouteEntryList](~~138148~~) operation to query the status of the task.
|
|
40997
42183
|
* * If the route entry is in the **Creating** state, the route entry is being created.
|
|
40998
42184
|
* * If the route entry is in the **Created** state, the route entry is created.
|
|
40999
42185
|
* * You cannot repeatedly call the **CreateRouteEntries** operation to create the same route entry within the specified period of time.
|
|
41000
42186
|
* **When you call this operation to add custom route entries to the route table of a vRouter, take note of the following items:**
|
|
41001
42187
|
* * A route table can contain up to 200 custom route entries.
|
|
41002
|
-
* * The destination CIDR block (**DstCidrBlock**) of a custom route entry cannot be the same as or overlap with the CIDR block of a vSwitch in the
|
|
42188
|
+
* * The destination CIDR block (**DstCidrBlock**) of a custom route entry cannot be the same as or overlap with the CIDR block of a vSwitch in the VPC.
|
|
41003
42189
|
* * The destination CIDR block (**DstCidrBlock**) of a custom route entry cannot be 100.64.0.0/10 or its subnets.
|
|
41004
42190
|
* * The destination CIDR blocks (**DstCidrBlock**) of route entries in the same route table must be unique.
|
|
41005
42191
|
* * If you do not include the mask length when you specify the destination CIDR block (**DstCidrBlock**), the destination CIDR block is considered a host IP address whose mask length is 32 bits.
|
|
@@ -41014,24 +42200,25 @@ class Client extends openapi_client_1.default {
|
|
|
41014
42200
|
return await this.createRouteEntriesWithOptions(request, runtime);
|
|
41015
42201
|
}
|
|
41016
42202
|
/**
|
|
41017
|
-
* * **CreateRouteEntry** is an asynchronous operation. After
|
|
41018
|
-
* * If
|
|
41019
|
-
* * If
|
|
41020
|
-
* * You cannot repeatedly call
|
|
42203
|
+
* * **CreateRouteEntry** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeRouteEntryList](~~138148~~) operation to query the status of the task:
|
|
42204
|
+
* * If a route is in the **Creating** state, the route is being added.
|
|
42205
|
+
* * If a route is in the **Created** state, the route is added.
|
|
42206
|
+
* * You cannot repeatedly call **CreateRouteEntry** within a specific period of time.
|
|
41021
42207
|
* **When you call this operation to add a custom route entry to the route table of a vRouter, take note of the following limits:**
|
|
42208
|
+
* > When you add a route entry from a prefix list, the quota usage is calculated by adding the number of existing route entries and the maximum number of route entries of the prefix list.
|
|
41022
42209
|
* * A route table can contain up to 200 custom route entries.
|
|
41023
|
-
* * The destination CIDR block (**DestinationCidrBlock**) of a custom route entry cannot be the same as or
|
|
42210
|
+
* * The destination CIDR block (**DestinationCidrBlock**) of a custom route entry cannot be the same as or be a subset of the CIDR block of a vSwitch in the virtual private cloud (VPC). The destination CIDR block can contain the CIDR block of a vSwitch.
|
|
41024
42211
|
* * The destination CIDR block (**DestinationCidrBlock**) of a custom route entry cannot be 100.64.0.0/10 or a subset of it.
|
|
41025
42212
|
* * The destination CIDR blocks (**DestinationCidrBlock**) of route entries in the same route table must be unique.
|
|
41026
42213
|
* * If you do not include the mask length when you specify the destination CIDR block (**DestinationCidrBlock**), the destination CIDR block is considered a host IP address whose mask length is 32 bits.
|
|
41027
42214
|
* * Multiple custom route entries can point to the same next hop (**NextHopId**).
|
|
41028
|
-
* * The next hop (**NextHopId**) of a custom route entry must
|
|
42215
|
+
* * The next hop (**NextHopId**) of a custom route entry must in the same VPC as the route table.
|
|
41029
42216
|
* * Equal-cost multi-path (ECMP) routing can be configured by specifying the **NextHopList** parameter.
|
|
41030
42217
|
* * When you add non-ECMP route entries, you must specify **DestinationCidrBlock**, **NextHopType**, and **NextHopId**, and you must not specify **NextHopList**.
|
|
41031
42218
|
* * When you add route entries for ECMP routing, you must specify **DestinationCidrBlock** and **NextHopList**, and you must not specify **NextHopType** or **NextHopId**.
|
|
41032
42219
|
* **When you call this operation to add a custom route entry to the route table of a VBR, take note of the following limits:**
|
|
41033
42220
|
* * A route table can contain up to 200 custom route entries.
|
|
41034
|
-
* *
|
|
42221
|
+
* * **NextHopList** is not supported.
|
|
41035
42222
|
* * The destination CIDR block (**DestinationCidrBlock**) of a custom route entry cannot be 100.64.0.0/10 or a subset of it.
|
|
41036
42223
|
* * The destination CIDR blocks (**DestinationCidrBlock**) of route entries in the same route table must be unique.
|
|
41037
42224
|
* * If you do not include the mask length when you specify the destination CIDR block (**DestinationCidrBlock**), the destination CIDR block is considered a host IP address whose mask length is 32 bits.
|
|
@@ -41103,24 +42290,25 @@ class Client extends openapi_client_1.default {
|
|
|
41103
42290
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateRouteEntryResponse({}));
|
|
41104
42291
|
}
|
|
41105
42292
|
/**
|
|
41106
|
-
* * **CreateRouteEntry** is an asynchronous operation. After
|
|
41107
|
-
* * If
|
|
41108
|
-
* * If
|
|
41109
|
-
* * You cannot repeatedly call
|
|
42293
|
+
* * **CreateRouteEntry** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeRouteEntryList](~~138148~~) operation to query the status of the task:
|
|
42294
|
+
* * If a route is in the **Creating** state, the route is being added.
|
|
42295
|
+
* * If a route is in the **Created** state, the route is added.
|
|
42296
|
+
* * You cannot repeatedly call **CreateRouteEntry** within a specific period of time.
|
|
41110
42297
|
* **When you call this operation to add a custom route entry to the route table of a vRouter, take note of the following limits:**
|
|
42298
|
+
* > When you add a route entry from a prefix list, the quota usage is calculated by adding the number of existing route entries and the maximum number of route entries of the prefix list.
|
|
41111
42299
|
* * A route table can contain up to 200 custom route entries.
|
|
41112
|
-
* * The destination CIDR block (**DestinationCidrBlock**) of a custom route entry cannot be the same as or
|
|
42300
|
+
* * The destination CIDR block (**DestinationCidrBlock**) of a custom route entry cannot be the same as or be a subset of the CIDR block of a vSwitch in the virtual private cloud (VPC). The destination CIDR block can contain the CIDR block of a vSwitch.
|
|
41113
42301
|
* * The destination CIDR block (**DestinationCidrBlock**) of a custom route entry cannot be 100.64.0.0/10 or a subset of it.
|
|
41114
42302
|
* * The destination CIDR blocks (**DestinationCidrBlock**) of route entries in the same route table must be unique.
|
|
41115
42303
|
* * If you do not include the mask length when you specify the destination CIDR block (**DestinationCidrBlock**), the destination CIDR block is considered a host IP address whose mask length is 32 bits.
|
|
41116
42304
|
* * Multiple custom route entries can point to the same next hop (**NextHopId**).
|
|
41117
|
-
* * The next hop (**NextHopId**) of a custom route entry must
|
|
42305
|
+
* * The next hop (**NextHopId**) of a custom route entry must in the same VPC as the route table.
|
|
41118
42306
|
* * Equal-cost multi-path (ECMP) routing can be configured by specifying the **NextHopList** parameter.
|
|
41119
42307
|
* * When you add non-ECMP route entries, you must specify **DestinationCidrBlock**, **NextHopType**, and **NextHopId**, and you must not specify **NextHopList**.
|
|
41120
42308
|
* * When you add route entries for ECMP routing, you must specify **DestinationCidrBlock** and **NextHopList**, and you must not specify **NextHopType** or **NextHopId**.
|
|
41121
42309
|
* **When you call this operation to add a custom route entry to the route table of a VBR, take note of the following limits:**
|
|
41122
42310
|
* * A route table can contain up to 200 custom route entries.
|
|
41123
|
-
* *
|
|
42311
|
+
* * **NextHopList** is not supported.
|
|
41124
42312
|
* * The destination CIDR block (**DestinationCidrBlock**) of a custom route entry cannot be 100.64.0.0/10 or a subset of it.
|
|
41125
42313
|
* * The destination CIDR blocks (**DestinationCidrBlock**) of route entries in the same route table must be unique.
|
|
41126
42314
|
* * If you do not include the mask length when you specify the destination CIDR block (**DestinationCidrBlock**), the destination CIDR block is considered a host IP address whose mask length is 32 bits.
|
|
@@ -41215,6 +42403,7 @@ class Client extends openapi_client_1.default {
|
|
|
41215
42403
|
return await this.createRouteTableWithOptions(request, runtime);
|
|
41216
42404
|
}
|
|
41217
42405
|
/**
|
|
42406
|
+
* ## [](#)
|
|
41218
42407
|
* When you call this operation, take note of the following limits:
|
|
41219
42408
|
* * You can create only one pair of interfaces to be connected between two routers.
|
|
41220
42409
|
* * You can create a maximum of five router interfaces for a router.
|
|
@@ -41337,6 +42526,7 @@ class Client extends openapi_client_1.default {
|
|
|
41337
42526
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateRouterInterfaceResponse({}));
|
|
41338
42527
|
}
|
|
41339
42528
|
/**
|
|
42529
|
+
* ## [](#)
|
|
41340
42530
|
* When you call this operation, take note of the following limits:
|
|
41341
42531
|
* * You can create only one pair of interfaces to be connected between two routers.
|
|
41342
42532
|
* * You can create a maximum of five router interfaces for a router.
|
|
@@ -41488,7 +42678,7 @@ class Client extends openapi_client_1.default {
|
|
|
41488
42678
|
return await this.createSslVpnClientCertWithOptions(request, runtime);
|
|
41489
42679
|
}
|
|
41490
42680
|
/**
|
|
41491
|
-
* * **CreateSslVpnServer** is an asynchronous operation. After
|
|
42681
|
+
* * **CreateSslVpnServer** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeVpnGateway](~~73720~~) operation to query the status of the task.
|
|
41492
42682
|
* * If the VPN gateway is in the **updating** state, the SSL server is being created.
|
|
41493
42683
|
* * If the VPN gateway is in the **active** state, the SSL server is created.
|
|
41494
42684
|
* * You cannot repeatedly call the **CreateSslVpnServer** operation for the same VPN gateway within the specified period of time.
|
|
@@ -41568,7 +42758,7 @@ class Client extends openapi_client_1.default {
|
|
|
41568
42758
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateSslVpnServerResponse({}));
|
|
41569
42759
|
}
|
|
41570
42760
|
/**
|
|
41571
|
-
* * **CreateSslVpnServer** is an asynchronous operation. After
|
|
42761
|
+
* * **CreateSslVpnServer** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeVpnGateway](~~73720~~) operation to query the status of the task.
|
|
41572
42762
|
* * If the VPN gateway is in the **updating** state, the SSL server is being created.
|
|
41573
42763
|
* * If the VPN gateway is in the **active** state, the SSL server is created.
|
|
41574
42764
|
* * You cannot repeatedly call the **CreateSslVpnServer** operation for the same VPN gateway within the specified period of time.
|
|
@@ -41926,6 +43116,103 @@ class Client extends openapi_client_1.default {
|
|
|
41926
43116
|
let runtime = new $Util.RuntimeOptions({});
|
|
41927
43117
|
return await this.createVSwitchWithOptions(request, runtime);
|
|
41928
43118
|
}
|
|
43119
|
+
/**
|
|
43120
|
+
* ## [](#)Description
|
|
43121
|
+
* Take note of the following items:
|
|
43122
|
+
* * You can create at most 10 reserved IPv4 CIDR blocks and 10 reserved IPv6 CIDR blocks for each vSwitch in a virtual private cloud (VPC).
|
|
43123
|
+
* * After you create a reserved CIDR block for a vSwitch, the CIDR block cannot contain the IP address of the subnet gateway of the VPC to which the vSwitch belongs.
|
|
43124
|
+
* * **CreateVSwitchCidrReservation** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call [ListVSwitchCidrReservations](~~610155~~) to query the status of the task:
|
|
43125
|
+
* * If the vSwitch is in the **Assigning** state, the reserved CIDR block is being created.
|
|
43126
|
+
* * If the vSwitch is in the **Assigned** state, the reserved CIDR block is created.
|
|
43127
|
+
* * When you create a reserved IPv4 CIDR block for a vSwitch, the first IP address and the last three IP addresses of the vSwitch are reserved by the system. The four IP addresses will not be allocated.
|
|
43128
|
+
* * When you create a reserved IPv6 CIDR block for a vSwitch, the first IP address and the last nine IP addresses of the vSwitch are reserved by the system. The 10 IP addresses will not be allocated. For example, if you create a reserved IPv4 CIDR block for a vSwitch whose CIDR block is 192.168.1.0/24, the reserved CIDR block cannot contain the following IP addresses: 192.168.1.0, 192.168.1.253, 192.168.1.254, and 192.168.1.255.
|
|
43129
|
+
*
|
|
43130
|
+
* @param request CreateVSwitchCidrReservationRequest
|
|
43131
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
43132
|
+
* @return CreateVSwitchCidrReservationResponse
|
|
43133
|
+
*/
|
|
43134
|
+
async createVSwitchCidrReservationWithOptions(request, runtime) {
|
|
43135
|
+
tea_util_1.default.validateModel(request);
|
|
43136
|
+
let query = {};
|
|
43137
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
43138
|
+
query["ClientToken"] = request.clientToken;
|
|
43139
|
+
}
|
|
43140
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
43141
|
+
query["DryRun"] = request.dryRun;
|
|
43142
|
+
}
|
|
43143
|
+
if (!tea_util_1.default.isUnset(request.ipVersion)) {
|
|
43144
|
+
query["IpVersion"] = request.ipVersion;
|
|
43145
|
+
}
|
|
43146
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
43147
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
43148
|
+
}
|
|
43149
|
+
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
43150
|
+
query["OwnerId"] = request.ownerId;
|
|
43151
|
+
}
|
|
43152
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
43153
|
+
query["RegionId"] = request.regionId;
|
|
43154
|
+
}
|
|
43155
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
43156
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
43157
|
+
}
|
|
43158
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerId)) {
|
|
43159
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
43160
|
+
}
|
|
43161
|
+
if (!tea_util_1.default.isUnset(request.tag)) {
|
|
43162
|
+
query["Tag"] = request.tag;
|
|
43163
|
+
}
|
|
43164
|
+
if (!tea_util_1.default.isUnset(request.vSwitchCidrReservationCidr)) {
|
|
43165
|
+
query["VSwitchCidrReservationCidr"] = request.vSwitchCidrReservationCidr;
|
|
43166
|
+
}
|
|
43167
|
+
if (!tea_util_1.default.isUnset(request.vSwitchCidrReservationDescription)) {
|
|
43168
|
+
query["VSwitchCidrReservationDescription"] = request.vSwitchCidrReservationDescription;
|
|
43169
|
+
}
|
|
43170
|
+
if (!tea_util_1.default.isUnset(request.vSwitchCidrReservationMask)) {
|
|
43171
|
+
query["VSwitchCidrReservationMask"] = request.vSwitchCidrReservationMask;
|
|
43172
|
+
}
|
|
43173
|
+
if (!tea_util_1.default.isUnset(request.vSwitchCidrReservationName)) {
|
|
43174
|
+
query["VSwitchCidrReservationName"] = request.vSwitchCidrReservationName;
|
|
43175
|
+
}
|
|
43176
|
+
if (!tea_util_1.default.isUnset(request.vSwitchCidrReservationType)) {
|
|
43177
|
+
query["VSwitchCidrReservationType"] = request.vSwitchCidrReservationType;
|
|
43178
|
+
}
|
|
43179
|
+
if (!tea_util_1.default.isUnset(request.vSwitchId)) {
|
|
43180
|
+
query["VSwitchId"] = request.vSwitchId;
|
|
43181
|
+
}
|
|
43182
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
43183
|
+
query: openapi_util_1.default.query(query),
|
|
43184
|
+
});
|
|
43185
|
+
let params = new $OpenApi.Params({
|
|
43186
|
+
action: "CreateVSwitchCidrReservation",
|
|
43187
|
+
version: "2016-04-28",
|
|
43188
|
+
protocol: "HTTPS",
|
|
43189
|
+
pathname: "/",
|
|
43190
|
+
method: "POST",
|
|
43191
|
+
authType: "AK",
|
|
43192
|
+
style: "RPC",
|
|
43193
|
+
reqBodyType: "formData",
|
|
43194
|
+
bodyType: "json",
|
|
43195
|
+
});
|
|
43196
|
+
return $tea.cast(await this.callApi(params, req, runtime), new CreateVSwitchCidrReservationResponse({}));
|
|
43197
|
+
}
|
|
43198
|
+
/**
|
|
43199
|
+
* ## [](#)Description
|
|
43200
|
+
* Take note of the following items:
|
|
43201
|
+
* * You can create at most 10 reserved IPv4 CIDR blocks and 10 reserved IPv6 CIDR blocks for each vSwitch in a virtual private cloud (VPC).
|
|
43202
|
+
* * After you create a reserved CIDR block for a vSwitch, the CIDR block cannot contain the IP address of the subnet gateway of the VPC to which the vSwitch belongs.
|
|
43203
|
+
* * **CreateVSwitchCidrReservation** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call [ListVSwitchCidrReservations](~~610155~~) to query the status of the task:
|
|
43204
|
+
* * If the vSwitch is in the **Assigning** state, the reserved CIDR block is being created.
|
|
43205
|
+
* * If the vSwitch is in the **Assigned** state, the reserved CIDR block is created.
|
|
43206
|
+
* * When you create a reserved IPv4 CIDR block for a vSwitch, the first IP address and the last three IP addresses of the vSwitch are reserved by the system. The four IP addresses will not be allocated.
|
|
43207
|
+
* * When you create a reserved IPv6 CIDR block for a vSwitch, the first IP address and the last nine IP addresses of the vSwitch are reserved by the system. The 10 IP addresses will not be allocated. For example, if you create a reserved IPv4 CIDR block for a vSwitch whose CIDR block is 192.168.1.0/24, the reserved CIDR block cannot contain the following IP addresses: 192.168.1.0, 192.168.1.253, 192.168.1.254, and 192.168.1.255.
|
|
43208
|
+
*
|
|
43209
|
+
* @param request CreateVSwitchCidrReservationRequest
|
|
43210
|
+
* @return CreateVSwitchCidrReservationResponse
|
|
43211
|
+
*/
|
|
43212
|
+
async createVSwitchCidrReservation(request) {
|
|
43213
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
43214
|
+
return await this.createVSwitchCidrReservationWithOptions(request, runtime);
|
|
43215
|
+
}
|
|
41929
43216
|
async createVbrHaWithOptions(request, runtime) {
|
|
41930
43217
|
tea_util_1.default.validateModel(request);
|
|
41931
43218
|
let query = {};
|
|
@@ -42062,7 +43349,7 @@ class Client extends openapi_client_1.default {
|
|
|
42062
43349
|
return await this.createVcoRouteEntryWithOptions(request, runtime);
|
|
42063
43350
|
}
|
|
42064
43351
|
/**
|
|
42065
|
-
* When you create a VBR, the VBR is in the **
|
|
43352
|
+
* When you create a VBR, the VBR is in the **active** state by default.
|
|
42066
43353
|
*
|
|
42067
43354
|
* @param request CreateVirtualBorderRouterRequest
|
|
42068
43355
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -42154,7 +43441,7 @@ class Client extends openapi_client_1.default {
|
|
|
42154
43441
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateVirtualBorderRouterResponse({}));
|
|
42155
43442
|
}
|
|
42156
43443
|
/**
|
|
42157
|
-
* When you create a VBR, the VBR is in the **
|
|
43444
|
+
* When you create a VBR, the VBR is in the **active** state by default.
|
|
42158
43445
|
*
|
|
42159
43446
|
* @param request CreateVirtualBorderRouterRequest
|
|
42160
43447
|
* @return CreateVirtualBorderRouterResponse
|
|
@@ -42164,7 +43451,8 @@ class Client extends openapi_client_1.default {
|
|
|
42164
43451
|
return await this.createVirtualBorderRouterWithOptions(request, runtime);
|
|
42165
43452
|
}
|
|
42166
43453
|
/**
|
|
42167
|
-
*
|
|
43454
|
+
* # [](#)Description
|
|
43455
|
+
* Before you call this operation, we recommend that you learn about the workflow for creating a hosted connection and the environment requirements. For more information, see [Overview of hosted connections](~~146571~~) and [Operations performed by Express Connect partners](~~155987~~).
|
|
42168
43456
|
*
|
|
42169
43457
|
* @param request CreateVirtualPhysicalConnectionRequest
|
|
42170
43458
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -42226,7 +43514,8 @@ class Client extends openapi_client_1.default {
|
|
|
42226
43514
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateVirtualPhysicalConnectionResponse({}));
|
|
42227
43515
|
}
|
|
42228
43516
|
/**
|
|
42229
|
-
*
|
|
43517
|
+
* # [](#)Description
|
|
43518
|
+
* Before you call this operation, we recommend that you learn about the workflow for creating a hosted connection and the environment requirements. For more information, see [Overview of hosted connections](~~146571~~) and [Operations performed by Express Connect partners](~~155987~~).
|
|
42230
43519
|
*
|
|
42231
43520
|
* @param request CreateVirtualPhysicalConnectionRequest
|
|
42232
43521
|
* @return CreateVirtualPhysicalConnectionResponse
|
|
@@ -42488,8 +43777,8 @@ class Client extends openapi_client_1.default {
|
|
|
42488
43777
|
* Preparations:
|
|
42489
43778
|
* Before the Express Connect partner performs the operation, the Express Connect partner must notify the tenant and request the tenant to enable outbound data transfer billing. For more information, see [Enable outbound data transfer billing](~~274385~~).
|
|
42490
43779
|
* What to do next:
|
|
42491
|
-
* 1
|
|
42492
|
-
* 2
|
|
43780
|
+
* 1. After the Express Connect partner performs the operation, a shared port is added for the tenant account. The tenant must call the [ConfirmPhysicalConnection](~~324198~~) operation to accept the shared port.
|
|
43781
|
+
* 2. Then, the Express Connect partner must call the [AttachVbrToVpconn](~~324191~~) operation to associate the VBR with the newly added shared port that belongs to the tenant account.
|
|
42493
43782
|
*
|
|
42494
43783
|
* @param request CreateVpconnFromVbrRequest
|
|
42495
43784
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -42534,8 +43823,8 @@ class Client extends openapi_client_1.default {
|
|
|
42534
43823
|
* Preparations:
|
|
42535
43824
|
* Before the Express Connect partner performs the operation, the Express Connect partner must notify the tenant and request the tenant to enable outbound data transfer billing. For more information, see [Enable outbound data transfer billing](~~274385~~).
|
|
42536
43825
|
* What to do next:
|
|
42537
|
-
* 1
|
|
42538
|
-
* 2
|
|
43826
|
+
* 1. After the Express Connect partner performs the operation, a shared port is added for the tenant account. The tenant must call the [ConfirmPhysicalConnection](~~324198~~) operation to accept the shared port.
|
|
43827
|
+
* 2. Then, the Express Connect partner must call the [AttachVbrToVpconn](~~324191~~) operation to associate the VBR with the newly added shared port that belongs to the tenant account.
|
|
42539
43828
|
*
|
|
42540
43829
|
* @param request CreateVpconnFromVbrRequest
|
|
42541
43830
|
* @return CreateVpconnFromVbrResponse
|
|
@@ -42546,7 +43835,7 @@ class Client extends openapi_client_1.default {
|
|
|
42546
43835
|
}
|
|
42547
43836
|
/**
|
|
42548
43837
|
* By default, an IPsec-VPN connection created by calling the `CreateVpnAttachment` operation is not associated with a resource. You can associate an IPsec-VPN connection with a transit router by calling the [CreateTransitRouterVpnAttachment](~~443993~~) operation.
|
|
42549
|
-
* ###
|
|
43838
|
+
* ### [](#)Prerequisites
|
|
42550
43839
|
* Before you create an IPsec-VPN connection, make sure that you created a customer gateway in the region where you want to create the IPsec-VPN connection. For more information, see [CreateCustomerGateway](~~120368~~).
|
|
42551
43840
|
* If you want to add BGP configurations to an IPsec-VPN connection, make sure that an autonomous system number (ASN) is assigned to the customer gateway.
|
|
42552
43841
|
*
|
|
@@ -42638,7 +43927,7 @@ class Client extends openapi_client_1.default {
|
|
|
42638
43927
|
}
|
|
42639
43928
|
/**
|
|
42640
43929
|
* By default, an IPsec-VPN connection created by calling the `CreateVpnAttachment` operation is not associated with a resource. You can associate an IPsec-VPN connection with a transit router by calling the [CreateTransitRouterVpnAttachment](~~443993~~) operation.
|
|
42641
|
-
* ###
|
|
43930
|
+
* ### [](#)Prerequisites
|
|
42642
43931
|
* Before you create an IPsec-VPN connection, make sure that you created a customer gateway in the region where you want to create the IPsec-VPN connection. For more information, see [CreateCustomerGateway](~~120368~~).
|
|
42643
43932
|
* If you want to add BGP configurations to an IPsec-VPN connection, make sure that an autonomous system number (ASN) is assigned to the customer gateway.
|
|
42644
43933
|
*
|
|
@@ -42651,9 +43940,10 @@ class Client extends openapi_client_1.default {
|
|
|
42651
43940
|
}
|
|
42652
43941
|
/**
|
|
42653
43942
|
* * If the VPN gateway supports the dual-tunnel mode, you can specify the following parameters in addition to the required parameters when you call `CreateVpnConnection`:
|
|
42654
|
-
* **ClientToken**, **Name**, **EffectImmediately**, **AutoConfigRoute**, **Tags
|
|
42655
|
-
*
|
|
42656
|
-
*
|
|
43943
|
+
* **ClientToken**, **Name**, **EffectImmediately**, **AutoConfigRoute**, **Tags** array, **TunnelOptionsSpecification** array, and **EnableTunnelsBgp**.
|
|
43944
|
+
* For more information about the regions and zones that support the dual-tunnel mode, see [IPsec-VPN connections support the dual-tunnel mode](~~2358946~~).
|
|
43945
|
+
* * If the VPN gateway supports only the dual-tunnel mode, you can specify the following parameters in addition to the required parameters when you call `CreateVpnConnection`:
|
|
43946
|
+
* **ClientToken**, **CustomerGatewayId**, **Name**, **EffectImmediately**, **IkeConfig**, **IpsecConfig**, **HealthCheckConfig**, **AutoConfigRoute**, **EnableDpd**, **EnableNatTraversal**, **BgpConfig**, **RemoteCaCertificate**, and **Tags** array.
|
|
42657
43947
|
* * **CreateVpnConnection** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call [DescribeVpnGateway](~~73720~~) to query the status of the task.
|
|
42658
43948
|
* * If the VPN gateway is in the **updating** state, the IPsec-VPN connection is being created.
|
|
42659
43949
|
* * If the VPN gateway is in the **active** state, the IPsec-VPN connection is created.
|
|
@@ -42757,9 +44047,10 @@ class Client extends openapi_client_1.default {
|
|
|
42757
44047
|
}
|
|
42758
44048
|
/**
|
|
42759
44049
|
* * If the VPN gateway supports the dual-tunnel mode, you can specify the following parameters in addition to the required parameters when you call `CreateVpnConnection`:
|
|
42760
|
-
* **ClientToken**, **Name**, **EffectImmediately**, **AutoConfigRoute**, **Tags
|
|
42761
|
-
*
|
|
42762
|
-
*
|
|
44050
|
+
* **ClientToken**, **Name**, **EffectImmediately**, **AutoConfigRoute**, **Tags** array, **TunnelOptionsSpecification** array, and **EnableTunnelsBgp**.
|
|
44051
|
+
* For more information about the regions and zones that support the dual-tunnel mode, see [IPsec-VPN connections support the dual-tunnel mode](~~2358946~~).
|
|
44052
|
+
* * If the VPN gateway supports only the dual-tunnel mode, you can specify the following parameters in addition to the required parameters when you call `CreateVpnConnection`:
|
|
44053
|
+
* **ClientToken**, **CustomerGatewayId**, **Name**, **EffectImmediately**, **IkeConfig**, **IpsecConfig**, **HealthCheckConfig**, **AutoConfigRoute**, **EnableDpd**, **EnableNatTraversal**, **BgpConfig**, **RemoteCaCertificate**, and **Tags** array.
|
|
42763
44054
|
* * **CreateVpnConnection** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call [DescribeVpnGateway](~~73720~~) to query the status of the task.
|
|
42764
44055
|
* * If the VPN gateway is in the **updating** state, the IPsec-VPN connection is being created.
|
|
42765
44056
|
* * If the VPN gateway is in the **active** state, the IPsec-VPN connection is created.
|
|
@@ -43383,7 +44674,8 @@ class Client extends openapi_client_1.default {
|
|
|
43383
44674
|
return await this.deleteCustomerGatewayWithOptions(request, runtime);
|
|
43384
44675
|
}
|
|
43385
44676
|
/**
|
|
43386
|
-
*
|
|
44677
|
+
* ## [](#)Description
|
|
44678
|
+
* * **DeleteDhcpOptionsSet** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [GetDhcpOptionsSet](~~189208~~) operation to query the status of the task.
|
|
43387
44679
|
* * If the DHCP options set is in the **Deleting** state, the DHCP options set is being deleted.
|
|
43388
44680
|
* * If you cannot query the DHCP options set, the DHCP options set is deleted.
|
|
43389
44681
|
* * You cannot repeatedly call the **DeleteDhcpOptionsSet** operation to delete a DHCP options set within the specified period of time.
|
|
@@ -43436,7 +44728,8 @@ class Client extends openapi_client_1.default {
|
|
|
43436
44728
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteDhcpOptionsSetResponse({}));
|
|
43437
44729
|
}
|
|
43438
44730
|
/**
|
|
43439
|
-
*
|
|
44731
|
+
* ## [](#)Description
|
|
44732
|
+
* * **DeleteDhcpOptionsSet** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [GetDhcpOptionsSet](~~189208~~) operation to query the status of the task.
|
|
43440
44733
|
* * If the DHCP options set is in the **Deleting** state, the DHCP options set is being deleted.
|
|
43441
44734
|
* * If you cannot query the DHCP options set, the DHCP options set is deleted.
|
|
43442
44735
|
* * You cannot repeatedly call the **DeleteDhcpOptionsSet** operation to delete a DHCP options set within the specified period of time.
|
|
@@ -43448,6 +44741,50 @@ class Client extends openapi_client_1.default {
|
|
|
43448
44741
|
let runtime = new $Util.RuntimeOptions({});
|
|
43449
44742
|
return await this.deleteDhcpOptionsSetWithOptions(request, runtime);
|
|
43450
44743
|
}
|
|
44744
|
+
async deleteFailoverTestJobWithOptions(request, runtime) {
|
|
44745
|
+
tea_util_1.default.validateModel(request);
|
|
44746
|
+
let query = {};
|
|
44747
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
44748
|
+
query["ClientToken"] = request.clientToken;
|
|
44749
|
+
}
|
|
44750
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
44751
|
+
query["ClientToken"] = request.clientToken;
|
|
44752
|
+
}
|
|
44753
|
+
if (!tea_util_1.default.isUnset(request.jobId)) {
|
|
44754
|
+
query["JobId"] = request.jobId;
|
|
44755
|
+
}
|
|
44756
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
44757
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
44758
|
+
}
|
|
44759
|
+
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
44760
|
+
query["OwnerId"] = request.ownerId;
|
|
44761
|
+
}
|
|
44762
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
44763
|
+
query["RegionId"] = request.regionId;
|
|
44764
|
+
}
|
|
44765
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
44766
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
44767
|
+
}
|
|
44768
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
44769
|
+
query: openapi_util_1.default.query(query),
|
|
44770
|
+
});
|
|
44771
|
+
let params = new $OpenApi.Params({
|
|
44772
|
+
action: "DeleteFailoverTestJob",
|
|
44773
|
+
version: "2016-04-28",
|
|
44774
|
+
protocol: "HTTPS",
|
|
44775
|
+
pathname: "/",
|
|
44776
|
+
method: "POST",
|
|
44777
|
+
authType: "AK",
|
|
44778
|
+
style: "RPC",
|
|
44779
|
+
reqBodyType: "formData",
|
|
44780
|
+
bodyType: "json",
|
|
44781
|
+
});
|
|
44782
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DeleteFailoverTestJobResponse({}));
|
|
44783
|
+
}
|
|
44784
|
+
async deleteFailoverTestJob(request) {
|
|
44785
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
44786
|
+
return await this.deleteFailoverTestJobWithOptions(request, runtime);
|
|
44787
|
+
}
|
|
43451
44788
|
/**
|
|
43452
44789
|
* * The **DeleteFlowLog** operation is asynchronous. After you send the request, the system returns a request ID. However, the operation is still being performed in the system background. You can call the [DescribeFlowLogs](~~87923~~) operation to query the status of a flow log:
|
|
43453
44790
|
* * If the flow log is in the **Deleting** state, the flow log is being deleted.
|
|
@@ -43509,7 +44846,8 @@ class Client extends openapi_client_1.default {
|
|
|
43509
44846
|
return await this.deleteFlowLogWithOptions(request, runtime);
|
|
43510
44847
|
}
|
|
43511
44848
|
/**
|
|
43512
|
-
*
|
|
44849
|
+
* ## [](#)Description
|
|
44850
|
+
* * **DeleteForwardEntry** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeForwardTableEntries](~~36053~~) operation to query the status of the task.
|
|
43513
44851
|
* * If the DNAT entry is in the **Deleting** state, the system is deleting the DNAT entry. In this case, you can only query the status of the DNAT entry, but cannot perform other operations.
|
|
43514
44852
|
* * If the DNAT entry cannot be found, it is deleted.
|
|
43515
44853
|
* > If a DNAT table has DNAT entries in the **Pending** state, you cannot delete the DNAT entries.
|
|
@@ -43563,7 +44901,8 @@ class Client extends openapi_client_1.default {
|
|
|
43563
44901
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteForwardEntryResponse({}));
|
|
43564
44902
|
}
|
|
43565
44903
|
/**
|
|
43566
|
-
*
|
|
44904
|
+
* ## [](#)Description
|
|
44905
|
+
* * **DeleteForwardEntry** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeForwardTableEntries](~~36053~~) operation to query the status of the task.
|
|
43567
44906
|
* * If the DNAT entry is in the **Deleting** state, the system is deleting the DNAT entry. In this case, you can only query the status of the DNAT entry, but cannot perform other operations.
|
|
43568
44907
|
* * If the DNAT entry cannot be found, it is deleted.
|
|
43569
44908
|
* > If a DNAT table has DNAT entries in the **Pending** state, you cannot delete the DNAT entries.
|
|
@@ -43577,7 +44916,8 @@ class Client extends openapi_client_1.default {
|
|
|
43577
44916
|
return await this.deleteForwardEntryWithOptions(request, runtime);
|
|
43578
44917
|
}
|
|
43579
44918
|
/**
|
|
43580
|
-
*
|
|
44919
|
+
* ## [](#)Description
|
|
44920
|
+
* **DeleteFullNatEntry** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [ListFullNatEntries](~~348779~~) operation to query the status of a FULLNAT entry.
|
|
43581
44921
|
* * If the FULLNAT entry is in the **Deleting** state, the system is deleting the FULLNAT entry. In this case, you can query the status of the FULLNAT entry, but cannot perform other operations.
|
|
43582
44922
|
* * If the FULLNAT entry cannot be found, the FULLNAT entry is deleted.
|
|
43583
44923
|
* You cannot repeatedly call the **DeleteFullNatEntry** operation to delete a FULLNAT entry within the specified period of time.
|
|
@@ -43633,7 +44973,8 @@ class Client extends openapi_client_1.default {
|
|
|
43633
44973
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteFullNatEntryResponse({}));
|
|
43634
44974
|
}
|
|
43635
44975
|
/**
|
|
43636
|
-
*
|
|
44976
|
+
* ## [](#)Description
|
|
44977
|
+
* **DeleteFullNatEntry** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [ListFullNatEntries](~~348779~~) operation to query the status of a FULLNAT entry.
|
|
43637
44978
|
* * If the FULLNAT entry is in the **Deleting** state, the system is deleting the FULLNAT entry. In this case, you can query the status of the FULLNAT entry, but cannot perform other operations.
|
|
43638
44979
|
* * If the FULLNAT entry cannot be found, the FULLNAT entry is deleted.
|
|
43639
44980
|
* You cannot repeatedly call the **DeleteFullNatEntry** operation to delete a FULLNAT entry within the specified period of time.
|
|
@@ -43996,10 +45337,11 @@ class Client extends openapi_client_1.default {
|
|
|
43996
45337
|
return await this.deleteIpsecServerWithOptions(request, runtime);
|
|
43997
45338
|
}
|
|
43998
45339
|
/**
|
|
45340
|
+
* ### [](#)Description
|
|
43999
45341
|
* * Before you delete an IPv4 gateway, make sure that no route tables are associated with the IPv4 gateway.
|
|
44000
|
-
* *
|
|
45342
|
+
* * **DeleteIpv4Gateway** is an asynchronous operation. After a request is sent, the system returns a **request ID** and runs the task in the background. You can call the [GetIpv4GatewayAttribute](~~407670~~) operation to query the status of the task.
|
|
44001
45343
|
* * If the IPv4 gateway is in the **Deleting** state, the IPv4 gateway is being deleted.
|
|
44002
|
-
* * If the IPv4 gateway cannot be queried, the
|
|
45344
|
+
* * If the IPv4 gateway cannot be queried, the IPv4 gateway is deleted.
|
|
44003
45345
|
* * After you call the **DeleteIpv4Gateway** operation to delete an IPv4 gateway, you cannot call the operation again to delete the IPv4 gateway until the deletion task is complete.
|
|
44004
45346
|
*
|
|
44005
45347
|
* @param request DeleteIpv4GatewayRequest
|
|
@@ -44053,10 +45395,11 @@ class Client extends openapi_client_1.default {
|
|
|
44053
45395
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteIpv4GatewayResponse({}));
|
|
44054
45396
|
}
|
|
44055
45397
|
/**
|
|
45398
|
+
* ### [](#)Description
|
|
44056
45399
|
* * Before you delete an IPv4 gateway, make sure that no route tables are associated with the IPv4 gateway.
|
|
44057
|
-
* *
|
|
45400
|
+
* * **DeleteIpv4Gateway** is an asynchronous operation. After a request is sent, the system returns a **request ID** and runs the task in the background. You can call the [GetIpv4GatewayAttribute](~~407670~~) operation to query the status of the task.
|
|
44058
45401
|
* * If the IPv4 gateway is in the **Deleting** state, the IPv4 gateway is being deleted.
|
|
44059
|
-
* * If the IPv4 gateway cannot be queried, the
|
|
45402
|
+
* * If the IPv4 gateway cannot be queried, the IPv4 gateway is deleted.
|
|
44060
45403
|
* * After you call the **DeleteIpv4Gateway** operation to delete an IPv4 gateway, you cannot call the operation again to delete the IPv4 gateway until the deletion task is complete.
|
|
44061
45404
|
*
|
|
44062
45405
|
* @param request DeleteIpv4GatewayRequest
|
|
@@ -44133,12 +45476,11 @@ class Client extends openapi_client_1.default {
|
|
|
44133
45476
|
return await this.deleteIpv6EgressOnlyRuleWithOptions(request, runtime);
|
|
44134
45477
|
}
|
|
44135
45478
|
/**
|
|
44136
|
-
* - The **DeleteIpv6Gateway** operation is asynchronous. After you send the request, the system returns a request ID. However, the operation is still being performed in the system background. You can call the [DescribeIpv6GatewayAttribute](/help/en/virtual-private-cloud/latest/describeipv6gatewayattribute) operation to query the status of an IPv6 gateway:
|
|
44137
|
-
* - If the IPv6 gateway is in the **Deleting** state, the IPv6 gateway is being deleted.
|
|
44138
|
-
* - If you cannot query the IPv6 gateway, the IPv6 gateway is deleted.
|
|
44139
|
-
* - After you call the **DeleteIpv6Gateway** operation to delete an IPv6 gateway, you cannot call the operation again to delete the IPv6 gateway until the deletion task is complete.
|
|
44140
|
-
* ## Prerequisites
|
|
44141
45479
|
* Before you delete an IPv6 gateway, you must delete the egress-only rules of the IPv6 gateway. For more information, see [DeleteIpv6EgressOnlyRule](~~102201~~).
|
|
45480
|
+
* * **DeleteIpv6Gateway** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeIpv6GatewayAttribute](~~102226~~) operation to query the status of the task:
|
|
45481
|
+
* * If the IPv6 gateway is in the **Deleting** state, the IPv6 gateway is being deleted.
|
|
45482
|
+
* * If you cannot query the IPv6 gateway, the IPv6 gateway is deleted.
|
|
45483
|
+
* * You cannot repeatedly call the **DeleteIpv6Gateway** operation to delete an IPv6 gateway within the specified period of time.
|
|
44142
45484
|
*
|
|
44143
45485
|
* @param request DeleteIpv6GatewayRequest
|
|
44144
45486
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -44185,12 +45527,11 @@ class Client extends openapi_client_1.default {
|
|
|
44185
45527
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteIpv6GatewayResponse({}));
|
|
44186
45528
|
}
|
|
44187
45529
|
/**
|
|
44188
|
-
* - The **DeleteIpv6Gateway** operation is asynchronous. After you send the request, the system returns a request ID. However, the operation is still being performed in the system background. You can call the [DescribeIpv6GatewayAttribute](/help/en/virtual-private-cloud/latest/describeipv6gatewayattribute) operation to query the status of an IPv6 gateway:
|
|
44189
|
-
* - If the IPv6 gateway is in the **Deleting** state, the IPv6 gateway is being deleted.
|
|
44190
|
-
* - If you cannot query the IPv6 gateway, the IPv6 gateway is deleted.
|
|
44191
|
-
* - After you call the **DeleteIpv6Gateway** operation to delete an IPv6 gateway, you cannot call the operation again to delete the IPv6 gateway until the deletion task is complete.
|
|
44192
|
-
* ## Prerequisites
|
|
44193
45530
|
* Before you delete an IPv6 gateway, you must delete the egress-only rules of the IPv6 gateway. For more information, see [DeleteIpv6EgressOnlyRule](~~102201~~).
|
|
45531
|
+
* * **DeleteIpv6Gateway** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeIpv6GatewayAttribute](~~102226~~) operation to query the status of the task:
|
|
45532
|
+
* * If the IPv6 gateway is in the **Deleting** state, the IPv6 gateway is being deleted.
|
|
45533
|
+
* * If you cannot query the IPv6 gateway, the IPv6 gateway is deleted.
|
|
45534
|
+
* * You cannot repeatedly call the **DeleteIpv6Gateway** operation to delete an IPv6 gateway within the specified period of time.
|
|
44194
45535
|
*
|
|
44195
45536
|
* @param request DeleteIpv6GatewayRequest
|
|
44196
45537
|
* @return DeleteIpv6GatewayResponse
|
|
@@ -44260,9 +45601,10 @@ class Client extends openapi_client_1.default {
|
|
|
44260
45601
|
return await this.deleteIpv6InternetBandwidthWithOptions(request, runtime);
|
|
44261
45602
|
}
|
|
44262
45603
|
/**
|
|
44263
|
-
*
|
|
45604
|
+
* ## [](#)Description
|
|
45605
|
+
* * **DeleteNatGateway** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeNatGateways](~~36054~~) to query the status of the task.
|
|
44264
45606
|
* * If a NAT gateway is in the **Deleting** state, the NAT gateway is being deleted. In this case, you can query the NAT gateway but you cannot perform other operations.
|
|
44265
|
-
* * If the
|
|
45607
|
+
* * If the NAT gateway cannot be found, the NAT gateway is deleted.
|
|
44266
45608
|
* After you delete a NAT gateway, you cannot restore the NAT gateway. Proceed with caution.
|
|
44267
45609
|
* * You cannot repeatedly call the **DeleteNatGateway** operation to delete a NAT gateway within the specified period of time.
|
|
44268
45610
|
*
|
|
@@ -44311,9 +45653,10 @@ class Client extends openapi_client_1.default {
|
|
|
44311
45653
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteNatGatewayResponse({}));
|
|
44312
45654
|
}
|
|
44313
45655
|
/**
|
|
44314
|
-
*
|
|
45656
|
+
* ## [](#)Description
|
|
45657
|
+
* * **DeleteNatGateway** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeNatGateways](~~36054~~) to query the status of the task.
|
|
44315
45658
|
* * If a NAT gateway is in the **Deleting** state, the NAT gateway is being deleted. In this case, you can query the NAT gateway but you cannot perform other operations.
|
|
44316
|
-
* * If the
|
|
45659
|
+
* * If the NAT gateway cannot be found, the NAT gateway is deleted.
|
|
44317
45660
|
* After you delete a NAT gateway, you cannot restore the NAT gateway. Proceed with caution.
|
|
44318
45661
|
* * You cannot repeatedly call the **DeleteNatGateway** operation to delete a NAT gateway within the specified period of time.
|
|
44319
45662
|
*
|
|
@@ -44325,8 +45668,9 @@ class Client extends openapi_client_1.default {
|
|
|
44325
45668
|
return await this.deleteNatGatewayWithOptions(request, runtime);
|
|
44326
45669
|
}
|
|
44327
45670
|
/**
|
|
44328
|
-
*
|
|
44329
|
-
*
|
|
45671
|
+
* ## [](#)Description
|
|
45672
|
+
* * **DeleteNatIp** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [ListNatIps](~~281979~~) operation to query the status of the task.
|
|
45673
|
+
* * If the NAT IP address is in the **Deleting** state, the NAT IP address is being deleted. In this case, you can only query the NAT IP address but cannot perform other operations.
|
|
44330
45674
|
* * If the NAT IP address cannot be found, it is deleted.
|
|
44331
45675
|
* * You cannot repeatedly call the **DeleteNatIp** operation to delete a NAT IP address within the specified period of time.
|
|
44332
45676
|
*
|
|
@@ -44381,8 +45725,9 @@ class Client extends openapi_client_1.default {
|
|
|
44381
45725
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteNatIpResponse({}));
|
|
44382
45726
|
}
|
|
44383
45727
|
/**
|
|
44384
|
-
*
|
|
44385
|
-
*
|
|
45728
|
+
* ## [](#)Description
|
|
45729
|
+
* * **DeleteNatIp** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [ListNatIps](~~281979~~) operation to query the status of the task.
|
|
45730
|
+
* * If the NAT IP address is in the **Deleting** state, the NAT IP address is being deleted. In this case, you can only query the NAT IP address but cannot perform other operations.
|
|
44386
45731
|
* * If the NAT IP address cannot be found, it is deleted.
|
|
44387
45732
|
* * You cannot repeatedly call the **DeleteNatIp** operation to delete a NAT IP address within the specified period of time.
|
|
44388
45733
|
*
|
|
@@ -44394,6 +45739,7 @@ class Client extends openapi_client_1.default {
|
|
|
44394
45739
|
return await this.deleteNatIpWithOptions(request, runtime);
|
|
44395
45740
|
}
|
|
44396
45741
|
/**
|
|
45742
|
+
* ## [](#)Description
|
|
44397
45743
|
* You cannot repeatedly call the **DeleteNatIpCidr** operation to delete a NAT CIDR block within the specified period of time.
|
|
44398
45744
|
*
|
|
44399
45745
|
* @param request DeleteNatIpCidrRequest
|
|
@@ -44450,6 +45796,7 @@ class Client extends openapi_client_1.default {
|
|
|
44450
45796
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteNatIpCidrResponse({}));
|
|
44451
45797
|
}
|
|
44452
45798
|
/**
|
|
45799
|
+
* ## [](#)Description
|
|
44453
45800
|
* You cannot repeatedly call the **DeleteNatIpCidr** operation to delete a NAT CIDR block within the specified period of time.
|
|
44454
45801
|
*
|
|
44455
45802
|
* @param request DeleteNatIpCidrRequest
|
|
@@ -44472,9 +45819,15 @@ class Client extends openapi_client_1.default {
|
|
|
44472
45819
|
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
44473
45820
|
query["ClientToken"] = request.clientToken;
|
|
44474
45821
|
}
|
|
45822
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
45823
|
+
query["DryRun"] = request.dryRun;
|
|
45824
|
+
}
|
|
44475
45825
|
if (!tea_util_1.default.isUnset(request.networkAclId)) {
|
|
44476
45826
|
query["NetworkAclId"] = request.networkAclId;
|
|
44477
45827
|
}
|
|
45828
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
45829
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
45830
|
+
}
|
|
44478
45831
|
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
44479
45832
|
query["OwnerId"] = request.ownerId;
|
|
44480
45833
|
}
|
|
@@ -44517,7 +45870,6 @@ class Client extends openapi_client_1.default {
|
|
|
44517
45870
|
return await this.deleteNetworkAclWithOptions(request, runtime);
|
|
44518
45871
|
}
|
|
44519
45872
|
/**
|
|
44520
|
-
* ## Limit
|
|
44521
45873
|
* You can only delete a connection over an Express Connect circuit that is in the **Rejected**, **Canceled**, **AllocationFailed**, or **Terminated** state.
|
|
44522
45874
|
*
|
|
44523
45875
|
* @param request DeletePhysicalConnectionRequest
|
|
@@ -44565,7 +45917,6 @@ class Client extends openapi_client_1.default {
|
|
|
44565
45917
|
return $tea.cast(await this.callApi(params, req, runtime), new DeletePhysicalConnectionResponse({}));
|
|
44566
45918
|
}
|
|
44567
45919
|
/**
|
|
44568
|
-
* ## Limit
|
|
44569
45920
|
* You can only delete a connection over an Express Connect circuit that is in the **Rejected**, **Canceled**, **AllocationFailed**, or **Terminated** state.
|
|
44570
45921
|
*
|
|
44571
45922
|
* @param request DeletePhysicalConnectionRequest
|
|
@@ -44868,7 +46219,8 @@ class Client extends openapi_client_1.default {
|
|
|
44868
46219
|
return await this.deleteRouteEntryWithOptions(request, runtime);
|
|
44869
46220
|
}
|
|
44870
46221
|
/**
|
|
44871
|
-
*
|
|
46222
|
+
* ## [](#)Description
|
|
46223
|
+
* * **DeleteRouteTable** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeRouteTableList](~~87602~~) operation to query the status of the task.
|
|
44872
46224
|
* * If the custom route table is in the **Deleting** state, the custom route table is being deleted.
|
|
44873
46225
|
* * If you cannot query the custom route table, the custom route table is deleted.
|
|
44874
46226
|
* * You cannot repeatedly call the **DeleteRouteTable** operation to delete a custom route table within the specified period of time.
|
|
@@ -44918,7 +46270,8 @@ class Client extends openapi_client_1.default {
|
|
|
44918
46270
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteRouteTableResponse({}));
|
|
44919
46271
|
}
|
|
44920
46272
|
/**
|
|
44921
|
-
*
|
|
46273
|
+
* ## [](#)Description
|
|
46274
|
+
* * **DeleteRouteTable** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeRouteTableList](~~87602~~) operation to query the status of the task.
|
|
44922
46275
|
* * If the custom route table is in the **Deleting** state, the custom route table is being deleted.
|
|
44923
46276
|
* * If you cannot query the custom route table, the custom route table is deleted.
|
|
44924
46277
|
* * You cannot repeatedly call the **DeleteRouteTable** operation to delete a custom route table within the specified period of time.
|
|
@@ -45452,6 +46805,17 @@ class Client extends openapi_client_1.default {
|
|
|
45452
46805
|
let runtime = new $Util.RuntimeOptions({});
|
|
45453
46806
|
return await this.deleteVSwitchWithOptions(request, runtime);
|
|
45454
46807
|
}
|
|
46808
|
+
/**
|
|
46809
|
+
* ## [](#)Description
|
|
46810
|
+
* * Before you call this operation, make sure that the IP address allocated to an elastic network interface (ENI) from the reserved CIDR block is deleted. If the IP address of the ENI is not deleted, call [UnassignPrivateIpAddresses](~~85919~~) or [UnassignIpv6Addresses](~~98611~~) to delete the IPv4 or IPv6 address.
|
|
46811
|
+
* * **DeleteVSwitchCidrReservation** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call [ListVSwitchCidrReservations](~~610155~~) to query the status of the task:
|
|
46812
|
+
* * If the reserved CIDR block is in the **Releasing** state, it is being released.
|
|
46813
|
+
* * If the reserved CIDR block is in the **Released** state, it is released.
|
|
46814
|
+
*
|
|
46815
|
+
* @param request DeleteVSwitchCidrReservationRequest
|
|
46816
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
46817
|
+
* @return DeleteVSwitchCidrReservationResponse
|
|
46818
|
+
*/
|
|
45455
46819
|
async deleteVSwitchCidrReservationWithOptions(request, runtime) {
|
|
45456
46820
|
tea_util_1.default.validateModel(request);
|
|
45457
46821
|
let query = {};
|
|
@@ -45489,6 +46853,16 @@ class Client extends openapi_client_1.default {
|
|
|
45489
46853
|
});
|
|
45490
46854
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteVSwitchCidrReservationResponse({}));
|
|
45491
46855
|
}
|
|
46856
|
+
/**
|
|
46857
|
+
* ## [](#)Description
|
|
46858
|
+
* * Before you call this operation, make sure that the IP address allocated to an elastic network interface (ENI) from the reserved CIDR block is deleted. If the IP address of the ENI is not deleted, call [UnassignPrivateIpAddresses](~~85919~~) or [UnassignIpv6Addresses](~~98611~~) to delete the IPv4 or IPv6 address.
|
|
46859
|
+
* * **DeleteVSwitchCidrReservation** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call [ListVSwitchCidrReservations](~~610155~~) to query the status of the task:
|
|
46860
|
+
* * If the reserved CIDR block is in the **Releasing** state, it is being released.
|
|
46861
|
+
* * If the reserved CIDR block is in the **Released** state, it is released.
|
|
46862
|
+
*
|
|
46863
|
+
* @param request DeleteVSwitchCidrReservationRequest
|
|
46864
|
+
* @return DeleteVSwitchCidrReservationResponse
|
|
46865
|
+
*/
|
|
45492
46866
|
async deleteVSwitchCidrReservation(request) {
|
|
45493
46867
|
let runtime = new $Util.RuntimeOptions({});
|
|
45494
46868
|
return await this.deleteVSwitchCidrReservationWithOptions(request, runtime);
|
|
@@ -45610,11 +46984,10 @@ class Client extends openapi_client_1.default {
|
|
|
45610
46984
|
return await this.deleteVcoRouteEntryWithOptions(request, runtime);
|
|
45611
46985
|
}
|
|
45612
46986
|
/**
|
|
45613
|
-
* ## Limits
|
|
45614
46987
|
* Before you call this operation, take note of the following limits:
|
|
45615
46988
|
* * Before you delete a VBR, you must delete all router interfaces of the VBR.
|
|
45616
|
-
* * You can delete only a VBR
|
|
45617
|
-
* * If the
|
|
46989
|
+
* * You can delete only a VBR in the **unconfirmed**, **active**, or **terminated** state.
|
|
46990
|
+
* * If the VBR belongs to another Alibaba Cloud account, you can delete the VBR only if it is in the **unconfirmed** state.
|
|
45618
46991
|
*
|
|
45619
46992
|
* @param request DeleteVirtualBorderRouterRequest
|
|
45620
46993
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -45661,11 +47034,10 @@ class Client extends openapi_client_1.default {
|
|
|
45661
47034
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteVirtualBorderRouterResponse({}));
|
|
45662
47035
|
}
|
|
45663
47036
|
/**
|
|
45664
|
-
* ## Limits
|
|
45665
47037
|
* Before you call this operation, take note of the following limits:
|
|
45666
47038
|
* * Before you delete a VBR, you must delete all router interfaces of the VBR.
|
|
45667
|
-
* * You can delete only a VBR
|
|
45668
|
-
* * If the
|
|
47039
|
+
* * You can delete only a VBR in the **unconfirmed**, **active**, or **terminated** state.
|
|
47040
|
+
* * If the VBR belongs to another Alibaba Cloud account, you can delete the VBR only if it is in the **unconfirmed** state.
|
|
45669
47041
|
*
|
|
45670
47042
|
* @param request DeleteVirtualBorderRouterRequest
|
|
45671
47043
|
* @return DeleteVirtualBorderRouterResponse
|
|
@@ -45975,7 +47347,7 @@ class Client extends openapi_client_1.default {
|
|
|
45975
47347
|
return await this.deleteVpnConnectionWithOptions(request, runtime);
|
|
45976
47348
|
}
|
|
45977
47349
|
/**
|
|
45978
|
-
* > You cannot delete a VPN gateway
|
|
47350
|
+
* > You cannot delete a VPN gateway associated with existing IPsec-VPN connections.
|
|
45979
47351
|
*
|
|
45980
47352
|
* @param request DeleteVpnGatewayRequest
|
|
45981
47353
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -46022,7 +47394,7 @@ class Client extends openapi_client_1.default {
|
|
|
46022
47394
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteVpnGatewayResponse({}));
|
|
46023
47395
|
}
|
|
46024
47396
|
/**
|
|
46025
|
-
* > You cannot delete a VPN gateway
|
|
47397
|
+
* > You cannot delete a VPN gateway associated with existing IPsec-VPN connections.
|
|
46026
47398
|
*
|
|
46027
47399
|
* @param request DeleteVpnGatewayRequest
|
|
46028
47400
|
* @return DeleteVpnGatewayResponse
|
|
@@ -46925,6 +48297,100 @@ class Client extends openapi_client_1.default {
|
|
|
46925
48297
|
let runtime = new $Util.RuntimeOptions({});
|
|
46926
48298
|
return await this.describeEipSegmentWithOptions(request, runtime);
|
|
46927
48299
|
}
|
|
48300
|
+
async describeFailoverTestJobWithOptions(request, runtime) {
|
|
48301
|
+
tea_util_1.default.validateModel(request);
|
|
48302
|
+
let query = {};
|
|
48303
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
48304
|
+
query["ClientToken"] = request.clientToken;
|
|
48305
|
+
}
|
|
48306
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
48307
|
+
query["ClientToken"] = request.clientToken;
|
|
48308
|
+
}
|
|
48309
|
+
if (!tea_util_1.default.isUnset(request.jobId)) {
|
|
48310
|
+
query["JobId"] = request.jobId;
|
|
48311
|
+
}
|
|
48312
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
48313
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
48314
|
+
}
|
|
48315
|
+
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
48316
|
+
query["OwnerId"] = request.ownerId;
|
|
48317
|
+
}
|
|
48318
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
48319
|
+
query["RegionId"] = request.regionId;
|
|
48320
|
+
}
|
|
48321
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
48322
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
48323
|
+
}
|
|
48324
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
48325
|
+
query: openapi_util_1.default.query(query),
|
|
48326
|
+
});
|
|
48327
|
+
let params = new $OpenApi.Params({
|
|
48328
|
+
action: "DescribeFailoverTestJob",
|
|
48329
|
+
version: "2016-04-28",
|
|
48330
|
+
protocol: "HTTPS",
|
|
48331
|
+
pathname: "/",
|
|
48332
|
+
method: "POST",
|
|
48333
|
+
authType: "AK",
|
|
48334
|
+
style: "RPC",
|
|
48335
|
+
reqBodyType: "formData",
|
|
48336
|
+
bodyType: "json",
|
|
48337
|
+
});
|
|
48338
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DescribeFailoverTestJobResponse({}));
|
|
48339
|
+
}
|
|
48340
|
+
async describeFailoverTestJob(request) {
|
|
48341
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
48342
|
+
return await this.describeFailoverTestJobWithOptions(request, runtime);
|
|
48343
|
+
}
|
|
48344
|
+
async describeFailoverTestJobsWithOptions(request, runtime) {
|
|
48345
|
+
tea_util_1.default.validateModel(request);
|
|
48346
|
+
let query = {};
|
|
48347
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
48348
|
+
query["ClientToken"] = request.clientToken;
|
|
48349
|
+
}
|
|
48350
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
48351
|
+
query["ClientToken"] = request.clientToken;
|
|
48352
|
+
}
|
|
48353
|
+
if (!tea_util_1.default.isUnset(request.filter)) {
|
|
48354
|
+
query["Filter"] = request.filter;
|
|
48355
|
+
}
|
|
48356
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
48357
|
+
query["MaxResults"] = request.maxResults;
|
|
48358
|
+
}
|
|
48359
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
48360
|
+
query["NextToken"] = request.nextToken;
|
|
48361
|
+
}
|
|
48362
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
48363
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
48364
|
+
}
|
|
48365
|
+
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
48366
|
+
query["OwnerId"] = request.ownerId;
|
|
48367
|
+
}
|
|
48368
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
48369
|
+
query["RegionId"] = request.regionId;
|
|
48370
|
+
}
|
|
48371
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
48372
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
48373
|
+
}
|
|
48374
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
48375
|
+
query: openapi_util_1.default.query(query),
|
|
48376
|
+
});
|
|
48377
|
+
let params = new $OpenApi.Params({
|
|
48378
|
+
action: "DescribeFailoverTestJobs",
|
|
48379
|
+
version: "2016-04-28",
|
|
48380
|
+
protocol: "HTTPS",
|
|
48381
|
+
pathname: "/",
|
|
48382
|
+
method: "POST",
|
|
48383
|
+
authType: "AK",
|
|
48384
|
+
style: "RPC",
|
|
48385
|
+
reqBodyType: "formData",
|
|
48386
|
+
bodyType: "json",
|
|
48387
|
+
});
|
|
48388
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DescribeFailoverTestJobsResponse({}));
|
|
48389
|
+
}
|
|
48390
|
+
async describeFailoverTestJobs(request) {
|
|
48391
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
48392
|
+
return await this.describeFailoverTestJobsWithOptions(request, runtime);
|
|
48393
|
+
}
|
|
46928
48394
|
async describeFlowLogsWithOptions(request, runtime) {
|
|
46929
48395
|
tea_util_1.default.validateModel(request);
|
|
46930
48396
|
let query = {};
|
|
@@ -47940,6 +49406,9 @@ class Client extends openapi_client_1.default {
|
|
|
47940
49406
|
if (!tea_util_1.default.isUnset(request.networkAclId)) {
|
|
47941
49407
|
query["NetworkAclId"] = request.networkAclId;
|
|
47942
49408
|
}
|
|
49409
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
49410
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
49411
|
+
}
|
|
47943
49412
|
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
47944
49413
|
query["OwnerId"] = request.ownerId;
|
|
47945
49414
|
}
|
|
@@ -47987,6 +49456,9 @@ class Client extends openapi_client_1.default {
|
|
|
47987
49456
|
if (!tea_util_1.default.isUnset(request.networkAclName)) {
|
|
47988
49457
|
query["NetworkAclName"] = request.networkAclName;
|
|
47989
49458
|
}
|
|
49459
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
49460
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
49461
|
+
}
|
|
47990
49462
|
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
47991
49463
|
query["OwnerId"] = request.ownerId;
|
|
47992
49464
|
}
|
|
@@ -48258,6 +49730,7 @@ class Client extends openapi_client_1.default {
|
|
|
48258
49730
|
return await this.describeRegionsWithOptions(request, runtime);
|
|
48259
49731
|
}
|
|
48260
49732
|
/**
|
|
49733
|
+
* ## [](#)References
|
|
48261
49734
|
* Before you call the [DeleteRouteEntry](~~36013~~) operation to delete a route, you can call this operation to query the next hop of the route that you want to delete.
|
|
48262
49735
|
*
|
|
48263
49736
|
* @param request DescribeRouteEntryListRequest
|
|
@@ -48338,6 +49811,7 @@ class Client extends openapi_client_1.default {
|
|
|
48338
49811
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeRouteEntryListResponse({}));
|
|
48339
49812
|
}
|
|
48340
49813
|
/**
|
|
49814
|
+
* ## [](#)References
|
|
48341
49815
|
* Before you call the [DeleteRouteEntry](~~36013~~) operation to delete a route, you can call this operation to query the next hop of the route that you want to delete.
|
|
48342
49816
|
*
|
|
48343
49817
|
* @param request DescribeRouteEntryListRequest
|
|
@@ -50129,7 +51603,8 @@ class Client extends openapi_client_1.default {
|
|
|
50129
51603
|
return await this.describeZonesWithOptions(request, runtime);
|
|
50130
51604
|
}
|
|
50131
51605
|
/**
|
|
50132
|
-
*
|
|
51606
|
+
* ## [](#)Description
|
|
51607
|
+
* * **DetachDhcpOptionsSetFromVpc** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeVpcAttribute](~~94565~~) operation to query the status of the task.
|
|
50133
51608
|
* * If the DHCP options set is in the **Pending** state, the DHCP options set is being disassociated.
|
|
50134
51609
|
* * If the DHCP options set is in the **UnUsed** state, the DHCP options set is disassociated.
|
|
50135
51610
|
* * You cannot repeatedly call the **DetachDhcpOptionsSetFromVpc** operation to disassociate a DHCP options set from a VPC within the specified period of time.
|
|
@@ -50185,7 +51660,8 @@ class Client extends openapi_client_1.default {
|
|
|
50185
51660
|
return $tea.cast(await this.callApi(params, req, runtime), new DetachDhcpOptionsSetFromVpcResponse({}));
|
|
50186
51661
|
}
|
|
50187
51662
|
/**
|
|
50188
|
-
*
|
|
51663
|
+
* ## [](#)Description
|
|
51664
|
+
* * **DetachDhcpOptionsSetFromVpc** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeVpcAttribute](~~94565~~) operation to query the status of the task.
|
|
50189
51665
|
* * If the DHCP options set is in the **Pending** state, the DHCP options set is being disassociated.
|
|
50190
51666
|
* * If the DHCP options set is in the **UnUsed** state, the DHCP options set is disassociated.
|
|
50191
51667
|
* * You cannot repeatedly call the **DetachDhcpOptionsSetFromVpc** operation to disassociate a DHCP options set from a VPC within the specified period of time.
|
|
@@ -50575,7 +52051,9 @@ class Client extends openapi_client_1.default {
|
|
|
50575
52051
|
/**
|
|
50576
52052
|
* When you call this operation, take note of the following limits:
|
|
50577
52053
|
* * You can enable only an Express Connect circuit that is in the **Confirmed** state.
|
|
50578
|
-
* * After you enable an Express Connect circuit, it
|
|
52054
|
+
* * After you enable an Express Connect circuit, it enters the **Enabled** state.
|
|
52055
|
+
* * **EnablePhysicalConnection** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribePhysicalConnections](~~36042~~) operation to query the status of the task.
|
|
52056
|
+
* * You cannot repeatedly call **EnablePhysicalConnection** for an Express Connect circuit in the **Confirmed** state within a specific time period.
|
|
50579
52057
|
*
|
|
50580
52058
|
* @param request EnablePhysicalConnectionRequest
|
|
50581
52059
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -50627,7 +52105,9 @@ class Client extends openapi_client_1.default {
|
|
|
50627
52105
|
/**
|
|
50628
52106
|
* When you call this operation, take note of the following limits:
|
|
50629
52107
|
* * You can enable only an Express Connect circuit that is in the **Confirmed** state.
|
|
50630
|
-
* * After you enable an Express Connect circuit, it
|
|
52108
|
+
* * After you enable an Express Connect circuit, it enters the **Enabled** state.
|
|
52109
|
+
* * **EnablePhysicalConnection** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribePhysicalConnections](~~36042~~) operation to query the status of the task.
|
|
52110
|
+
* * You cannot repeatedly call **EnablePhysicalConnection** for an Express Connect circuit in the **Confirmed** state within a specific time period.
|
|
50631
52111
|
*
|
|
50632
52112
|
* @param request EnablePhysicalConnectionRequest
|
|
50633
52113
|
* @return EnablePhysicalConnectionResponse
|
|
@@ -50681,7 +52161,8 @@ class Client extends openapi_client_1.default {
|
|
|
50681
52161
|
return await this.enableVpcClassicLinkWithOptions(request, runtime);
|
|
50682
52162
|
}
|
|
50683
52163
|
/**
|
|
50684
|
-
*
|
|
52164
|
+
* ## [](#)Description
|
|
52165
|
+
* * **EnableVpcIpv4Gateway** is an asynchronous operation. After a request is sent, the system returns a **request ID** and runs the task in the background. You can call the [GetIpv4GatewayAttribute](~~407670~~) operation to query the status of an IPv4 gateway.
|
|
50685
52166
|
* * If the IPv4 gateway is in the **Activating** state, the IPv4 gateway is being activated.
|
|
50686
52167
|
* * If the IPv4 gateway is in the **Created** state, the IPv4 gateway is activated.
|
|
50687
52168
|
* * You cannot repeatedly call the **EnableVpcIpv4Gateway** operation to activate an IPv4 gateway within the specified period of time.
|
|
@@ -50740,7 +52221,8 @@ class Client extends openapi_client_1.default {
|
|
|
50740
52221
|
return $tea.cast(await this.callApi(params, req, runtime), new EnableVpcIpv4GatewayResponse({}));
|
|
50741
52222
|
}
|
|
50742
52223
|
/**
|
|
50743
|
-
*
|
|
52224
|
+
* ## [](#)Description
|
|
52225
|
+
* * **EnableVpcIpv4Gateway** is an asynchronous operation. After a request is sent, the system returns a **request ID** and runs the task in the background. You can call the [GetIpv4GatewayAttribute](~~407670~~) operation to query the status of an IPv4 gateway.
|
|
50744
52226
|
* * If the IPv4 gateway is in the **Activating** state, the IPv4 gateway is being activated.
|
|
50745
52227
|
* * If the IPv4 gateway is in the **Created** state, the IPv4 gateway is activated.
|
|
50746
52228
|
* * You cannot repeatedly call the **EnableVpcIpv4Gateway** operation to activate an IPv4 gateway within the specified period of time.
|
|
@@ -50916,7 +52398,108 @@ class Client extends openapi_client_1.default {
|
|
|
50916
52398
|
query: openapi_util_1.default.query(query),
|
|
50917
52399
|
});
|
|
50918
52400
|
let params = new $OpenApi.Params({
|
|
50919
|
-
action: "GetNatGatewayAttribute",
|
|
52401
|
+
action: "GetNatGatewayAttribute",
|
|
52402
|
+
version: "2016-04-28",
|
|
52403
|
+
protocol: "HTTPS",
|
|
52404
|
+
pathname: "/",
|
|
52405
|
+
method: "POST",
|
|
52406
|
+
authType: "AK",
|
|
52407
|
+
style: "RPC",
|
|
52408
|
+
reqBodyType: "formData",
|
|
52409
|
+
bodyType: "json",
|
|
52410
|
+
});
|
|
52411
|
+
return $tea.cast(await this.callApi(params, req, runtime), new GetNatGatewayAttributeResponse({}));
|
|
52412
|
+
}
|
|
52413
|
+
/**
|
|
52414
|
+
* You can call this operation to query information about a specified Internet NAT gateway or Virtual Private Cloud (VPC) NAT gateway. In this topic, "NAT gateway" refers to both gateway types.
|
|
52415
|
+
*
|
|
52416
|
+
* @param request GetNatGatewayAttributeRequest
|
|
52417
|
+
* @return GetNatGatewayAttributeResponse
|
|
52418
|
+
*/
|
|
52419
|
+
async getNatGatewayAttribute(request) {
|
|
52420
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
52421
|
+
return await this.getNatGatewayAttributeWithOptions(request, runtime);
|
|
52422
|
+
}
|
|
52423
|
+
/**
|
|
52424
|
+
* You can call this API operation to query the status of outbound data transfer billing for the current account. For more information about outbound data transfer billing, see [Outbound data transfer billing](~~274385~~) and [Billing](~~54582~~).
|
|
52425
|
+
*
|
|
52426
|
+
* @param request GetPhysicalConnectionServiceStatusRequest
|
|
52427
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
52428
|
+
* @return GetPhysicalConnectionServiceStatusResponse
|
|
52429
|
+
*/
|
|
52430
|
+
async getPhysicalConnectionServiceStatusWithOptions(request, runtime) {
|
|
52431
|
+
tea_util_1.default.validateModel(request);
|
|
52432
|
+
let query = {};
|
|
52433
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
52434
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
52435
|
+
}
|
|
52436
|
+
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
52437
|
+
query["OwnerId"] = request.ownerId;
|
|
52438
|
+
}
|
|
52439
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
52440
|
+
query["RegionId"] = request.regionId;
|
|
52441
|
+
}
|
|
52442
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
52443
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
52444
|
+
}
|
|
52445
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerId)) {
|
|
52446
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
52447
|
+
}
|
|
52448
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
52449
|
+
query: openapi_util_1.default.query(query),
|
|
52450
|
+
});
|
|
52451
|
+
let params = new $OpenApi.Params({
|
|
52452
|
+
action: "GetPhysicalConnectionServiceStatus",
|
|
52453
|
+
version: "2016-04-28",
|
|
52454
|
+
protocol: "HTTPS",
|
|
52455
|
+
pathname: "/",
|
|
52456
|
+
method: "POST",
|
|
52457
|
+
authType: "AK",
|
|
52458
|
+
style: "RPC",
|
|
52459
|
+
reqBodyType: "formData",
|
|
52460
|
+
bodyType: "json",
|
|
52461
|
+
});
|
|
52462
|
+
return $tea.cast(await this.callApi(params, req, runtime), new GetPhysicalConnectionServiceStatusResponse({}));
|
|
52463
|
+
}
|
|
52464
|
+
/**
|
|
52465
|
+
* You can call this API operation to query the status of outbound data transfer billing for the current account. For more information about outbound data transfer billing, see [Outbound data transfer billing](~~274385~~) and [Billing](~~54582~~).
|
|
52466
|
+
*
|
|
52467
|
+
* @param request GetPhysicalConnectionServiceStatusRequest
|
|
52468
|
+
* @return GetPhysicalConnectionServiceStatusResponse
|
|
52469
|
+
*/
|
|
52470
|
+
async getPhysicalConnectionServiceStatus(request) {
|
|
52471
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
52472
|
+
return await this.getPhysicalConnectionServiceStatusWithOptions(request, runtime);
|
|
52473
|
+
}
|
|
52474
|
+
async getTrafficMirrorServiceStatusWithOptions(request, runtime) {
|
|
52475
|
+
tea_util_1.default.validateModel(request);
|
|
52476
|
+
let query = {};
|
|
52477
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
52478
|
+
query["ClientToken"] = request.clientToken;
|
|
52479
|
+
}
|
|
52480
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
52481
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
52482
|
+
}
|
|
52483
|
+
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
52484
|
+
query["OwnerId"] = request.ownerId;
|
|
52485
|
+
}
|
|
52486
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
52487
|
+
query["RegionId"] = request.regionId;
|
|
52488
|
+
}
|
|
52489
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
52490
|
+
query["RegionId"] = request.regionId;
|
|
52491
|
+
}
|
|
52492
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
52493
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
52494
|
+
}
|
|
52495
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerId)) {
|
|
52496
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
52497
|
+
}
|
|
52498
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
52499
|
+
query: openapi_util_1.default.query(query),
|
|
52500
|
+
});
|
|
52501
|
+
let params = new $OpenApi.Params({
|
|
52502
|
+
action: "GetTrafficMirrorServiceStatus",
|
|
50920
52503
|
version: "2016-04-28",
|
|
50921
52504
|
protocol: "HTTPS",
|
|
50922
52505
|
pathname: "/",
|
|
@@ -50926,74 +52509,20 @@ class Client extends openapi_client_1.default {
|
|
|
50926
52509
|
reqBodyType: "formData",
|
|
50927
52510
|
bodyType: "json",
|
|
50928
52511
|
});
|
|
50929
|
-
return $tea.cast(await this.callApi(params, req, runtime), new
|
|
52512
|
+
return $tea.cast(await this.callApi(params, req, runtime), new GetTrafficMirrorServiceStatusResponse({}));
|
|
50930
52513
|
}
|
|
50931
|
-
|
|
50932
|
-
* You can call this operation to query information about a specified Internet NAT gateway or Virtual Private Cloud (VPC) NAT gateway. In this topic, "NAT gateway" refers to both gateway types.
|
|
50933
|
-
*
|
|
50934
|
-
* @param request GetNatGatewayAttributeRequest
|
|
50935
|
-
* @return GetNatGatewayAttributeResponse
|
|
50936
|
-
*/
|
|
50937
|
-
async getNatGatewayAttribute(request) {
|
|
52514
|
+
async getTrafficMirrorServiceStatus(request) {
|
|
50938
52515
|
let runtime = new $Util.RuntimeOptions({});
|
|
50939
|
-
return await this.
|
|
52516
|
+
return await this.getTrafficMirrorServiceStatusWithOptions(request, runtime);
|
|
50940
52517
|
}
|
|
50941
|
-
|
|
50942
|
-
* You can call this API operation to query the status of outbound data transfer billing for the current account. For more information about outbound data transfer billing, see [Outbound data transfer billing](~~274385~~) and [Billing](~~54582~~).
|
|
50943
|
-
*
|
|
50944
|
-
* @param request GetPhysicalConnectionServiceStatusRequest
|
|
50945
|
-
* @param runtime runtime options for this request RuntimeOptions
|
|
50946
|
-
* @return GetPhysicalConnectionServiceStatusResponse
|
|
50947
|
-
*/
|
|
50948
|
-
async getPhysicalConnectionServiceStatusWithOptions(request, runtime) {
|
|
52518
|
+
async getVSwitchCidrReservationUsageWithOptions(request, runtime) {
|
|
50949
52519
|
tea_util_1.default.validateModel(request);
|
|
50950
52520
|
let query = {};
|
|
50951
|
-
if (!tea_util_1.default.isUnset(request.
|
|
50952
|
-
query["
|
|
50953
|
-
}
|
|
50954
|
-
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
50955
|
-
query["OwnerId"] = request.ownerId;
|
|
50956
|
-
}
|
|
50957
|
-
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
50958
|
-
query["RegionId"] = request.regionId;
|
|
50959
|
-
}
|
|
50960
|
-
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
50961
|
-
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
50962
|
-
}
|
|
50963
|
-
if (!tea_util_1.default.isUnset(request.resourceOwnerId)) {
|
|
50964
|
-
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
52521
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
52522
|
+
query["MaxResults"] = request.maxResults;
|
|
50965
52523
|
}
|
|
50966
|
-
|
|
50967
|
-
query
|
|
50968
|
-
});
|
|
50969
|
-
let params = new $OpenApi.Params({
|
|
50970
|
-
action: "GetPhysicalConnectionServiceStatus",
|
|
50971
|
-
version: "2016-04-28",
|
|
50972
|
-
protocol: "HTTPS",
|
|
50973
|
-
pathname: "/",
|
|
50974
|
-
method: "POST",
|
|
50975
|
-
authType: "AK",
|
|
50976
|
-
style: "RPC",
|
|
50977
|
-
reqBodyType: "formData",
|
|
50978
|
-
bodyType: "json",
|
|
50979
|
-
});
|
|
50980
|
-
return $tea.cast(await this.callApi(params, req, runtime), new GetPhysicalConnectionServiceStatusResponse({}));
|
|
50981
|
-
}
|
|
50982
|
-
/**
|
|
50983
|
-
* You can call this API operation to query the status of outbound data transfer billing for the current account. For more information about outbound data transfer billing, see [Outbound data transfer billing](~~274385~~) and [Billing](~~54582~~).
|
|
50984
|
-
*
|
|
50985
|
-
* @param request GetPhysicalConnectionServiceStatusRequest
|
|
50986
|
-
* @return GetPhysicalConnectionServiceStatusResponse
|
|
50987
|
-
*/
|
|
50988
|
-
async getPhysicalConnectionServiceStatus(request) {
|
|
50989
|
-
let runtime = new $Util.RuntimeOptions({});
|
|
50990
|
-
return await this.getPhysicalConnectionServiceStatusWithOptions(request, runtime);
|
|
50991
|
-
}
|
|
50992
|
-
async getTrafficMirrorServiceStatusWithOptions(request, runtime) {
|
|
50993
|
-
tea_util_1.default.validateModel(request);
|
|
50994
|
-
let query = {};
|
|
50995
|
-
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
50996
|
-
query["ClientToken"] = request.clientToken;
|
|
52524
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
52525
|
+
query["NextToken"] = request.nextToken;
|
|
50997
52526
|
}
|
|
50998
52527
|
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
50999
52528
|
query["OwnerAccount"] = request.ownerAccount;
|
|
@@ -51004,20 +52533,20 @@ class Client extends openapi_client_1.default {
|
|
|
51004
52533
|
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
51005
52534
|
query["RegionId"] = request.regionId;
|
|
51006
52535
|
}
|
|
51007
|
-
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
51008
|
-
query["RegionId"] = request.regionId;
|
|
51009
|
-
}
|
|
51010
52536
|
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
51011
52537
|
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
51012
52538
|
}
|
|
51013
52539
|
if (!tea_util_1.default.isUnset(request.resourceOwnerId)) {
|
|
51014
52540
|
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
51015
52541
|
}
|
|
52542
|
+
if (!tea_util_1.default.isUnset(request.vSwitchCidrReservationId)) {
|
|
52543
|
+
query["VSwitchCidrReservationId"] = request.vSwitchCidrReservationId;
|
|
52544
|
+
}
|
|
51016
52545
|
let req = new $OpenApi.OpenApiRequest({
|
|
51017
52546
|
query: openapi_util_1.default.query(query),
|
|
51018
52547
|
});
|
|
51019
52548
|
let params = new $OpenApi.Params({
|
|
51020
|
-
action: "
|
|
52549
|
+
action: "GetVSwitchCidrReservationUsage",
|
|
51021
52550
|
version: "2016-04-28",
|
|
51022
52551
|
protocol: "HTTPS",
|
|
51023
52552
|
pathname: "/",
|
|
@@ -51027,11 +52556,11 @@ class Client extends openapi_client_1.default {
|
|
|
51027
52556
|
reqBodyType: "formData",
|
|
51028
52557
|
bodyType: "json",
|
|
51029
52558
|
});
|
|
51030
|
-
return $tea.cast(await this.callApi(params, req, runtime), new
|
|
52559
|
+
return $tea.cast(await this.callApi(params, req, runtime), new GetVSwitchCidrReservationUsageResponse({}));
|
|
51031
52560
|
}
|
|
51032
|
-
async
|
|
52561
|
+
async getVSwitchCidrReservationUsage(request) {
|
|
51033
52562
|
let runtime = new $Util.RuntimeOptions({});
|
|
51034
|
-
return await this.
|
|
52563
|
+
return await this.getVSwitchCidrReservationUsageWithOptions(request, runtime);
|
|
51035
52564
|
}
|
|
51036
52565
|
async getVpcGatewayEndpointAttributeWithOptions(request, runtime) {
|
|
51037
52566
|
tea_util_1.default.validateModel(request);
|
|
@@ -51265,7 +52794,7 @@ class Client extends openapi_client_1.default {
|
|
|
51265
52794
|
}
|
|
51266
52795
|
/**
|
|
51267
52796
|
* * Before you can attach a network instance that belongs to another Alibaba Cloud account to your CEN instance, you must grant permissions to your CEN instance.
|
|
51268
|
-
* > **GrantInstanceToCen** is a Virtual Private Cloud (VPC) operation. Therefore, you must use `vpc.aliyuncs.com`
|
|
52797
|
+
* > **GrantInstanceToCen** is a Virtual Private Cloud (VPC) operation. Therefore, you must use the `vpc.aliyuncs.com` domain name to call this operation. The API version is `2016-04-28`.
|
|
51269
52798
|
* * You cannot repeatedly call the **GrantInstanceToCen** operation to grant the permissions on a network instance to a CEN instance. The network instance can be a VPC, a virtual border router (VBR), or a Cloud Connect Network (CCN) instance.
|
|
51270
52799
|
*
|
|
51271
52800
|
* @param request GrantInstanceToCenRequest
|
|
@@ -51323,7 +52852,7 @@ class Client extends openapi_client_1.default {
|
|
|
51323
52852
|
}
|
|
51324
52853
|
/**
|
|
51325
52854
|
* * Before you can attach a network instance that belongs to another Alibaba Cloud account to your CEN instance, you must grant permissions to your CEN instance.
|
|
51326
|
-
* > **GrantInstanceToCen** is a Virtual Private Cloud (VPC) operation. Therefore, you must use `vpc.aliyuncs.com`
|
|
52855
|
+
* > **GrantInstanceToCen** is a Virtual Private Cloud (VPC) operation. Therefore, you must use the `vpc.aliyuncs.com` domain name to call this operation. The API version is `2016-04-28`.
|
|
51327
52856
|
* * You cannot repeatedly call the **GrantInstanceToCen** operation to grant the permissions on a network instance to a CEN instance. The network instance can be a VPC, a virtual border router (VBR), or a Cloud Connect Network (CCN) instance.
|
|
51328
52857
|
*
|
|
51329
52858
|
* @param request GrantInstanceToCenRequest
|
|
@@ -52211,8 +53740,9 @@ class Client extends openapi_client_1.default {
|
|
|
52211
53740
|
return await this.listTagResourcesWithOptions(request, runtime);
|
|
52212
53741
|
}
|
|
52213
53742
|
/**
|
|
52214
|
-
*
|
|
52215
|
-
* *
|
|
53743
|
+
* ## [](#)
|
|
53744
|
+
* * If you want to query a specific object, you must specify **ResourceId.N** or **Tag.N** that consists of **Tag.N.Key** and **Tag.N.Value** in the request.
|
|
53745
|
+
* * **Tag.N** is a resource tag that consists of a key-value pair. If you specify only **Tag.N.Key**, all tag values that are associated with the specified key are returned. If you specify only **Tag.N.Value**, an error message is returned.
|
|
52216
53746
|
* * If you specify **Tag.N** and **ResourceId.N** to filter tags, **ResourceId.N** must match all specified key-value pairs.
|
|
52217
53747
|
* * If you specify multiple key-value pairs, resources that contain these key-value pairs are returned.
|
|
52218
53748
|
*
|
|
@@ -52270,8 +53800,9 @@ class Client extends openapi_client_1.default {
|
|
|
52270
53800
|
return $tea.cast(await this.callApi(params, req, runtime), new ListTagResourcesForExpressConnectResponse({}));
|
|
52271
53801
|
}
|
|
52272
53802
|
/**
|
|
52273
|
-
*
|
|
52274
|
-
* *
|
|
53803
|
+
* ## [](#)
|
|
53804
|
+
* * If you want to query a specific object, you must specify **ResourceId.N** or **Tag.N** that consists of **Tag.N.Key** and **Tag.N.Value** in the request.
|
|
53805
|
+
* * **Tag.N** is a resource tag that consists of a key-value pair. If you specify only **Tag.N.Key**, all tag values that are associated with the specified key are returned. If you specify only **Tag.N.Value**, an error message is returned.
|
|
52275
53806
|
* * If you specify **Tag.N** and **ResourceId.N** to filter tags, **ResourceId.N** must match all specified key-value pairs.
|
|
52276
53807
|
* * If you specify multiple key-value pairs, resources that contain these key-value pairs are returned.
|
|
52277
53808
|
*
|
|
@@ -52412,6 +53943,65 @@ class Client extends openapi_client_1.default {
|
|
|
52412
53943
|
let runtime = new $Util.RuntimeOptions({});
|
|
52413
53944
|
return await this.listTrafficMirrorSessionsWithOptions(request, runtime);
|
|
52414
53945
|
}
|
|
53946
|
+
async listVSwitchCidrReservationsWithOptions(request, runtime) {
|
|
53947
|
+
tea_util_1.default.validateModel(request);
|
|
53948
|
+
let query = {};
|
|
53949
|
+
if (!tea_util_1.default.isUnset(request.ipVersion)) {
|
|
53950
|
+
query["IpVersion"] = request.ipVersion;
|
|
53951
|
+
}
|
|
53952
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
53953
|
+
query["MaxResults"] = request.maxResults;
|
|
53954
|
+
}
|
|
53955
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
53956
|
+
query["NextToken"] = request.nextToken;
|
|
53957
|
+
}
|
|
53958
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
53959
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
53960
|
+
}
|
|
53961
|
+
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
53962
|
+
query["OwnerId"] = request.ownerId;
|
|
53963
|
+
}
|
|
53964
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
53965
|
+
query["RegionId"] = request.regionId;
|
|
53966
|
+
}
|
|
53967
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
53968
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
53969
|
+
}
|
|
53970
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerId)) {
|
|
53971
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
53972
|
+
}
|
|
53973
|
+
if (!tea_util_1.default.isUnset(request.tags)) {
|
|
53974
|
+
query["Tags"] = request.tags;
|
|
53975
|
+
}
|
|
53976
|
+
if (!tea_util_1.default.isUnset(request.vSwitchCidrReservationIds)) {
|
|
53977
|
+
query["VSwitchCidrReservationIds"] = request.vSwitchCidrReservationIds;
|
|
53978
|
+
}
|
|
53979
|
+
if (!tea_util_1.default.isUnset(request.vSwitchCidrReservationType)) {
|
|
53980
|
+
query["VSwitchCidrReservationType"] = request.vSwitchCidrReservationType;
|
|
53981
|
+
}
|
|
53982
|
+
if (!tea_util_1.default.isUnset(request.vSwitchId)) {
|
|
53983
|
+
query["VSwitchId"] = request.vSwitchId;
|
|
53984
|
+
}
|
|
53985
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
53986
|
+
query: openapi_util_1.default.query(query),
|
|
53987
|
+
});
|
|
53988
|
+
let params = new $OpenApi.Params({
|
|
53989
|
+
action: "ListVSwitchCidrReservations",
|
|
53990
|
+
version: "2016-04-28",
|
|
53991
|
+
protocol: "HTTPS",
|
|
53992
|
+
pathname: "/",
|
|
53993
|
+
method: "POST",
|
|
53994
|
+
authType: "AK",
|
|
53995
|
+
style: "RPC",
|
|
53996
|
+
reqBodyType: "formData",
|
|
53997
|
+
bodyType: "json",
|
|
53998
|
+
});
|
|
53999
|
+
return $tea.cast(await this.callApi(params, req, runtime), new ListVSwitchCidrReservationsResponse({}));
|
|
54000
|
+
}
|
|
54001
|
+
async listVSwitchCidrReservations(request) {
|
|
54002
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
54003
|
+
return await this.listVSwitchCidrReservationsWithOptions(request, runtime);
|
|
54004
|
+
}
|
|
52415
54005
|
async listVirtualPhysicalConnectionsWithOptions(request, runtime) {
|
|
52416
54006
|
tea_util_1.default.validateModel(request);
|
|
52417
54007
|
let query = {};
|
|
@@ -53239,7 +54829,7 @@ class Client extends openapi_client_1.default {
|
|
|
53239
54829
|
return await this.modifyFlowLogAttributeWithOptions(request, runtime);
|
|
53240
54830
|
}
|
|
53241
54831
|
/**
|
|
53242
|
-
* * **ModifyForwardEntry** is an asynchronous operation. After
|
|
54832
|
+
* * **ModifyForwardEntry** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeForwardTableEntries](~~36053~~) operation to query the status of the task.
|
|
53243
54833
|
* * **Pending**: indicates that the system is modifying the DNAT entry. You can only query the DNAT entry, but cannot perform other operations.
|
|
53244
54834
|
* * **Available**: indicates that the DNAT entry is modified.
|
|
53245
54835
|
* * You cannot repeatedly call the **ModifyForwardEntry** operation to modify a DNAT entry within the specified period of time.
|
|
@@ -53313,7 +54903,7 @@ class Client extends openapi_client_1.default {
|
|
|
53313
54903
|
return $tea.cast(await this.callApi(params, req, runtime), new ModifyForwardEntryResponse({}));
|
|
53314
54904
|
}
|
|
53315
54905
|
/**
|
|
53316
|
-
* * **ModifyForwardEntry** is an asynchronous operation. After
|
|
54906
|
+
* * **ModifyForwardEntry** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeForwardTableEntries](~~36053~~) operation to query the status of the task.
|
|
53317
54907
|
* * **Pending**: indicates that the system is modifying the DNAT entry. You can only query the DNAT entry, but cannot perform other operations.
|
|
53318
54908
|
* * **Available**: indicates that the DNAT entry is modified.
|
|
53319
54909
|
* * You cannot repeatedly call the **ModifyForwardEntry** operation to modify a DNAT entry within the specified period of time.
|
|
@@ -53326,7 +54916,8 @@ class Client extends openapi_client_1.default {
|
|
|
53326
54916
|
return await this.modifyForwardEntryWithOptions(request, runtime);
|
|
53327
54917
|
}
|
|
53328
54918
|
/**
|
|
53329
|
-
*
|
|
54919
|
+
* ## [](#)
|
|
54920
|
+
* * **ModifyFullNatEntryAttribute** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [ListFullNatEntries](~~348779~~) operation to query the status of a FULLNAT entry.
|
|
53330
54921
|
* * **Modifying**: indicates that the system is modifying the FULLNAT entry. You can query the FULLNAT entry, but cannot perform other operations.
|
|
53331
54922
|
* * **Available**: indicates that the FULLNAT entry is modified.
|
|
53332
54923
|
* * You cannot repeatedly call the **ModifyFullNatEntryAttribute** operation to modify a FULLNAT entry within the specified period of time.
|
|
@@ -53406,7 +54997,8 @@ class Client extends openapi_client_1.default {
|
|
|
53406
54997
|
return $tea.cast(await this.callApi(params, req, runtime), new ModifyFullNatEntryAttributeResponse({}));
|
|
53407
54998
|
}
|
|
53408
54999
|
/**
|
|
53409
|
-
*
|
|
55000
|
+
* ## [](#)
|
|
55001
|
+
* * **ModifyFullNatEntryAttribute** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [ListFullNatEntries](~~348779~~) operation to query the status of a FULLNAT entry.
|
|
53410
55002
|
* * **Modifying**: indicates that the system is modifying the FULLNAT entry. You can query the FULLNAT entry, but cannot perform other operations.
|
|
53411
55003
|
* * **Available**: indicates that the FULLNAT entry is modified.
|
|
53412
55004
|
* * You cannot repeatedly call the **ModifyFullNatEntryAttribute** operation to modify a FULLNAT entry within the specified period of time.
|
|
@@ -54049,7 +55641,8 @@ class Client extends openapi_client_1.default {
|
|
|
54049
55641
|
return await this.modifyIpv6InternetBandwidthWithOptions(request, runtime);
|
|
54050
55642
|
}
|
|
54051
55643
|
/**
|
|
54052
|
-
*
|
|
55644
|
+
* ## [](#)Description
|
|
55645
|
+
* You can call this operation to query an Internet NAT gateway or a virtual private cloud (VPC) NAT gateway. The term NAT gateway in this topic refers to both NAT gateway types.
|
|
54053
55646
|
*
|
|
54054
55647
|
* @param request ModifyNatGatewayAttributeRequest
|
|
54055
55648
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -54105,7 +55698,8 @@ class Client extends openapi_client_1.default {
|
|
|
54105
55698
|
return $tea.cast(await this.callApi(params, req, runtime), new ModifyNatGatewayAttributeResponse({}));
|
|
54106
55699
|
}
|
|
54107
55700
|
/**
|
|
54108
|
-
*
|
|
55701
|
+
* ## [](#)Description
|
|
55702
|
+
* You can call this operation to query an Internet NAT gateway or a virtual private cloud (VPC) NAT gateway. The term NAT gateway in this topic refers to both NAT gateway types.
|
|
54109
55703
|
*
|
|
54110
55704
|
* @param request ModifyNatGatewayAttributeRequest
|
|
54111
55705
|
* @return ModifyNatGatewayAttributeResponse
|
|
@@ -54198,6 +55792,7 @@ class Client extends openapi_client_1.default {
|
|
|
54198
55792
|
return await this.modifyNatGatewaySpecWithOptions(request, runtime);
|
|
54199
55793
|
}
|
|
54200
55794
|
/**
|
|
55795
|
+
* ## [](#)Description
|
|
54201
55796
|
* You cannot repeatedly call the **ModifyNatIpAttribute** operation to modify the name and description of a NAT IP address within the specified period of time.
|
|
54202
55797
|
*
|
|
54203
55798
|
* @param request ModifyNatIpAttributeRequest
|
|
@@ -54257,6 +55852,7 @@ class Client extends openapi_client_1.default {
|
|
|
54257
55852
|
return $tea.cast(await this.callApi(params, req, runtime), new ModifyNatIpAttributeResponse({}));
|
|
54258
55853
|
}
|
|
54259
55854
|
/**
|
|
55855
|
+
* ## [](#)Description
|
|
54260
55856
|
* You cannot repeatedly call the **ModifyNatIpAttribute** operation to modify the name and description of a NAT IP address within the specified period of time.
|
|
54261
55857
|
*
|
|
54262
55858
|
* @param request ModifyNatIpAttributeRequest
|
|
@@ -54334,12 +55930,18 @@ class Client extends openapi_client_1.default {
|
|
|
54334
55930
|
if (!tea_util_1.default.isUnset(request.description)) {
|
|
54335
55931
|
query["Description"] = request.description;
|
|
54336
55932
|
}
|
|
55933
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
55934
|
+
query["DryRun"] = request.dryRun;
|
|
55935
|
+
}
|
|
54337
55936
|
if (!tea_util_1.default.isUnset(request.networkAclId)) {
|
|
54338
55937
|
query["NetworkAclId"] = request.networkAclId;
|
|
54339
55938
|
}
|
|
54340
55939
|
if (!tea_util_1.default.isUnset(request.networkAclName)) {
|
|
54341
55940
|
query["NetworkAclName"] = request.networkAclName;
|
|
54342
55941
|
}
|
|
55942
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
55943
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
55944
|
+
}
|
|
54343
55945
|
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
54344
55946
|
query["OwnerId"] = request.ownerId;
|
|
54345
55947
|
}
|
|
@@ -54376,7 +55978,6 @@ class Client extends openapi_client_1.default {
|
|
|
54376
55978
|
return await this.modifyNetworkAclAttributesWithOptions(request, runtime);
|
|
54377
55979
|
}
|
|
54378
55980
|
/**
|
|
54379
|
-
* ## Limits
|
|
54380
55981
|
* When you call this operation, take note of the following limits:
|
|
54381
55982
|
* * If an Express Connect circuit is in the **Initial**, **Enabled**, or **Rejected** state, you can modify the specifications of the Express Connect circuit and the ID of the redundant circuit.
|
|
54382
55983
|
* * If an Express Connect circuit is in the **Canceled**, **Allocating**, **AllocationFailed**, or **Terminated** state, you cannot modify the specifications of the Express Connect circuit.
|
|
@@ -54454,7 +56055,6 @@ class Client extends openapi_client_1.default {
|
|
|
54454
56055
|
return $tea.cast(await this.callApi(params, req, runtime), new ModifyPhysicalConnectionAttributeResponse({}));
|
|
54455
56056
|
}
|
|
54456
56057
|
/**
|
|
54457
|
-
* ## Limits
|
|
54458
56058
|
* When you call this operation, take note of the following limits:
|
|
54459
56059
|
* * If an Express Connect circuit is in the **Initial**, **Enabled**, or **Rejected** state, you can modify the specifications of the Express Connect circuit and the ID of the redundant circuit.
|
|
54460
56060
|
* * If an Express Connect circuit is in the **Canceled**, **Allocating**, **AllocationFailed**, or **Terminated** state, you cannot modify the specifications of the Express Connect circuit.
|
|
@@ -54534,6 +56134,7 @@ class Client extends openapi_client_1.default {
|
|
|
54534
56134
|
return await this.modifyRouteEntryWithOptions(request, runtime);
|
|
54535
56135
|
}
|
|
54536
56136
|
/**
|
|
56137
|
+
* ## [](#)References
|
|
54537
56138
|
* You cannot repeatedly call the **ModifyRouteTableAttributes** operation to modify the name and description of a route table within the specified period of time.
|
|
54538
56139
|
*
|
|
54539
56140
|
* @param request ModifyRouteTableAttributesRequest
|
|
@@ -54584,6 +56185,7 @@ class Client extends openapi_client_1.default {
|
|
|
54584
56185
|
return $tea.cast(await this.callApi(params, req, runtime), new ModifyRouteTableAttributesResponse({}));
|
|
54585
56186
|
}
|
|
54586
56187
|
/**
|
|
56188
|
+
* ## [](#)References
|
|
54587
56189
|
* You cannot repeatedly call the **ModifyRouteTableAttributes** operation to modify the name and description of a route table within the specified period of time.
|
|
54588
56190
|
*
|
|
54589
56191
|
* @param request ModifyRouteTableAttributesRequest
|
|
@@ -54665,8 +56267,9 @@ class Client extends openapi_client_1.default {
|
|
|
54665
56267
|
return await this.modifyRouterInterfaceAttributeWithOptions(request, runtime);
|
|
54666
56268
|
}
|
|
54667
56269
|
/**
|
|
56270
|
+
* ## [](#)Description
|
|
54668
56271
|
* After you call this operation, the router interface enters the **Activating** state. After the router interface is activated, the router interface enters the **Active** state.
|
|
54669
|
-
* > You cannot modify the
|
|
56272
|
+
* > You cannot modify the specification of a router interface that has overdue payments.
|
|
54670
56273
|
*
|
|
54671
56274
|
* @param request ModifyRouterInterfaceSpecRequest
|
|
54672
56275
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -54716,8 +56319,9 @@ class Client extends openapi_client_1.default {
|
|
|
54716
56319
|
return $tea.cast(await this.callApi(params, req, runtime), new ModifyRouterInterfaceSpecResponse({}));
|
|
54717
56320
|
}
|
|
54718
56321
|
/**
|
|
56322
|
+
* ## [](#)Description
|
|
54719
56323
|
* After you call this operation, the router interface enters the **Activating** state. After the router interface is activated, the router interface enters the **Active** state.
|
|
54720
|
-
* > You cannot modify the
|
|
56324
|
+
* > You cannot modify the specification of a router interface that has overdue payments.
|
|
54721
56325
|
*
|
|
54722
56326
|
* @param request ModifyRouterInterfaceSpecRequest
|
|
54723
56327
|
* @return ModifyRouterInterfaceSpecResponse
|
|
@@ -54727,11 +56331,12 @@ class Client extends openapi_client_1.default {
|
|
|
54727
56331
|
return await this.modifyRouterInterfaceSpecWithOptions(request, runtime);
|
|
54728
56332
|
}
|
|
54729
56333
|
/**
|
|
54730
|
-
*
|
|
56334
|
+
* ## [](#)
|
|
56335
|
+
* **ModifySnatEntry** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeSnatTableEntries](~~42677~~) operation to query the status of the task.
|
|
54731
56336
|
* * **Pending**: indicates that the system is modifying the SNAT entry. You can only query the status of the SNAT entry, but cannot perform other operations.
|
|
54732
56337
|
* * **Available**: indicates that the SNAT entry is modified.
|
|
54733
|
-
* > **Pending
|
|
54734
|
-
* You cannot repeatedly call the **ModifySnatEntry** operation to modify an SNAT entry within
|
|
56338
|
+
* > If an SNAT entry is in the **Pending** state, it indicates that you cannot modify the SNAT entry.
|
|
56339
|
+
* You cannot repeatedly call the **ModifySnatEntry** operation to modify an SNAT entry within a specific period of time.
|
|
54735
56340
|
*
|
|
54736
56341
|
* @param request ModifySnatEntryRequest
|
|
54737
56342
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -54787,11 +56392,12 @@ class Client extends openapi_client_1.default {
|
|
|
54787
56392
|
return $tea.cast(await this.callApi(params, req, runtime), new ModifySnatEntryResponse({}));
|
|
54788
56393
|
}
|
|
54789
56394
|
/**
|
|
54790
|
-
*
|
|
56395
|
+
* ## [](#)
|
|
56396
|
+
* **ModifySnatEntry** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeSnatTableEntries](~~42677~~) operation to query the status of the task.
|
|
54791
56397
|
* * **Pending**: indicates that the system is modifying the SNAT entry. You can only query the status of the SNAT entry, but cannot perform other operations.
|
|
54792
56398
|
* * **Available**: indicates that the SNAT entry is modified.
|
|
54793
|
-
* > **Pending
|
|
54794
|
-
* You cannot repeatedly call the **ModifySnatEntry** operation to modify an SNAT entry within
|
|
56399
|
+
* > If an SNAT entry is in the **Pending** state, it indicates that you cannot modify the SNAT entry.
|
|
56400
|
+
* You cannot repeatedly call the **ModifySnatEntry** operation to modify an SNAT entry within a specific period of time.
|
|
54795
56401
|
*
|
|
54796
56402
|
* @param request ModifySnatEntryRequest
|
|
54797
56403
|
* @return ModifySnatEntryResponse
|
|
@@ -54848,7 +56454,7 @@ class Client extends openapi_client_1.default {
|
|
|
54848
56454
|
return await this.modifySslVpnClientCertWithOptions(request, runtime);
|
|
54849
56455
|
}
|
|
54850
56456
|
/**
|
|
54851
|
-
* * If you only
|
|
56457
|
+
* * If you modify only the **name** of the SSL server, the operation is synchronous. If you also modify other configurations besides the **name**, the operation is asynchronous.
|
|
54852
56458
|
* * When **ModifySslVpnServer** is an asynchronous operation, the system returns a request ID and runs the task in the background. You can call [DescribeVpnGateway](~~73720~~) to query the status of the task.
|
|
54853
56459
|
* * If a VPN gateway is in the **updating** state, the configurations of the SSL server are being modified.
|
|
54854
56460
|
* * If a VPN gateway is in the **active** state, the configurations of the SSL server are modified.
|
|
@@ -54929,7 +56535,7 @@ class Client extends openapi_client_1.default {
|
|
|
54929
56535
|
return $tea.cast(await this.callApi(params, req, runtime), new ModifySslVpnServerResponse({}));
|
|
54930
56536
|
}
|
|
54931
56537
|
/**
|
|
54932
|
-
* * If you only
|
|
56538
|
+
* * If you modify only the **name** of the SSL server, the operation is synchronous. If you also modify other configurations besides the **name**, the operation is asynchronous.
|
|
54933
56539
|
* * When **ModifySslVpnServer** is an asynchronous operation, the system returns a request ID and runs the task in the background. You can call [DescribeVpnGateway](~~73720~~) to query the status of the task.
|
|
54934
56540
|
* * If a VPN gateway is in the **updating** state, the configurations of the SSL server are being modified.
|
|
54935
56541
|
* * If a VPN gateway is in the **active** state, the configurations of the SSL server are modified.
|
|
@@ -54993,7 +56599,7 @@ class Client extends openapi_client_1.default {
|
|
|
54993
56599
|
return await this.modifyTunnelAttributeWithOptions(request, runtime);
|
|
54994
56600
|
}
|
|
54995
56601
|
/**
|
|
54996
|
-
* You cannot repeatedly call the **ModifyVRouterAttribute** operation
|
|
56602
|
+
* You cannot repeatedly call the **ModifyVRouterAttribute** operation within a specific period of time.
|
|
54997
56603
|
*
|
|
54998
56604
|
* @param request ModifyVRouterAttributeRequest
|
|
54999
56605
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -55043,7 +56649,7 @@ class Client extends openapi_client_1.default {
|
|
|
55043
56649
|
return $tea.cast(await this.callApi(params, req, runtime), new ModifyVRouterAttributeResponse({}));
|
|
55044
56650
|
}
|
|
55045
56651
|
/**
|
|
55046
|
-
* You cannot repeatedly call the **ModifyVRouterAttribute** operation
|
|
56652
|
+
* You cannot repeatedly call the **ModifyVRouterAttribute** operation within a specific period of time.
|
|
55047
56653
|
*
|
|
55048
56654
|
* @param request ModifyVRouterAttributeRequest
|
|
55049
56655
|
* @return ModifyVRouterAttributeResponse
|
|
@@ -55127,6 +56733,68 @@ class Client extends openapi_client_1.default {
|
|
|
55127
56733
|
let runtime = new $Util.RuntimeOptions({});
|
|
55128
56734
|
return await this.modifyVSwitchAttributeWithOptions(request, runtime);
|
|
55129
56735
|
}
|
|
56736
|
+
/**
|
|
56737
|
+
* ## [](#)Usage notes
|
|
56738
|
+
* You cannot repeatedly call **ModifyVSwitchCidrReservationAttribute** within a specific time period.
|
|
56739
|
+
*
|
|
56740
|
+
* @param request ModifyVSwitchCidrReservationAttributeRequest
|
|
56741
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
56742
|
+
* @return ModifyVSwitchCidrReservationAttributeResponse
|
|
56743
|
+
*/
|
|
56744
|
+
async modifyVSwitchCidrReservationAttributeWithOptions(request, runtime) {
|
|
56745
|
+
tea_util_1.default.validateModel(request);
|
|
56746
|
+
let query = {};
|
|
56747
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
56748
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
56749
|
+
}
|
|
56750
|
+
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
56751
|
+
query["OwnerId"] = request.ownerId;
|
|
56752
|
+
}
|
|
56753
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
56754
|
+
query["RegionId"] = request.regionId;
|
|
56755
|
+
}
|
|
56756
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
56757
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
56758
|
+
}
|
|
56759
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerId)) {
|
|
56760
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
56761
|
+
}
|
|
56762
|
+
if (!tea_util_1.default.isUnset(request.vSwitchCidrReservationDescription)) {
|
|
56763
|
+
query["VSwitchCidrReservationDescription"] = request.vSwitchCidrReservationDescription;
|
|
56764
|
+
}
|
|
56765
|
+
if (!tea_util_1.default.isUnset(request.vSwitchCidrReservationId)) {
|
|
56766
|
+
query["VSwitchCidrReservationId"] = request.vSwitchCidrReservationId;
|
|
56767
|
+
}
|
|
56768
|
+
if (!tea_util_1.default.isUnset(request.vSwitchCidrReservationName)) {
|
|
56769
|
+
query["VSwitchCidrReservationName"] = request.vSwitchCidrReservationName;
|
|
56770
|
+
}
|
|
56771
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
56772
|
+
query: openapi_util_1.default.query(query),
|
|
56773
|
+
});
|
|
56774
|
+
let params = new $OpenApi.Params({
|
|
56775
|
+
action: "ModifyVSwitchCidrReservationAttribute",
|
|
56776
|
+
version: "2016-04-28",
|
|
56777
|
+
protocol: "HTTPS",
|
|
56778
|
+
pathname: "/",
|
|
56779
|
+
method: "POST",
|
|
56780
|
+
authType: "AK",
|
|
56781
|
+
style: "RPC",
|
|
56782
|
+
reqBodyType: "formData",
|
|
56783
|
+
bodyType: "json",
|
|
56784
|
+
});
|
|
56785
|
+
return $tea.cast(await this.callApi(params, req, runtime), new ModifyVSwitchCidrReservationAttributeResponse({}));
|
|
56786
|
+
}
|
|
56787
|
+
/**
|
|
56788
|
+
* ## [](#)Usage notes
|
|
56789
|
+
* You cannot repeatedly call **ModifyVSwitchCidrReservationAttribute** within a specific time period.
|
|
56790
|
+
*
|
|
56791
|
+
* @param request ModifyVSwitchCidrReservationAttributeRequest
|
|
56792
|
+
* @return ModifyVSwitchCidrReservationAttributeResponse
|
|
56793
|
+
*/
|
|
56794
|
+
async modifyVSwitchCidrReservationAttribute(request) {
|
|
56795
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
56796
|
+
return await this.modifyVSwitchCidrReservationAttributeWithOptions(request, runtime);
|
|
56797
|
+
}
|
|
55130
56798
|
/**
|
|
55131
56799
|
* * **ModifyVcoRouteEntryWeight** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeVpnConnection](~~53046~~) operation to query the status of the associated IPsec-VPN connection and determine whether the weight of the specified destination-based route is modified.
|
|
55132
56800
|
* * If the IPsec-VPN connection is in the **updating** state, the weight of the destination-based route is being modified.
|
|
@@ -55203,8 +56871,9 @@ class Client extends openapi_client_1.default {
|
|
|
55203
56871
|
return await this.modifyVcoRouteEntryWeightWithOptions(request, runtime);
|
|
55204
56872
|
}
|
|
55205
56873
|
/**
|
|
56874
|
+
* # [](#)
|
|
55206
56875
|
* * Only the owner of an Express Connect circuit can modify the **VlanId** parameter.
|
|
55207
|
-
* * One VLAN ID of an Express Connect circuit cannot be used by
|
|
56876
|
+
* * One VLAN ID of an Express Connect circuit cannot be used only by one VBR at the same time.
|
|
55208
56877
|
* * The VLAN ID of a VBR in the **Terminated** state is reserved for seven days and cannot be used by other VBRs. The VLAN ID can be used by other VBRs after 7 days.
|
|
55209
56878
|
* * You cannot set **LocalGatewayIp**, **PeerGatewayIp**, or **PeeringSubnetMask** for VBRs that do not belong to your Alibaba Cloud account.
|
|
55210
56879
|
* * Set **PeeringSubnetMask** to a subnet mask with 24 to 30 bits in length (255.255.255.0~255.255.255.252).
|
|
@@ -55303,8 +56972,9 @@ class Client extends openapi_client_1.default {
|
|
|
55303
56972
|
return $tea.cast(await this.callApi(params, req, runtime), new ModifyVirtualBorderRouterAttributeResponse({}));
|
|
55304
56973
|
}
|
|
55305
56974
|
/**
|
|
56975
|
+
* # [](#)
|
|
55306
56976
|
* * Only the owner of an Express Connect circuit can modify the **VlanId** parameter.
|
|
55307
|
-
* * One VLAN ID of an Express Connect circuit cannot be used by
|
|
56977
|
+
* * One VLAN ID of an Express Connect circuit cannot be used only by one VBR at the same time.
|
|
55308
56978
|
* * The VLAN ID of a VBR in the **Terminated** state is reserved for seven days and cannot be used by other VBRs. The VLAN ID can be used by other VBRs after 7 days.
|
|
55309
56979
|
* * You cannot set **LocalGatewayIp**, **PeerGatewayIp**, or **PeeringSubnetMask** for VBRs that do not belong to your Alibaba Cloud account.
|
|
55310
56980
|
* * Set **PeeringSubnetMask** to a subnet mask with 24 to 30 bits in length (255.255.255.0~255.255.255.252).
|
|
@@ -55318,6 +56988,7 @@ class Client extends openapi_client_1.default {
|
|
|
55318
56988
|
return await this.modifyVirtualBorderRouterAttributeWithOptions(request, runtime);
|
|
55319
56989
|
}
|
|
55320
56990
|
/**
|
|
56991
|
+
* ## [](#)Description
|
|
55321
56992
|
* You cannot repeatedly call the **ModifyVpcAttribute** operation to modify the name and description of a VPC within the specified period of time.
|
|
55322
56993
|
*
|
|
55323
56994
|
* @param request ModifyVpcAttributeRequest
|
|
@@ -55380,6 +57051,7 @@ class Client extends openapi_client_1.default {
|
|
|
55380
57051
|
return $tea.cast(await this.callApi(params, req, runtime), new ModifyVpcAttributeResponse({}));
|
|
55381
57052
|
}
|
|
55382
57053
|
/**
|
|
57054
|
+
* ## [](#)Description
|
|
55383
57055
|
* You cannot repeatedly call the **ModifyVpcAttribute** operation to modify the name and description of a VPC within the specified period of time.
|
|
55384
57056
|
*
|
|
55385
57057
|
* @param request ModifyVpcAttributeRequest
|
|
@@ -55917,7 +57589,91 @@ class Client extends openapi_client_1.default {
|
|
|
55917
57589
|
query: openapi_util_1.default.query(query),
|
|
55918
57590
|
});
|
|
55919
57591
|
let params = new $OpenApi.Params({
|
|
55920
|
-
action: "ModifyVpnPbrRouteEntryPriority",
|
|
57592
|
+
action: "ModifyVpnPbrRouteEntryPriority",
|
|
57593
|
+
version: "2016-04-28",
|
|
57594
|
+
protocol: "HTTPS",
|
|
57595
|
+
pathname: "/",
|
|
57596
|
+
method: "POST",
|
|
57597
|
+
authType: "AK",
|
|
57598
|
+
style: "RPC",
|
|
57599
|
+
reqBodyType: "formData",
|
|
57600
|
+
bodyType: "json",
|
|
57601
|
+
});
|
|
57602
|
+
return $tea.cast(await this.callApi(params, req, runtime), new ModifyVpnPbrRouteEntryPriorityResponse({}));
|
|
57603
|
+
}
|
|
57604
|
+
/**
|
|
57605
|
+
* * **ModifyVpnPbrRouteEntryPriority** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call [DescribeVpnGateway](~~73720~~) to query the status of the task.
|
|
57606
|
+
* * If a VPN gateway is in the **updating** state, the policy-based route entry is being modified.
|
|
57607
|
+
* * If the VPN gateway is in the **active** state, the policy-based route is created.
|
|
57608
|
+
* * You cannot repeatedly call the **ModifyVpnPbrRouteEntryPriority** operation for the same VPN gateway within the specified period of time.
|
|
57609
|
+
*
|
|
57610
|
+
* @param request ModifyVpnPbrRouteEntryPriorityRequest
|
|
57611
|
+
* @return ModifyVpnPbrRouteEntryPriorityResponse
|
|
57612
|
+
*/
|
|
57613
|
+
async modifyVpnPbrRouteEntryPriority(request) {
|
|
57614
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
57615
|
+
return await this.modifyVpnPbrRouteEntryPriorityWithOptions(request, runtime);
|
|
57616
|
+
}
|
|
57617
|
+
/**
|
|
57618
|
+
* * **ModifyVpnPbrRouteEntryWeight** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call [DescribeVpnGateway](~~73720~~) to query the status of the task.
|
|
57619
|
+
* * If a VPN gateway is in the **updating** state, the policy-based route entry is being modified.
|
|
57620
|
+
* * If a VPN gateway is in the **active** state, the policy-based route entry is modified.
|
|
57621
|
+
* * You cannot repeatedly call the **ModifyVpnPbrRouteEntryWeight** operation for the same VPN gateway within the specified period of time.
|
|
57622
|
+
*
|
|
57623
|
+
* @param request ModifyVpnPbrRouteEntryWeightRequest
|
|
57624
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
57625
|
+
* @return ModifyVpnPbrRouteEntryWeightResponse
|
|
57626
|
+
*/
|
|
57627
|
+
async modifyVpnPbrRouteEntryWeightWithOptions(request, runtime) {
|
|
57628
|
+
tea_util_1.default.validateModel(request);
|
|
57629
|
+
let query = {};
|
|
57630
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
57631
|
+
query["ClientToken"] = request.clientToken;
|
|
57632
|
+
}
|
|
57633
|
+
if (!tea_util_1.default.isUnset(request.newWeight)) {
|
|
57634
|
+
query["NewWeight"] = request.newWeight;
|
|
57635
|
+
}
|
|
57636
|
+
if (!tea_util_1.default.isUnset(request.nextHop)) {
|
|
57637
|
+
query["NextHop"] = request.nextHop;
|
|
57638
|
+
}
|
|
57639
|
+
if (!tea_util_1.default.isUnset(request.overlayMode)) {
|
|
57640
|
+
query["OverlayMode"] = request.overlayMode;
|
|
57641
|
+
}
|
|
57642
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
57643
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
57644
|
+
}
|
|
57645
|
+
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
57646
|
+
query["OwnerId"] = request.ownerId;
|
|
57647
|
+
}
|
|
57648
|
+
if (!tea_util_1.default.isUnset(request.priority)) {
|
|
57649
|
+
query["Priority"] = request.priority;
|
|
57650
|
+
}
|
|
57651
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
57652
|
+
query["RegionId"] = request.regionId;
|
|
57653
|
+
}
|
|
57654
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
57655
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
57656
|
+
}
|
|
57657
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerId)) {
|
|
57658
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
57659
|
+
}
|
|
57660
|
+
if (!tea_util_1.default.isUnset(request.routeDest)) {
|
|
57661
|
+
query["RouteDest"] = request.routeDest;
|
|
57662
|
+
}
|
|
57663
|
+
if (!tea_util_1.default.isUnset(request.routeSource)) {
|
|
57664
|
+
query["RouteSource"] = request.routeSource;
|
|
57665
|
+
}
|
|
57666
|
+
if (!tea_util_1.default.isUnset(request.vpnGatewayId)) {
|
|
57667
|
+
query["VpnGatewayId"] = request.vpnGatewayId;
|
|
57668
|
+
}
|
|
57669
|
+
if (!tea_util_1.default.isUnset(request.weight)) {
|
|
57670
|
+
query["Weight"] = request.weight;
|
|
57671
|
+
}
|
|
57672
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
57673
|
+
query: openapi_util_1.default.query(query),
|
|
57674
|
+
});
|
|
57675
|
+
let params = new $OpenApi.Params({
|
|
57676
|
+
action: "ModifyVpnPbrRouteEntryWeight",
|
|
55921
57677
|
version: "2016-04-28",
|
|
55922
57678
|
protocol: "HTTPS",
|
|
55923
57679
|
pathname: "/",
|
|
@@ -55927,32 +57683,32 @@ class Client extends openapi_client_1.default {
|
|
|
55927
57683
|
reqBodyType: "formData",
|
|
55928
57684
|
bodyType: "json",
|
|
55929
57685
|
});
|
|
55930
|
-
return $tea.cast(await this.callApi(params, req, runtime), new
|
|
57686
|
+
return $tea.cast(await this.callApi(params, req, runtime), new ModifyVpnPbrRouteEntryWeightResponse({}));
|
|
55931
57687
|
}
|
|
55932
57688
|
/**
|
|
55933
|
-
* * **
|
|
57689
|
+
* * **ModifyVpnPbrRouteEntryWeight** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call [DescribeVpnGateway](~~73720~~) to query the status of the task.
|
|
55934
57690
|
* * If a VPN gateway is in the **updating** state, the policy-based route entry is being modified.
|
|
55935
|
-
* * If
|
|
55936
|
-
* * You cannot repeatedly call the **
|
|
57691
|
+
* * If a VPN gateway is in the **active** state, the policy-based route entry is modified.
|
|
57692
|
+
* * You cannot repeatedly call the **ModifyVpnPbrRouteEntryWeight** operation for the same VPN gateway within the specified period of time.
|
|
55937
57693
|
*
|
|
55938
|
-
* @param request
|
|
55939
|
-
* @return
|
|
57694
|
+
* @param request ModifyVpnPbrRouteEntryWeightRequest
|
|
57695
|
+
* @return ModifyVpnPbrRouteEntryWeightResponse
|
|
55940
57696
|
*/
|
|
55941
|
-
async
|
|
57697
|
+
async modifyVpnPbrRouteEntryWeight(request) {
|
|
55942
57698
|
let runtime = new $Util.RuntimeOptions({});
|
|
55943
|
-
return await this.
|
|
57699
|
+
return await this.modifyVpnPbrRouteEntryWeightWithOptions(request, runtime);
|
|
55944
57700
|
}
|
|
55945
57701
|
/**
|
|
55946
|
-
* * **
|
|
55947
|
-
* * If
|
|
55948
|
-
* * If
|
|
55949
|
-
* * You cannot repeatedly call the **
|
|
57702
|
+
* * **ModifyVpnRouteEntryWeight** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call [DescribeVpnGateway](~~73720~~) to query the status of the task.
|
|
57703
|
+
* * If the VPN gateway is in the **updating** state, the weight of the destination-based route is being modified.
|
|
57704
|
+
* * If the VPN gateway is in the **active** state, the weight of the destination-based route is modified.
|
|
57705
|
+
* * You cannot repeatedly call the **ModifyVpnRouteEntryWeight** operation to modify the weight of destination-based route for the same VPN gateway within the specified period of time.
|
|
55950
57706
|
*
|
|
55951
|
-
* @param request
|
|
57707
|
+
* @param request ModifyVpnRouteEntryWeightRequest
|
|
55952
57708
|
* @param runtime runtime options for this request RuntimeOptions
|
|
55953
|
-
* @return
|
|
57709
|
+
* @return ModifyVpnRouteEntryWeightResponse
|
|
55954
57710
|
*/
|
|
55955
|
-
async
|
|
57711
|
+
async modifyVpnRouteEntryWeightWithOptions(request, runtime) {
|
|
55956
57712
|
tea_util_1.default.validateModel(request);
|
|
55957
57713
|
let query = {};
|
|
55958
57714
|
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
@@ -55973,9 +57729,6 @@ class Client extends openapi_client_1.default {
|
|
|
55973
57729
|
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
55974
57730
|
query["OwnerId"] = request.ownerId;
|
|
55975
57731
|
}
|
|
55976
|
-
if (!tea_util_1.default.isUnset(request.priority)) {
|
|
55977
|
-
query["Priority"] = request.priority;
|
|
55978
|
-
}
|
|
55979
57732
|
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
55980
57733
|
query["RegionId"] = request.regionId;
|
|
55981
57734
|
}
|
|
@@ -55988,9 +57741,6 @@ class Client extends openapi_client_1.default {
|
|
|
55988
57741
|
if (!tea_util_1.default.isUnset(request.routeDest)) {
|
|
55989
57742
|
query["RouteDest"] = request.routeDest;
|
|
55990
57743
|
}
|
|
55991
|
-
if (!tea_util_1.default.isUnset(request.routeSource)) {
|
|
55992
|
-
query["RouteSource"] = request.routeSource;
|
|
55993
|
-
}
|
|
55994
57744
|
if (!tea_util_1.default.isUnset(request.vpnGatewayId)) {
|
|
55995
57745
|
query["VpnGatewayId"] = request.vpnGatewayId;
|
|
55996
57746
|
}
|
|
@@ -56001,7 +57751,7 @@ class Client extends openapi_client_1.default {
|
|
|
56001
57751
|
query: openapi_util_1.default.query(query),
|
|
56002
57752
|
});
|
|
56003
57753
|
let params = new $OpenApi.Params({
|
|
56004
|
-
action: "
|
|
57754
|
+
action: "ModifyVpnRouteEntryWeight",
|
|
56005
57755
|
version: "2016-04-28",
|
|
56006
57756
|
protocol: "HTTPS",
|
|
56007
57757
|
pathname: "/",
|
|
@@ -56011,20 +57761,7 @@ class Client extends openapi_client_1.default {
|
|
|
56011
57761
|
reqBodyType: "formData",
|
|
56012
57762
|
bodyType: "json",
|
|
56013
57763
|
});
|
|
56014
|
-
return $tea.cast(await this.callApi(params, req, runtime), new
|
|
56015
|
-
}
|
|
56016
|
-
/**
|
|
56017
|
-
* * **ModifyVpnPbrRouteEntryWeight** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call [DescribeVpnGateway](~~73720~~) to query the status of the task.
|
|
56018
|
-
* * If a VPN gateway is in the **updating** state, the policy-based route entry is being modified.
|
|
56019
|
-
* * If a VPN gateway is in the **active** state, the policy-based route entry is modified.
|
|
56020
|
-
* * You cannot repeatedly call the **ModifyVpnPbrRouteEntryWeight** operation for the same VPN gateway within the specified period of time.
|
|
56021
|
-
*
|
|
56022
|
-
* @param request ModifyVpnPbrRouteEntryWeightRequest
|
|
56023
|
-
* @return ModifyVpnPbrRouteEntryWeightResponse
|
|
56024
|
-
*/
|
|
56025
|
-
async modifyVpnPbrRouteEntryWeight(request) {
|
|
56026
|
-
let runtime = new $Util.RuntimeOptions({});
|
|
56027
|
-
return await this.modifyVpnPbrRouteEntryWeightWithOptions(request, runtime);
|
|
57764
|
+
return $tea.cast(await this.callApi(params, req, runtime), new ModifyVpnRouteEntryWeightResponse({}));
|
|
56028
57765
|
}
|
|
56029
57766
|
/**
|
|
56030
57767
|
* * **ModifyVpnRouteEntryWeight** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call [DescribeVpnGateway](~~73720~~) to query the status of the task.
|
|
@@ -56033,23 +57770,17 @@ class Client extends openapi_client_1.default {
|
|
|
56033
57770
|
* * You cannot repeatedly call the **ModifyVpnRouteEntryWeight** operation to modify the weight of destination-based route for the same VPN gateway within the specified period of time.
|
|
56034
57771
|
*
|
|
56035
57772
|
* @param request ModifyVpnRouteEntryWeightRequest
|
|
56036
|
-
* @param runtime runtime options for this request RuntimeOptions
|
|
56037
57773
|
* @return ModifyVpnRouteEntryWeightResponse
|
|
56038
57774
|
*/
|
|
56039
|
-
async
|
|
57775
|
+
async modifyVpnRouteEntryWeight(request) {
|
|
57776
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
57777
|
+
return await this.modifyVpnRouteEntryWeightWithOptions(request, runtime);
|
|
57778
|
+
}
|
|
57779
|
+
async moveResourceGroupWithOptions(request, runtime) {
|
|
56040
57780
|
tea_util_1.default.validateModel(request);
|
|
56041
57781
|
let query = {};
|
|
56042
|
-
if (!tea_util_1.default.isUnset(request.
|
|
56043
|
-
query["
|
|
56044
|
-
}
|
|
56045
|
-
if (!tea_util_1.default.isUnset(request.newWeight)) {
|
|
56046
|
-
query["NewWeight"] = request.newWeight;
|
|
56047
|
-
}
|
|
56048
|
-
if (!tea_util_1.default.isUnset(request.nextHop)) {
|
|
56049
|
-
query["NextHop"] = request.nextHop;
|
|
56050
|
-
}
|
|
56051
|
-
if (!tea_util_1.default.isUnset(request.overlayMode)) {
|
|
56052
|
-
query["OverlayMode"] = request.overlayMode;
|
|
57782
|
+
if (!tea_util_1.default.isUnset(request.newResourceGroupId)) {
|
|
57783
|
+
query["NewResourceGroupId"] = request.newResourceGroupId;
|
|
56053
57784
|
}
|
|
56054
57785
|
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
56055
57786
|
query["OwnerAccount"] = request.ownerAccount;
|
|
@@ -56060,26 +57791,23 @@ class Client extends openapi_client_1.default {
|
|
|
56060
57791
|
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
56061
57792
|
query["RegionId"] = request.regionId;
|
|
56062
57793
|
}
|
|
57794
|
+
if (!tea_util_1.default.isUnset(request.resourceId)) {
|
|
57795
|
+
query["ResourceId"] = request.resourceId;
|
|
57796
|
+
}
|
|
56063
57797
|
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
56064
57798
|
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
56065
57799
|
}
|
|
56066
57800
|
if (!tea_util_1.default.isUnset(request.resourceOwnerId)) {
|
|
56067
57801
|
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
56068
57802
|
}
|
|
56069
|
-
if (!tea_util_1.default.isUnset(request.
|
|
56070
|
-
query["
|
|
56071
|
-
}
|
|
56072
|
-
if (!tea_util_1.default.isUnset(request.vpnGatewayId)) {
|
|
56073
|
-
query["VpnGatewayId"] = request.vpnGatewayId;
|
|
56074
|
-
}
|
|
56075
|
-
if (!tea_util_1.default.isUnset(request.weight)) {
|
|
56076
|
-
query["Weight"] = request.weight;
|
|
57803
|
+
if (!tea_util_1.default.isUnset(request.resourceType)) {
|
|
57804
|
+
query["ResourceType"] = request.resourceType;
|
|
56077
57805
|
}
|
|
56078
57806
|
let req = new $OpenApi.OpenApiRequest({
|
|
56079
57807
|
query: openapi_util_1.default.query(query),
|
|
56080
57808
|
});
|
|
56081
57809
|
let params = new $OpenApi.Params({
|
|
56082
|
-
action: "
|
|
57810
|
+
action: "MoveResourceGroup",
|
|
56083
57811
|
version: "2016-04-28",
|
|
56084
57812
|
protocol: "HTTPS",
|
|
56085
57813
|
pathname: "/",
|
|
@@ -56089,24 +57817,18 @@ class Client extends openapi_client_1.default {
|
|
|
56089
57817
|
reqBodyType: "formData",
|
|
56090
57818
|
bodyType: "json",
|
|
56091
57819
|
});
|
|
56092
|
-
return $tea.cast(await this.callApi(params, req, runtime), new
|
|
57820
|
+
return $tea.cast(await this.callApi(params, req, runtime), new MoveResourceGroupResponse({}));
|
|
56093
57821
|
}
|
|
56094
|
-
|
|
56095
|
-
* * **ModifyVpnRouteEntryWeight** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call [DescribeVpnGateway](~~73720~~) to query the status of the task.
|
|
56096
|
-
* * If the VPN gateway is in the **updating** state, the weight of the destination-based route is being modified.
|
|
56097
|
-
* * If the VPN gateway is in the **active** state, the weight of the destination-based route is modified.
|
|
56098
|
-
* * You cannot repeatedly call the **ModifyVpnRouteEntryWeight** operation to modify the weight of destination-based route for the same VPN gateway within the specified period of time.
|
|
56099
|
-
*
|
|
56100
|
-
* @param request ModifyVpnRouteEntryWeightRequest
|
|
56101
|
-
* @return ModifyVpnRouteEntryWeightResponse
|
|
56102
|
-
*/
|
|
56103
|
-
async modifyVpnRouteEntryWeight(request) {
|
|
57822
|
+
async moveResourceGroup(request) {
|
|
56104
57823
|
let runtime = new $Util.RuntimeOptions({});
|
|
56105
|
-
return await this.
|
|
57824
|
+
return await this.moveResourceGroupWithOptions(request, runtime);
|
|
56106
57825
|
}
|
|
56107
|
-
async
|
|
57826
|
+
async moveVpnResourceGroupWithOptions(request, runtime) {
|
|
56108
57827
|
tea_util_1.default.validateModel(request);
|
|
56109
57828
|
let query = {};
|
|
57829
|
+
if (!tea_util_1.default.isUnset(request.instanceId)) {
|
|
57830
|
+
query["InstanceId"] = request.instanceId;
|
|
57831
|
+
}
|
|
56110
57832
|
if (!tea_util_1.default.isUnset(request.newResourceGroupId)) {
|
|
56111
57833
|
query["NewResourceGroupId"] = request.newResourceGroupId;
|
|
56112
57834
|
}
|
|
@@ -56119,9 +57841,6 @@ class Client extends openapi_client_1.default {
|
|
|
56119
57841
|
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
56120
57842
|
query["RegionId"] = request.regionId;
|
|
56121
57843
|
}
|
|
56122
|
-
if (!tea_util_1.default.isUnset(request.resourceId)) {
|
|
56123
|
-
query["ResourceId"] = request.resourceId;
|
|
56124
|
-
}
|
|
56125
57844
|
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
56126
57845
|
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
56127
57846
|
}
|
|
@@ -56135,7 +57854,7 @@ class Client extends openapi_client_1.default {
|
|
|
56135
57854
|
query: openapi_util_1.default.query(query),
|
|
56136
57855
|
});
|
|
56137
57856
|
let params = new $OpenApi.Params({
|
|
56138
|
-
action: "
|
|
57857
|
+
action: "MoveVpnResourceGroup",
|
|
56139
57858
|
version: "2016-04-28",
|
|
56140
57859
|
protocol: "HTTPS",
|
|
56141
57860
|
pathname: "/",
|
|
@@ -56145,11 +57864,11 @@ class Client extends openapi_client_1.default {
|
|
|
56145
57864
|
reqBodyType: "formData",
|
|
56146
57865
|
bodyType: "json",
|
|
56147
57866
|
});
|
|
56148
|
-
return $tea.cast(await this.callApi(params, req, runtime), new
|
|
57867
|
+
return $tea.cast(await this.callApi(params, req, runtime), new MoveVpnResourceGroupResponse({}));
|
|
56149
57868
|
}
|
|
56150
|
-
async
|
|
57869
|
+
async moveVpnResourceGroup(request) {
|
|
56151
57870
|
let runtime = new $Util.RuntimeOptions({});
|
|
56152
|
-
return await this.
|
|
57871
|
+
return await this.moveVpnResourceGroupWithOptions(request, runtime);
|
|
56153
57872
|
}
|
|
56154
57873
|
/**
|
|
56155
57874
|
* * You cannot repeatedly call the **OpenFlowLogService** operation within the specified period of time by using an Alibaba Cloud account.
|
|
@@ -56249,6 +57968,7 @@ class Client extends openapi_client_1.default {
|
|
|
56249
57968
|
return await this.openPhysicalConnectionServiceWithOptions(request, runtime);
|
|
56250
57969
|
}
|
|
56251
57970
|
/**
|
|
57971
|
+
* ## [](#)Usage notes
|
|
56252
57972
|
* You can enable traffic mirroring for different regions. You cannot repeatedly call the **OpenTrafficMirrorService** operation to enable traffic mirroring for one region within the specified period of time.
|
|
56253
57973
|
*
|
|
56254
57974
|
* @param request OpenTrafficMirrorServiceRequest
|
|
@@ -56296,6 +58016,7 @@ class Client extends openapi_client_1.default {
|
|
|
56296
58016
|
return $tea.cast(await this.callApi(params, req, runtime), new OpenTrafficMirrorServiceResponse({}));
|
|
56297
58017
|
}
|
|
56298
58018
|
/**
|
|
58019
|
+
* ## [](#)Usage notes
|
|
56299
58020
|
* You can enable traffic mirroring for different regions. You cannot repeatedly call the **OpenTrafficMirrorService** operation to enable traffic mirroring for one region within the specified period of time.
|
|
56300
58021
|
*
|
|
56301
58022
|
* @param request OpenTrafficMirrorServiceRequest
|
|
@@ -56362,6 +58083,7 @@ class Client extends openapi_client_1.default {
|
|
|
56362
58083
|
return await this.publishVpnRouteEntryWithOptions(request, runtime);
|
|
56363
58084
|
}
|
|
56364
58085
|
/**
|
|
58086
|
+
* # [](#)Description
|
|
56365
58087
|
* You can call this API operation to resume a suspended Express Connect circuit. You can resume only shared Express Connect circuits by calling this API operation.
|
|
56366
58088
|
*
|
|
56367
58089
|
* @param request RecoverPhysicalConnectionRequest
|
|
@@ -56400,6 +58122,7 @@ class Client extends openapi_client_1.default {
|
|
|
56400
58122
|
return $tea.cast(await this.callApi(params, req, runtime), new RecoverPhysicalConnectionResponse({}));
|
|
56401
58123
|
}
|
|
56402
58124
|
/**
|
|
58125
|
+
* # [](#)Description
|
|
56403
58126
|
* You can call this API operation to resume a suspended Express Connect circuit. You can resume only shared Express Connect circuits by calling this API operation.
|
|
56404
58127
|
*
|
|
56405
58128
|
* @param request RecoverPhysicalConnectionRequest
|
|
@@ -56410,7 +58133,7 @@ class Client extends openapi_client_1.default {
|
|
|
56410
58133
|
return await this.recoverPhysicalConnectionWithOptions(request, runtime);
|
|
56411
58134
|
}
|
|
56412
58135
|
/**
|
|
56413
|
-
* After the operation is called, the
|
|
58136
|
+
* After the operation is called, the VBR changes from the **terminated** state to the **recovering** state. When the VBR recovers, it enters the **active** state.
|
|
56414
58137
|
* When you call this operation, take note of the following items:
|
|
56415
58138
|
* * Only the owner of the Express Connect circuit can call this operation.
|
|
56416
58139
|
* * The Express Connect circuit to which the VBR connects must be in the **Enabled** state.
|
|
@@ -56460,7 +58183,7 @@ class Client extends openapi_client_1.default {
|
|
|
56460
58183
|
return $tea.cast(await this.callApi(params, req, runtime), new RecoverVirtualBorderRouterResponse({}));
|
|
56461
58184
|
}
|
|
56462
58185
|
/**
|
|
56463
|
-
* After the operation is called, the
|
|
58186
|
+
* After the operation is called, the VBR changes from the **terminated** state to the **recovering** state. When the VBR recovers, it enters the **active** state.
|
|
56464
58187
|
* When you call this operation, take note of the following items:
|
|
56465
58188
|
* * Only the owner of the Express Connect circuit can call this operation.
|
|
56466
58189
|
* * The Express Connect circuit to which the VBR connects must be in the **Enabled** state.
|
|
@@ -56958,6 +58681,7 @@ class Client extends openapi_client_1.default {
|
|
|
56958
58681
|
return await this.retryVpcPrefixListAssociationWithOptions(request, runtime);
|
|
56959
58682
|
}
|
|
56960
58683
|
/**
|
|
58684
|
+
* ## [](#)Usage notes
|
|
56961
58685
|
* * **RevokeInstanceFromCen** is a Virtual Private Cloud (VPC) operation. Therefore, you must use `vpc.aliyuncs.com` as the domain name when you call this operation. The API version is `2016-04-28`.
|
|
56962
58686
|
* * You cannot repeatedly call the **RevokeInstanceFromCen** operation to revoke the permissions on a network instance that is attached to a CEN instance within the specified period of time. The network instance can be a VPC, virtual border router (VBR), or a Cloud Connect Network (CCN) instance.
|
|
56963
58687
|
*
|
|
@@ -57015,6 +58739,7 @@ class Client extends openapi_client_1.default {
|
|
|
57015
58739
|
return $tea.cast(await this.callApi(params, req, runtime), new RevokeInstanceFromCenResponse({}));
|
|
57016
58740
|
}
|
|
57017
58741
|
/**
|
|
58742
|
+
* ## [](#)Usage notes
|
|
57018
58743
|
* * **RevokeInstanceFromCen** is a Virtual Private Cloud (VPC) operation. Therefore, you must use `vpc.aliyuncs.com` as the domain name when you call this operation. The API version is `2016-04-28`.
|
|
57019
58744
|
* * You cannot repeatedly call the **RevokeInstanceFromCen** operation to revoke the permissions on a network instance that is attached to a CEN instance within the specified period of time. The network instance can be a VPC, virtual border router (VBR), or a Cloud Connect Network (CCN) instance.
|
|
57020
58745
|
*
|
|
@@ -57202,8 +58927,95 @@ class Client extends openapi_client_1.default {
|
|
|
57202
58927
|
let runtime = new $Util.RuntimeOptions({});
|
|
57203
58928
|
return await this.setHighDefinitionMonitorLogStatusWithOptions(request, runtime);
|
|
57204
58929
|
}
|
|
58930
|
+
async startFailoverTestJobWithOptions(request, runtime) {
|
|
58931
|
+
tea_util_1.default.validateModel(request);
|
|
58932
|
+
let query = {};
|
|
58933
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
58934
|
+
query["ClientToken"] = request.clientToken;
|
|
58935
|
+
}
|
|
58936
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
58937
|
+
query["ClientToken"] = request.clientToken;
|
|
58938
|
+
}
|
|
58939
|
+
if (!tea_util_1.default.isUnset(request.jobId)) {
|
|
58940
|
+
query["JobId"] = request.jobId;
|
|
58941
|
+
}
|
|
58942
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
58943
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
58944
|
+
}
|
|
58945
|
+
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
58946
|
+
query["OwnerId"] = request.ownerId;
|
|
58947
|
+
}
|
|
58948
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
58949
|
+
query["RegionId"] = request.regionId;
|
|
58950
|
+
}
|
|
58951
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
58952
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
58953
|
+
}
|
|
58954
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
58955
|
+
query: openapi_util_1.default.query(query),
|
|
58956
|
+
});
|
|
58957
|
+
let params = new $OpenApi.Params({
|
|
58958
|
+
action: "StartFailoverTestJob",
|
|
58959
|
+
version: "2016-04-28",
|
|
58960
|
+
protocol: "HTTPS",
|
|
58961
|
+
pathname: "/",
|
|
58962
|
+
method: "POST",
|
|
58963
|
+
authType: "AK",
|
|
58964
|
+
style: "RPC",
|
|
58965
|
+
reqBodyType: "formData",
|
|
58966
|
+
bodyType: "json",
|
|
58967
|
+
});
|
|
58968
|
+
return $tea.cast(await this.callApi(params, req, runtime), new StartFailoverTestJobResponse({}));
|
|
58969
|
+
}
|
|
58970
|
+
async startFailoverTestJob(request) {
|
|
58971
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
58972
|
+
return await this.startFailoverTestJobWithOptions(request, runtime);
|
|
58973
|
+
}
|
|
58974
|
+
async stopFailoverTestJobWithOptions(request, runtime) {
|
|
58975
|
+
tea_util_1.default.validateModel(request);
|
|
58976
|
+
let query = {};
|
|
58977
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
58978
|
+
query["ClientToken"] = request.clientToken;
|
|
58979
|
+
}
|
|
58980
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
58981
|
+
query["ClientToken"] = request.clientToken;
|
|
58982
|
+
}
|
|
58983
|
+
if (!tea_util_1.default.isUnset(request.jobId)) {
|
|
58984
|
+
query["JobId"] = request.jobId;
|
|
58985
|
+
}
|
|
58986
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
58987
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
58988
|
+
}
|
|
58989
|
+
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
58990
|
+
query["OwnerId"] = request.ownerId;
|
|
58991
|
+
}
|
|
58992
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
58993
|
+
query["RegionId"] = request.regionId;
|
|
58994
|
+
}
|
|
58995
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
58996
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
58997
|
+
}
|
|
58998
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
58999
|
+
query: openapi_util_1.default.query(query),
|
|
59000
|
+
});
|
|
59001
|
+
let params = new $OpenApi.Params({
|
|
59002
|
+
action: "StopFailoverTestJob",
|
|
59003
|
+
version: "2016-04-28",
|
|
59004
|
+
protocol: "HTTPS",
|
|
59005
|
+
pathname: "/",
|
|
59006
|
+
method: "POST",
|
|
59007
|
+
authType: "AK",
|
|
59008
|
+
style: "RPC",
|
|
59009
|
+
reqBodyType: "formData",
|
|
59010
|
+
bodyType: "json",
|
|
59011
|
+
});
|
|
59012
|
+
return $tea.cast(await this.callApi(params, req, runtime), new StopFailoverTestJobResponse({}));
|
|
59013
|
+
}
|
|
59014
|
+
async stopFailoverTestJob(request) {
|
|
59015
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
59016
|
+
return await this.stopFailoverTestJobWithOptions(request, runtime);
|
|
59017
|
+
}
|
|
57205
59018
|
/**
|
|
57206
|
-
* ## Usage notes
|
|
57207
59019
|
* Tags are used to classify instances. Each tag consists of a key-value pair. Before you use tags, take note of the following limits:
|
|
57208
59020
|
* * The keys of tags that are added to the same instance must be unique.
|
|
57209
59021
|
* * You cannot create tags without adding them to instances. All tags must be added to instances.
|
|
@@ -57261,7 +59073,6 @@ class Client extends openapi_client_1.default {
|
|
|
57261
59073
|
return $tea.cast(await this.callApi(params, req, runtime), new TagResourcesResponse({}));
|
|
57262
59074
|
}
|
|
57263
59075
|
/**
|
|
57264
|
-
* ## Usage notes
|
|
57265
59076
|
* Tags are used to classify instances. Each tag consists of a key-value pair. Before you use tags, take note of the following limits:
|
|
57266
59077
|
* * The keys of tags that are added to the same instance must be unique.
|
|
57267
59078
|
* * You cannot create tags without adding them to instances. All tags must be added to instances.
|
|
@@ -57279,12 +59090,13 @@ class Client extends openapi_client_1.default {
|
|
|
57279
59090
|
return await this.tagResourcesWithOptions(request, runtime);
|
|
57280
59091
|
}
|
|
57281
59092
|
/**
|
|
57282
|
-
*
|
|
57283
|
-
*
|
|
59093
|
+
* ## [](#)
|
|
59094
|
+
* Tags are used to classify instances. Each tag consists of a key-value pair. Before you use tags, take note of the following items:
|
|
59095
|
+
* * Each tag key that is added to an instance must be unique.
|
|
57284
59096
|
* * You cannot create tags without adding them to instances. All tags must be added to instances.
|
|
57285
59097
|
* * Tag information is not shared across regions.
|
|
57286
59098
|
* For example, you cannot view the tags that are created in the China (Hangzhou) region from the China (Shanghai) region.
|
|
57287
|
-
* * You can add up to 20 tags to each instance. Before you add a tag to an instance, the system automatically checks the number of existing tags.
|
|
59099
|
+
* * You can add up to 20 tags to each instance. Before you add a tag to an instance, the system automatically checks the number of existing tags. An error message is returned if the maximum number of tags is reached.
|
|
57288
59100
|
*
|
|
57289
59101
|
* @param request TagResourcesForExpressConnectRequest
|
|
57290
59102
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -57334,12 +59146,13 @@ class Client extends openapi_client_1.default {
|
|
|
57334
59146
|
return $tea.cast(await this.callApi(params, req, runtime), new TagResourcesForExpressConnectResponse({}));
|
|
57335
59147
|
}
|
|
57336
59148
|
/**
|
|
57337
|
-
*
|
|
57338
|
-
*
|
|
59149
|
+
* ## [](#)
|
|
59150
|
+
* Tags are used to classify instances. Each tag consists of a key-value pair. Before you use tags, take note of the following items:
|
|
59151
|
+
* * Each tag key that is added to an instance must be unique.
|
|
57339
59152
|
* * You cannot create tags without adding them to instances. All tags must be added to instances.
|
|
57340
59153
|
* * Tag information is not shared across regions.
|
|
57341
59154
|
* For example, you cannot view the tags that are created in the China (Hangzhou) region from the China (Shanghai) region.
|
|
57342
|
-
* * You can add up to 20 tags to each instance. Before you add a tag to an instance, the system automatically checks the number of existing tags.
|
|
59155
|
+
* * You can add up to 20 tags to each instance. Before you add a tag to an instance, the system automatically checks the number of existing tags. An error message is returned if the maximum number of tags is reached.
|
|
57343
59156
|
*
|
|
57344
59157
|
* @param request TagResourcesForExpressConnectRequest
|
|
57345
59158
|
* @return TagResourcesForExpressConnectResponse
|
|
@@ -57349,9 +59162,8 @@ class Client extends openapi_client_1.default {
|
|
|
57349
59162
|
return await this.tagResourcesForExpressConnectWithOptions(request, runtime);
|
|
57350
59163
|
}
|
|
57351
59164
|
/**
|
|
57352
|
-
* After you call this operation, the specified Express Connect circuit changes to the **Terminating** state. After the Express Connect circuit is disabled, it changes to the **Terminated** state.
|
|
57353
|
-
*
|
|
57354
|
-
* * You can only terminate an Express Connect circuit that is in the **Enabled** state.
|
|
59165
|
+
* After you call this operation, the specified Express Connect circuit changes to the **Terminating** state. After the Express Connect circuit is disabled, it changes to the **Terminated** state. When you call this operation, take note of the following limits:
|
|
59166
|
+
* * You can only disable an Express Connect circuit that is in the **Enabled** state.
|
|
57355
59167
|
* * Before you disable an Express Connect circuit, you must delete the virtual border routers (VBRs) associated with it.
|
|
57356
59168
|
*
|
|
57357
59169
|
* @param request TerminatePhysicalConnectionRequest
|
|
@@ -57399,9 +59211,8 @@ class Client extends openapi_client_1.default {
|
|
|
57399
59211
|
return $tea.cast(await this.callApi(params, req, runtime), new TerminatePhysicalConnectionResponse({}));
|
|
57400
59212
|
}
|
|
57401
59213
|
/**
|
|
57402
|
-
* After you call this operation, the specified Express Connect circuit changes to the **Terminating** state. After the Express Connect circuit is disabled, it changes to the **Terminated** state.
|
|
57403
|
-
*
|
|
57404
|
-
* * You can only terminate an Express Connect circuit that is in the **Enabled** state.
|
|
59214
|
+
* After you call this operation, the specified Express Connect circuit changes to the **Terminating** state. After the Express Connect circuit is disabled, it changes to the **Terminated** state. When you call this operation, take note of the following limits:
|
|
59215
|
+
* * You can only disable an Express Connect circuit that is in the **Enabled** state.
|
|
57405
59216
|
* * Before you disable an Express Connect circuit, you must delete the virtual border routers (VBRs) associated with it.
|
|
57406
59217
|
*
|
|
57407
59218
|
* @param request TerminatePhysicalConnectionRequest
|
|
@@ -57412,7 +59223,7 @@ class Client extends openapi_client_1.default {
|
|
|
57412
59223
|
return await this.terminatePhysicalConnectionWithOptions(request, runtime);
|
|
57413
59224
|
}
|
|
57414
59225
|
/**
|
|
57415
|
-
* After the operation is
|
|
59226
|
+
* After the operation is performed, the VBR changes from the **active** state to the **terminating** state. After the VBR is terminated, it enters the **terminated** state.
|
|
57416
59227
|
* > Only the owner of an Express Connect circuit can call this operation.
|
|
57417
59228
|
*
|
|
57418
59229
|
* @param request TerminateVirtualBorderRouterRequest
|
|
@@ -57460,7 +59271,7 @@ class Client extends openapi_client_1.default {
|
|
|
57460
59271
|
return $tea.cast(await this.callApi(params, req, runtime), new TerminateVirtualBorderRouterResponse({}));
|
|
57461
59272
|
}
|
|
57462
59273
|
/**
|
|
57463
|
-
* After the operation is
|
|
59274
|
+
* After the operation is performed, the VBR changes from the **active** state to the **terminating** state. After the VBR is terminated, it enters the **terminated** state.
|
|
57464
59275
|
* > Only the owner of an Express Connect circuit can call this operation.
|
|
57465
59276
|
*
|
|
57466
59277
|
* @param request TerminateVirtualBorderRouterRequest
|
|
@@ -57640,10 +59451,11 @@ class Client extends openapi_client_1.default {
|
|
|
57640
59451
|
return await this.unassociateGlobalAccelerationInstanceWithOptions(request, runtime);
|
|
57641
59452
|
}
|
|
57642
59453
|
/**
|
|
59454
|
+
* ## [](#)
|
|
57643
59455
|
* When you call this operation, take note of the following limits:
|
|
57644
59456
|
* * The ECS instance must be in the **Running** or **Stopped** state.
|
|
57645
59457
|
* * The HAVIP must be in the **Available** or **InUse** state.
|
|
57646
|
-
* *
|
|
59458
|
+
* * **UnassociateHaVip** is an asynchronous operation. After a request is sent, the system returns a request ID and an instance ID and runs the task in the background. You can call the [DescribeHaVips](~~114611~~) operation to query the status of an HAVIP:
|
|
57647
59459
|
* * If the HAVIP is in the **Unassociating** state, the HAVIP is being disassociated.
|
|
57648
59460
|
* * If the HAVIP is in the **Inuse** or **Available** state, the HAVIP is disassociated.
|
|
57649
59461
|
* * You cannot repeatedly call the **UnassociateHaVip** operation to disassociate an HAVIP within the specified period of time.
|
|
@@ -57702,10 +59514,11 @@ class Client extends openapi_client_1.default {
|
|
|
57702
59514
|
return $tea.cast(await this.callApi(params, req, runtime), new UnassociateHaVipResponse({}));
|
|
57703
59515
|
}
|
|
57704
59516
|
/**
|
|
59517
|
+
* ## [](#)
|
|
57705
59518
|
* When you call this operation, take note of the following limits:
|
|
57706
59519
|
* * The ECS instance must be in the **Running** or **Stopped** state.
|
|
57707
59520
|
* * The HAVIP must be in the **Available** or **InUse** state.
|
|
57708
|
-
* *
|
|
59521
|
+
* * **UnassociateHaVip** is an asynchronous operation. After a request is sent, the system returns a request ID and an instance ID and runs the task in the background. You can call the [DescribeHaVips](~~114611~~) operation to query the status of an HAVIP:
|
|
57709
59522
|
* * If the HAVIP is in the **Unassociating** state, the HAVIP is being disassociated.
|
|
57710
59523
|
* * If the HAVIP is in the **Inuse** or **Available** state, the HAVIP is disassociated.
|
|
57711
59524
|
* * You cannot repeatedly call the **UnassociateHaVip** operation to disassociate an HAVIP within the specified period of time.
|
|
@@ -57718,7 +59531,8 @@ class Client extends openapi_client_1.default {
|
|
|
57718
59531
|
return await this.unassociateHaVipWithOptions(request, runtime);
|
|
57719
59532
|
}
|
|
57720
59533
|
/**
|
|
57721
|
-
*
|
|
59534
|
+
* ## [](#)Description
|
|
59535
|
+
* * **UnassociateNetworkAcl** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeNetworkAclAttributes](~~116542~~) operation to query the status of the task.
|
|
57722
59536
|
* * If the network ACL is in the **UNBINDING** state, the network ACL is being disassociated from the vSwitch.
|
|
57723
59537
|
* * If the network ACL is in the **UNBINDED** state, the network ACL is disassociated from the vSwitch.
|
|
57724
59538
|
* * You cannot repeatedly call the **UnassociateNetworkAcl** operation to disassociate a network ACL from a vSwitch within the specified period of time.
|
|
@@ -57733,9 +59547,15 @@ class Client extends openapi_client_1.default {
|
|
|
57733
59547
|
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
57734
59548
|
query["ClientToken"] = request.clientToken;
|
|
57735
59549
|
}
|
|
59550
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
59551
|
+
query["DryRun"] = request.dryRun;
|
|
59552
|
+
}
|
|
57736
59553
|
if (!tea_util_1.default.isUnset(request.networkAclId)) {
|
|
57737
59554
|
query["NetworkAclId"] = request.networkAclId;
|
|
57738
59555
|
}
|
|
59556
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
59557
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
59558
|
+
}
|
|
57739
59559
|
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
57740
59560
|
query["OwnerId"] = request.ownerId;
|
|
57741
59561
|
}
|
|
@@ -57771,7 +59591,8 @@ class Client extends openapi_client_1.default {
|
|
|
57771
59591
|
return $tea.cast(await this.callApi(params, req, runtime), new UnassociateNetworkAclResponse({}));
|
|
57772
59592
|
}
|
|
57773
59593
|
/**
|
|
57774
|
-
*
|
|
59594
|
+
* ## [](#)Description
|
|
59595
|
+
* * **UnassociateNetworkAcl** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeNetworkAclAttributes](~~116542~~) operation to query the status of the task.
|
|
57775
59596
|
* * If the network ACL is in the **UNBINDING** state, the network ACL is being disassociated from the vSwitch.
|
|
57776
59597
|
* * If the network ACL is in the **UNBINDED** state, the network ACL is disassociated from the vSwitch.
|
|
57777
59598
|
* * You cannot repeatedly call the **UnassociateNetworkAcl** operation to disassociate a network ACL from a vSwitch within the specified period of time.
|
|
@@ -57831,7 +59652,8 @@ class Client extends openapi_client_1.default {
|
|
|
57831
59652
|
return await this.unassociatePhysicalConnectionFromVirtualBorderRouterWithOptions(request, runtime);
|
|
57832
59653
|
}
|
|
57833
59654
|
/**
|
|
57834
|
-
*
|
|
59655
|
+
* ## [](#)References
|
|
59656
|
+
* * **UnassociateRouteTable** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeVSwitchAttributes](~~94567~~) operation to query the status of the task.
|
|
57835
59657
|
* * If the vSwitch is in the **Pending** state, the route table is being disassociated.
|
|
57836
59658
|
* * If the vSwitch is in the **Available** state, the route table is disassociated.
|
|
57837
59659
|
* * You cannot repeatedly call the **UnassociateRouteTable** operation to disassociate a route table from a vSwitch within the specified period of time.
|
|
@@ -57887,7 +59709,8 @@ class Client extends openapi_client_1.default {
|
|
|
57887
59709
|
return $tea.cast(await this.callApi(params, req, runtime), new UnassociateRouteTableResponse({}));
|
|
57888
59710
|
}
|
|
57889
59711
|
/**
|
|
57890
|
-
*
|
|
59712
|
+
* ## [](#)References
|
|
59713
|
+
* * **UnassociateRouteTable** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeVSwitchAttributes](~~94567~~) operation to query the status of the task.
|
|
57891
59714
|
* * If the vSwitch is in the **Pending** state, the route table is being disassociated.
|
|
57892
59715
|
* * If the vSwitch is in the **Available** state, the route table is disassociated.
|
|
57893
59716
|
* * You cannot repeatedly call the **UnassociateRouteTable** operation to disassociate a route table from a vSwitch within the specified period of time.
|
|
@@ -58079,6 +59902,62 @@ class Client extends openapi_client_1.default {
|
|
|
58079
59902
|
let runtime = new $Util.RuntimeOptions({});
|
|
58080
59903
|
return await this.updateDhcpOptionsSetAttributeWithOptions(request, runtime);
|
|
58081
59904
|
}
|
|
59905
|
+
async updateFailoverTestJobWithOptions(request, runtime) {
|
|
59906
|
+
tea_util_1.default.validateModel(request);
|
|
59907
|
+
let query = {};
|
|
59908
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
59909
|
+
query["ClientToken"] = request.clientToken;
|
|
59910
|
+
}
|
|
59911
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
59912
|
+
query["ClientToken"] = request.clientToken;
|
|
59913
|
+
}
|
|
59914
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
59915
|
+
query["Description"] = request.description;
|
|
59916
|
+
}
|
|
59917
|
+
if (!tea_util_1.default.isUnset(request.jobDuration)) {
|
|
59918
|
+
query["JobDuration"] = request.jobDuration;
|
|
59919
|
+
}
|
|
59920
|
+
if (!tea_util_1.default.isUnset(request.jobId)) {
|
|
59921
|
+
query["JobId"] = request.jobId;
|
|
59922
|
+
}
|
|
59923
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
59924
|
+
query["Name"] = request.name;
|
|
59925
|
+
}
|
|
59926
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
59927
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
59928
|
+
}
|
|
59929
|
+
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
59930
|
+
query["OwnerId"] = request.ownerId;
|
|
59931
|
+
}
|
|
59932
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
59933
|
+
query["RegionId"] = request.regionId;
|
|
59934
|
+
}
|
|
59935
|
+
if (!tea_util_1.default.isUnset(request.resourceId)) {
|
|
59936
|
+
query["ResourceId"] = request.resourceId;
|
|
59937
|
+
}
|
|
59938
|
+
if (!tea_util_1.default.isUnset(request.resourceOwnerAccount)) {
|
|
59939
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
59940
|
+
}
|
|
59941
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
59942
|
+
query: openapi_util_1.default.query(query),
|
|
59943
|
+
});
|
|
59944
|
+
let params = new $OpenApi.Params({
|
|
59945
|
+
action: "UpdateFailoverTestJob",
|
|
59946
|
+
version: "2016-04-28",
|
|
59947
|
+
protocol: "HTTPS",
|
|
59948
|
+
pathname: "/",
|
|
59949
|
+
method: "POST",
|
|
59950
|
+
authType: "AK",
|
|
59951
|
+
style: "RPC",
|
|
59952
|
+
reqBodyType: "formData",
|
|
59953
|
+
bodyType: "json",
|
|
59954
|
+
});
|
|
59955
|
+
return $tea.cast(await this.callApi(params, req, runtime), new UpdateFailoverTestJobResponse({}));
|
|
59956
|
+
}
|
|
59957
|
+
async updateFailoverTestJob(request) {
|
|
59958
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
59959
|
+
return await this.updateFailoverTestJobWithOptions(request, runtime);
|
|
59960
|
+
}
|
|
58082
59961
|
async updateGatewayRouteTableEntryAttributeWithOptions(request, runtime) {
|
|
58083
59962
|
tea_util_1.default.validateModel(request);
|
|
58084
59963
|
let query = {};
|
|
@@ -58382,7 +60261,7 @@ class Client extends openapi_client_1.default {
|
|
|
58382
60261
|
return await this.updateNatGatewayNatTypeWithOptions(request, runtime);
|
|
58383
60262
|
}
|
|
58384
60263
|
/**
|
|
58385
|
-
* *
|
|
60264
|
+
* * **UpdateNetworkAclEntries** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeNetworkAclAttributes](~~116542~~) operation to query the status of a network ACL:
|
|
58386
60265
|
* * If the network ACL is in the **Modifying** state, the rules of the network ACL are being updated.
|
|
58387
60266
|
* * If the network ACL is in the **Available** state, the rules of the network ACL are updated.
|
|
58388
60267
|
* * You cannot repeatedly call the **UpdateNetworkAclEntries** operation to update the rules of a network ACL within the specified period of time.
|
|
@@ -58397,6 +60276,9 @@ class Client extends openapi_client_1.default {
|
|
|
58397
60276
|
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
58398
60277
|
query["ClientToken"] = request.clientToken;
|
|
58399
60278
|
}
|
|
60279
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
60280
|
+
query["DryRun"] = request.dryRun;
|
|
60281
|
+
}
|
|
58400
60282
|
if (!tea_util_1.default.isUnset(request.egressAclEntries)) {
|
|
58401
60283
|
query["EgressAclEntries"] = request.egressAclEntries;
|
|
58402
60284
|
}
|
|
@@ -58406,6 +60288,9 @@ class Client extends openapi_client_1.default {
|
|
|
58406
60288
|
if (!tea_util_1.default.isUnset(request.networkAclId)) {
|
|
58407
60289
|
query["NetworkAclId"] = request.networkAclId;
|
|
58408
60290
|
}
|
|
60291
|
+
if (!tea_util_1.default.isUnset(request.ownerAccount)) {
|
|
60292
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
60293
|
+
}
|
|
58409
60294
|
if (!tea_util_1.default.isUnset(request.ownerId)) {
|
|
58410
60295
|
query["OwnerId"] = request.ownerId;
|
|
58411
60296
|
}
|
|
@@ -58444,7 +60329,7 @@ class Client extends openapi_client_1.default {
|
|
|
58444
60329
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateNetworkAclEntriesResponse({}));
|
|
58445
60330
|
}
|
|
58446
60331
|
/**
|
|
58447
|
-
* *
|
|
60332
|
+
* * **UpdateNetworkAclEntries** is an asynchronous operation. After a request is sent, the system returns a request ID and runs the task in the background. You can call the [DescribeNetworkAclAttributes](~~116542~~) operation to query the status of a network ACL:
|
|
58448
60333
|
* * If the network ACL is in the **Modifying** state, the rules of the network ACL are being updated.
|
|
58449
60334
|
* * If the network ACL is in the **Available** state, the rules of the network ACL are updated.
|
|
58450
60335
|
* * You cannot repeatedly call the **UpdateNetworkAclEntries** operation to update the rules of a network ACL within the specified period of time.
|