@alicloud/vpc20160428 6.3.2 → 6.4.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 +1005 -104
- package/dist/client.js +6807 -4748
- package/dist/client.js.map +1 -1
- package/package.json +5 -5
- package/src/client.ts +2864 -304
package/src/client.ts
CHANGED
|
@@ -640,15 +640,18 @@ export class AddPublicIpAddressPoolCidrBlockRequest extends $tea.Model {
|
|
|
640
640
|
}
|
|
641
641
|
|
|
642
642
|
export class AddPublicIpAddressPoolCidrBlockResponseBody extends $tea.Model {
|
|
643
|
+
cidrBlock?: string;
|
|
643
644
|
requestId?: string;
|
|
644
645
|
static names(): { [key: string]: string } {
|
|
645
646
|
return {
|
|
647
|
+
cidrBlock: 'CidrBlock',
|
|
646
648
|
requestId: 'RequestId',
|
|
647
649
|
};
|
|
648
650
|
}
|
|
649
651
|
|
|
650
652
|
static types(): { [key: string]: any } {
|
|
651
653
|
return {
|
|
654
|
+
cidrBlock: 'string',
|
|
652
655
|
requestId: 'string',
|
|
653
656
|
};
|
|
654
657
|
}
|
|
@@ -4259,6 +4262,312 @@ export class CreateExpressCloudConnectionResponse extends $tea.Model {
|
|
|
4259
4262
|
}
|
|
4260
4263
|
}
|
|
4261
4264
|
|
|
4265
|
+
export class CreateExpressConnectTrafficQosRequest extends $tea.Model {
|
|
4266
|
+
clientToken?: string;
|
|
4267
|
+
ownerAccount?: string;
|
|
4268
|
+
ownerId?: number;
|
|
4269
|
+
qosDescription?: string;
|
|
4270
|
+
qosName?: string;
|
|
4271
|
+
regionId?: string;
|
|
4272
|
+
resourceOwnerAccount?: string;
|
|
4273
|
+
static names(): { [key: string]: string } {
|
|
4274
|
+
return {
|
|
4275
|
+
clientToken: 'ClientToken',
|
|
4276
|
+
ownerAccount: 'OwnerAccount',
|
|
4277
|
+
ownerId: 'OwnerId',
|
|
4278
|
+
qosDescription: 'QosDescription',
|
|
4279
|
+
qosName: 'QosName',
|
|
4280
|
+
regionId: 'RegionId',
|
|
4281
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
4282
|
+
};
|
|
4283
|
+
}
|
|
4284
|
+
|
|
4285
|
+
static types(): { [key: string]: any } {
|
|
4286
|
+
return {
|
|
4287
|
+
clientToken: 'string',
|
|
4288
|
+
ownerAccount: 'string',
|
|
4289
|
+
ownerId: 'number',
|
|
4290
|
+
qosDescription: 'string',
|
|
4291
|
+
qosName: 'string',
|
|
4292
|
+
regionId: 'string',
|
|
4293
|
+
resourceOwnerAccount: 'string',
|
|
4294
|
+
};
|
|
4295
|
+
}
|
|
4296
|
+
|
|
4297
|
+
constructor(map?: { [key: string]: any }) {
|
|
4298
|
+
super(map);
|
|
4299
|
+
}
|
|
4300
|
+
}
|
|
4301
|
+
|
|
4302
|
+
export class CreateExpressConnectTrafficQosResponseBody extends $tea.Model {
|
|
4303
|
+
qosId?: string;
|
|
4304
|
+
requestId?: string;
|
|
4305
|
+
static names(): { [key: string]: string } {
|
|
4306
|
+
return {
|
|
4307
|
+
qosId: 'QosId',
|
|
4308
|
+
requestId: 'RequestId',
|
|
4309
|
+
};
|
|
4310
|
+
}
|
|
4311
|
+
|
|
4312
|
+
static types(): { [key: string]: any } {
|
|
4313
|
+
return {
|
|
4314
|
+
qosId: 'string',
|
|
4315
|
+
requestId: 'string',
|
|
4316
|
+
};
|
|
4317
|
+
}
|
|
4318
|
+
|
|
4319
|
+
constructor(map?: { [key: string]: any }) {
|
|
4320
|
+
super(map);
|
|
4321
|
+
}
|
|
4322
|
+
}
|
|
4323
|
+
|
|
4324
|
+
export class CreateExpressConnectTrafficQosResponse extends $tea.Model {
|
|
4325
|
+
headers?: { [key: string]: string };
|
|
4326
|
+
statusCode?: number;
|
|
4327
|
+
body?: CreateExpressConnectTrafficQosResponseBody;
|
|
4328
|
+
static names(): { [key: string]: string } {
|
|
4329
|
+
return {
|
|
4330
|
+
headers: 'headers',
|
|
4331
|
+
statusCode: 'statusCode',
|
|
4332
|
+
body: 'body',
|
|
4333
|
+
};
|
|
4334
|
+
}
|
|
4335
|
+
|
|
4336
|
+
static types(): { [key: string]: any } {
|
|
4337
|
+
return {
|
|
4338
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
4339
|
+
statusCode: 'number',
|
|
4340
|
+
body: CreateExpressConnectTrafficQosResponseBody,
|
|
4341
|
+
};
|
|
4342
|
+
}
|
|
4343
|
+
|
|
4344
|
+
constructor(map?: { [key: string]: any }) {
|
|
4345
|
+
super(map);
|
|
4346
|
+
}
|
|
4347
|
+
}
|
|
4348
|
+
|
|
4349
|
+
export class CreateExpressConnectTrafficQosQueueRequest extends $tea.Model {
|
|
4350
|
+
bandwidthPercent?: string;
|
|
4351
|
+
clientToken?: string;
|
|
4352
|
+
ownerAccount?: string;
|
|
4353
|
+
ownerId?: number;
|
|
4354
|
+
qosId?: string;
|
|
4355
|
+
queueDescription?: string;
|
|
4356
|
+
queueName?: string;
|
|
4357
|
+
queueType?: string;
|
|
4358
|
+
regionId?: string;
|
|
4359
|
+
resourceOwnerAccount?: string;
|
|
4360
|
+
static names(): { [key: string]: string } {
|
|
4361
|
+
return {
|
|
4362
|
+
bandwidthPercent: 'BandwidthPercent',
|
|
4363
|
+
clientToken: 'ClientToken',
|
|
4364
|
+
ownerAccount: 'OwnerAccount',
|
|
4365
|
+
ownerId: 'OwnerId',
|
|
4366
|
+
qosId: 'QosId',
|
|
4367
|
+
queueDescription: 'QueueDescription',
|
|
4368
|
+
queueName: 'QueueName',
|
|
4369
|
+
queueType: 'QueueType',
|
|
4370
|
+
regionId: 'RegionId',
|
|
4371
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
4372
|
+
};
|
|
4373
|
+
}
|
|
4374
|
+
|
|
4375
|
+
static types(): { [key: string]: any } {
|
|
4376
|
+
return {
|
|
4377
|
+
bandwidthPercent: 'string',
|
|
4378
|
+
clientToken: 'string',
|
|
4379
|
+
ownerAccount: 'string',
|
|
4380
|
+
ownerId: 'number',
|
|
4381
|
+
qosId: 'string',
|
|
4382
|
+
queueDescription: 'string',
|
|
4383
|
+
queueName: 'string',
|
|
4384
|
+
queueType: 'string',
|
|
4385
|
+
regionId: 'string',
|
|
4386
|
+
resourceOwnerAccount: 'string',
|
|
4387
|
+
};
|
|
4388
|
+
}
|
|
4389
|
+
|
|
4390
|
+
constructor(map?: { [key: string]: any }) {
|
|
4391
|
+
super(map);
|
|
4392
|
+
}
|
|
4393
|
+
}
|
|
4394
|
+
|
|
4395
|
+
export class CreateExpressConnectTrafficQosQueueResponseBody extends $tea.Model {
|
|
4396
|
+
qosId?: string;
|
|
4397
|
+
queueId?: string;
|
|
4398
|
+
requestId?: string;
|
|
4399
|
+
static names(): { [key: string]: string } {
|
|
4400
|
+
return {
|
|
4401
|
+
qosId: 'QosId',
|
|
4402
|
+
queueId: 'QueueId',
|
|
4403
|
+
requestId: 'RequestId',
|
|
4404
|
+
};
|
|
4405
|
+
}
|
|
4406
|
+
|
|
4407
|
+
static types(): { [key: string]: any } {
|
|
4408
|
+
return {
|
|
4409
|
+
qosId: 'string',
|
|
4410
|
+
queueId: 'string',
|
|
4411
|
+
requestId: 'string',
|
|
4412
|
+
};
|
|
4413
|
+
}
|
|
4414
|
+
|
|
4415
|
+
constructor(map?: { [key: string]: any }) {
|
|
4416
|
+
super(map);
|
|
4417
|
+
}
|
|
4418
|
+
}
|
|
4419
|
+
|
|
4420
|
+
export class CreateExpressConnectTrafficQosQueueResponse extends $tea.Model {
|
|
4421
|
+
headers?: { [key: string]: string };
|
|
4422
|
+
statusCode?: number;
|
|
4423
|
+
body?: CreateExpressConnectTrafficQosQueueResponseBody;
|
|
4424
|
+
static names(): { [key: string]: string } {
|
|
4425
|
+
return {
|
|
4426
|
+
headers: 'headers',
|
|
4427
|
+
statusCode: 'statusCode',
|
|
4428
|
+
body: 'body',
|
|
4429
|
+
};
|
|
4430
|
+
}
|
|
4431
|
+
|
|
4432
|
+
static types(): { [key: string]: any } {
|
|
4433
|
+
return {
|
|
4434
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
4435
|
+
statusCode: 'number',
|
|
4436
|
+
body: CreateExpressConnectTrafficQosQueueResponseBody,
|
|
4437
|
+
};
|
|
4438
|
+
}
|
|
4439
|
+
|
|
4440
|
+
constructor(map?: { [key: string]: any }) {
|
|
4441
|
+
super(map);
|
|
4442
|
+
}
|
|
4443
|
+
}
|
|
4444
|
+
|
|
4445
|
+
export class CreateExpressConnectTrafficQosRuleRequest extends $tea.Model {
|
|
4446
|
+
clientToken?: string;
|
|
4447
|
+
dstCidr?: string;
|
|
4448
|
+
dstIPv6Cidr?: string;
|
|
4449
|
+
dstPortRange?: string;
|
|
4450
|
+
matchDscp?: number;
|
|
4451
|
+
ownerAccount?: string;
|
|
4452
|
+
ownerId?: number;
|
|
4453
|
+
priority?: number;
|
|
4454
|
+
protocol?: string;
|
|
4455
|
+
qosId?: string;
|
|
4456
|
+
queueId?: string;
|
|
4457
|
+
regionId?: string;
|
|
4458
|
+
remarkingDscp?: number;
|
|
4459
|
+
resourceOwnerAccount?: string;
|
|
4460
|
+
ruleDescription?: string;
|
|
4461
|
+
ruleName?: string;
|
|
4462
|
+
srcCidr?: string;
|
|
4463
|
+
srcIPv6Cidr?: string;
|
|
4464
|
+
srcPortRange?: string;
|
|
4465
|
+
static names(): { [key: string]: string } {
|
|
4466
|
+
return {
|
|
4467
|
+
clientToken: 'ClientToken',
|
|
4468
|
+
dstCidr: 'DstCidr',
|
|
4469
|
+
dstIPv6Cidr: 'DstIPv6Cidr',
|
|
4470
|
+
dstPortRange: 'DstPortRange',
|
|
4471
|
+
matchDscp: 'MatchDscp',
|
|
4472
|
+
ownerAccount: 'OwnerAccount',
|
|
4473
|
+
ownerId: 'OwnerId',
|
|
4474
|
+
priority: 'Priority',
|
|
4475
|
+
protocol: 'Protocol',
|
|
4476
|
+
qosId: 'QosId',
|
|
4477
|
+
queueId: 'QueueId',
|
|
4478
|
+
regionId: 'RegionId',
|
|
4479
|
+
remarkingDscp: 'RemarkingDscp',
|
|
4480
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
4481
|
+
ruleDescription: 'RuleDescription',
|
|
4482
|
+
ruleName: 'RuleName',
|
|
4483
|
+
srcCidr: 'SrcCidr',
|
|
4484
|
+
srcIPv6Cidr: 'SrcIPv6Cidr',
|
|
4485
|
+
srcPortRange: 'SrcPortRange',
|
|
4486
|
+
};
|
|
4487
|
+
}
|
|
4488
|
+
|
|
4489
|
+
static types(): { [key: string]: any } {
|
|
4490
|
+
return {
|
|
4491
|
+
clientToken: 'string',
|
|
4492
|
+
dstCidr: 'string',
|
|
4493
|
+
dstIPv6Cidr: 'string',
|
|
4494
|
+
dstPortRange: 'string',
|
|
4495
|
+
matchDscp: 'number',
|
|
4496
|
+
ownerAccount: 'string',
|
|
4497
|
+
ownerId: 'number',
|
|
4498
|
+
priority: 'number',
|
|
4499
|
+
protocol: 'string',
|
|
4500
|
+
qosId: 'string',
|
|
4501
|
+
queueId: 'string',
|
|
4502
|
+
regionId: 'string',
|
|
4503
|
+
remarkingDscp: 'number',
|
|
4504
|
+
resourceOwnerAccount: 'string',
|
|
4505
|
+
ruleDescription: 'string',
|
|
4506
|
+
ruleName: 'string',
|
|
4507
|
+
srcCidr: 'string',
|
|
4508
|
+
srcIPv6Cidr: 'string',
|
|
4509
|
+
srcPortRange: 'string',
|
|
4510
|
+
};
|
|
4511
|
+
}
|
|
4512
|
+
|
|
4513
|
+
constructor(map?: { [key: string]: any }) {
|
|
4514
|
+
super(map);
|
|
4515
|
+
}
|
|
4516
|
+
}
|
|
4517
|
+
|
|
4518
|
+
export class CreateExpressConnectTrafficQosRuleResponseBody extends $tea.Model {
|
|
4519
|
+
qosId?: string;
|
|
4520
|
+
queueId?: string;
|
|
4521
|
+
requestId?: string;
|
|
4522
|
+
ruleId?: string;
|
|
4523
|
+
static names(): { [key: string]: string } {
|
|
4524
|
+
return {
|
|
4525
|
+
qosId: 'QosId',
|
|
4526
|
+
queueId: 'QueueId',
|
|
4527
|
+
requestId: 'RequestId',
|
|
4528
|
+
ruleId: 'RuleId',
|
|
4529
|
+
};
|
|
4530
|
+
}
|
|
4531
|
+
|
|
4532
|
+
static types(): { [key: string]: any } {
|
|
4533
|
+
return {
|
|
4534
|
+
qosId: 'string',
|
|
4535
|
+
queueId: 'string',
|
|
4536
|
+
requestId: 'string',
|
|
4537
|
+
ruleId: 'string',
|
|
4538
|
+
};
|
|
4539
|
+
}
|
|
4540
|
+
|
|
4541
|
+
constructor(map?: { [key: string]: any }) {
|
|
4542
|
+
super(map);
|
|
4543
|
+
}
|
|
4544
|
+
}
|
|
4545
|
+
|
|
4546
|
+
export class CreateExpressConnectTrafficQosRuleResponse extends $tea.Model {
|
|
4547
|
+
headers?: { [key: string]: string };
|
|
4548
|
+
statusCode?: number;
|
|
4549
|
+
body?: CreateExpressConnectTrafficQosRuleResponseBody;
|
|
4550
|
+
static names(): { [key: string]: string } {
|
|
4551
|
+
return {
|
|
4552
|
+
headers: 'headers',
|
|
4553
|
+
statusCode: 'statusCode',
|
|
4554
|
+
body: 'body',
|
|
4555
|
+
};
|
|
4556
|
+
}
|
|
4557
|
+
|
|
4558
|
+
static types(): { [key: string]: any } {
|
|
4559
|
+
return {
|
|
4560
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
4561
|
+
statusCode: 'number',
|
|
4562
|
+
body: CreateExpressConnectTrafficQosRuleResponseBody,
|
|
4563
|
+
};
|
|
4564
|
+
}
|
|
4565
|
+
|
|
4566
|
+
constructor(map?: { [key: string]: any }) {
|
|
4567
|
+
super(map);
|
|
4568
|
+
}
|
|
4569
|
+
}
|
|
4570
|
+
|
|
4262
4571
|
export class CreateFailoverTestJobRequest extends $tea.Model {
|
|
4263
4572
|
clientToken?: string;
|
|
4264
4573
|
description?: string;
|
|
@@ -6523,11 +6832,13 @@ export class CreatePublicIpAddressPoolRequest extends $tea.Model {
|
|
|
6523
6832
|
}
|
|
6524
6833
|
|
|
6525
6834
|
export class CreatePublicIpAddressPoolResponseBody extends $tea.Model {
|
|
6835
|
+
publicIpAddressPoolId?: string;
|
|
6526
6836
|
pulbicIpAddressPoolId?: string;
|
|
6527
6837
|
requestId?: string;
|
|
6528
6838
|
resourceGroupId?: string;
|
|
6529
6839
|
static names(): { [key: string]: string } {
|
|
6530
6840
|
return {
|
|
6841
|
+
publicIpAddressPoolId: 'PublicIpAddressPoolId',
|
|
6531
6842
|
pulbicIpAddressPoolId: 'PulbicIpAddressPoolId',
|
|
6532
6843
|
requestId: 'RequestId',
|
|
6533
6844
|
resourceGroupId: 'ResourceGroupId',
|
|
@@ -6536,6 +6847,7 @@ export class CreatePublicIpAddressPoolResponseBody extends $tea.Model {
|
|
|
6536
6847
|
|
|
6537
6848
|
static types(): { [key: string]: any } {
|
|
6538
6849
|
return {
|
|
6850
|
+
publicIpAddressPoolId: 'string',
|
|
6539
6851
|
pulbicIpAddressPoolId: 'string',
|
|
6540
6852
|
requestId: 'string',
|
|
6541
6853
|
resourceGroupId: 'string',
|
|
@@ -10037,6 +10349,249 @@ export class DeleteDhcpOptionsSetResponse extends $tea.Model {
|
|
|
10037
10349
|
}
|
|
10038
10350
|
}
|
|
10039
10351
|
|
|
10352
|
+
export class DeleteExpressConnectTrafficQosRequest extends $tea.Model {
|
|
10353
|
+
clientToken?: string;
|
|
10354
|
+
ownerAccount?: string;
|
|
10355
|
+
ownerId?: number;
|
|
10356
|
+
qosId?: string;
|
|
10357
|
+
regionId?: string;
|
|
10358
|
+
resourceOwnerAccount?: string;
|
|
10359
|
+
static names(): { [key: string]: string } {
|
|
10360
|
+
return {
|
|
10361
|
+
clientToken: 'ClientToken',
|
|
10362
|
+
ownerAccount: 'OwnerAccount',
|
|
10363
|
+
ownerId: 'OwnerId',
|
|
10364
|
+
qosId: 'QosId',
|
|
10365
|
+
regionId: 'RegionId',
|
|
10366
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
10367
|
+
};
|
|
10368
|
+
}
|
|
10369
|
+
|
|
10370
|
+
static types(): { [key: string]: any } {
|
|
10371
|
+
return {
|
|
10372
|
+
clientToken: 'string',
|
|
10373
|
+
ownerAccount: 'string',
|
|
10374
|
+
ownerId: 'number',
|
|
10375
|
+
qosId: 'string',
|
|
10376
|
+
regionId: 'string',
|
|
10377
|
+
resourceOwnerAccount: 'string',
|
|
10378
|
+
};
|
|
10379
|
+
}
|
|
10380
|
+
|
|
10381
|
+
constructor(map?: { [key: string]: any }) {
|
|
10382
|
+
super(map);
|
|
10383
|
+
}
|
|
10384
|
+
}
|
|
10385
|
+
|
|
10386
|
+
export class DeleteExpressConnectTrafficQosResponseBody extends $tea.Model {
|
|
10387
|
+
requestId?: string;
|
|
10388
|
+
static names(): { [key: string]: string } {
|
|
10389
|
+
return {
|
|
10390
|
+
requestId: 'RequestId',
|
|
10391
|
+
};
|
|
10392
|
+
}
|
|
10393
|
+
|
|
10394
|
+
static types(): { [key: string]: any } {
|
|
10395
|
+
return {
|
|
10396
|
+
requestId: 'string',
|
|
10397
|
+
};
|
|
10398
|
+
}
|
|
10399
|
+
|
|
10400
|
+
constructor(map?: { [key: string]: any }) {
|
|
10401
|
+
super(map);
|
|
10402
|
+
}
|
|
10403
|
+
}
|
|
10404
|
+
|
|
10405
|
+
export class DeleteExpressConnectTrafficQosResponse extends $tea.Model {
|
|
10406
|
+
headers?: { [key: string]: string };
|
|
10407
|
+
statusCode?: number;
|
|
10408
|
+
body?: DeleteExpressConnectTrafficQosResponseBody;
|
|
10409
|
+
static names(): { [key: string]: string } {
|
|
10410
|
+
return {
|
|
10411
|
+
headers: 'headers',
|
|
10412
|
+
statusCode: 'statusCode',
|
|
10413
|
+
body: 'body',
|
|
10414
|
+
};
|
|
10415
|
+
}
|
|
10416
|
+
|
|
10417
|
+
static types(): { [key: string]: any } {
|
|
10418
|
+
return {
|
|
10419
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
10420
|
+
statusCode: 'number',
|
|
10421
|
+
body: DeleteExpressConnectTrafficQosResponseBody,
|
|
10422
|
+
};
|
|
10423
|
+
}
|
|
10424
|
+
|
|
10425
|
+
constructor(map?: { [key: string]: any }) {
|
|
10426
|
+
super(map);
|
|
10427
|
+
}
|
|
10428
|
+
}
|
|
10429
|
+
|
|
10430
|
+
export class DeleteExpressConnectTrafficQosQueueRequest extends $tea.Model {
|
|
10431
|
+
clientToken?: string;
|
|
10432
|
+
ownerAccount?: string;
|
|
10433
|
+
ownerId?: number;
|
|
10434
|
+
qosId?: string;
|
|
10435
|
+
queueId?: string;
|
|
10436
|
+
regionId?: string;
|
|
10437
|
+
resourceOwnerAccount?: string;
|
|
10438
|
+
static names(): { [key: string]: string } {
|
|
10439
|
+
return {
|
|
10440
|
+
clientToken: 'ClientToken',
|
|
10441
|
+
ownerAccount: 'OwnerAccount',
|
|
10442
|
+
ownerId: 'OwnerId',
|
|
10443
|
+
qosId: 'QosId',
|
|
10444
|
+
queueId: 'QueueId',
|
|
10445
|
+
regionId: 'RegionId',
|
|
10446
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
10447
|
+
};
|
|
10448
|
+
}
|
|
10449
|
+
|
|
10450
|
+
static types(): { [key: string]: any } {
|
|
10451
|
+
return {
|
|
10452
|
+
clientToken: 'string',
|
|
10453
|
+
ownerAccount: 'string',
|
|
10454
|
+
ownerId: 'number',
|
|
10455
|
+
qosId: 'string',
|
|
10456
|
+
queueId: 'string',
|
|
10457
|
+
regionId: 'string',
|
|
10458
|
+
resourceOwnerAccount: 'string',
|
|
10459
|
+
};
|
|
10460
|
+
}
|
|
10461
|
+
|
|
10462
|
+
constructor(map?: { [key: string]: any }) {
|
|
10463
|
+
super(map);
|
|
10464
|
+
}
|
|
10465
|
+
}
|
|
10466
|
+
|
|
10467
|
+
export class DeleteExpressConnectTrafficQosQueueResponseBody extends $tea.Model {
|
|
10468
|
+
requestId?: string;
|
|
10469
|
+
static names(): { [key: string]: string } {
|
|
10470
|
+
return {
|
|
10471
|
+
requestId: 'RequestId',
|
|
10472
|
+
};
|
|
10473
|
+
}
|
|
10474
|
+
|
|
10475
|
+
static types(): { [key: string]: any } {
|
|
10476
|
+
return {
|
|
10477
|
+
requestId: 'string',
|
|
10478
|
+
};
|
|
10479
|
+
}
|
|
10480
|
+
|
|
10481
|
+
constructor(map?: { [key: string]: any }) {
|
|
10482
|
+
super(map);
|
|
10483
|
+
}
|
|
10484
|
+
}
|
|
10485
|
+
|
|
10486
|
+
export class DeleteExpressConnectTrafficQosQueueResponse extends $tea.Model {
|
|
10487
|
+
headers?: { [key: string]: string };
|
|
10488
|
+
statusCode?: number;
|
|
10489
|
+
body?: DeleteExpressConnectTrafficQosQueueResponseBody;
|
|
10490
|
+
static names(): { [key: string]: string } {
|
|
10491
|
+
return {
|
|
10492
|
+
headers: 'headers',
|
|
10493
|
+
statusCode: 'statusCode',
|
|
10494
|
+
body: 'body',
|
|
10495
|
+
};
|
|
10496
|
+
}
|
|
10497
|
+
|
|
10498
|
+
static types(): { [key: string]: any } {
|
|
10499
|
+
return {
|
|
10500
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
10501
|
+
statusCode: 'number',
|
|
10502
|
+
body: DeleteExpressConnectTrafficQosQueueResponseBody,
|
|
10503
|
+
};
|
|
10504
|
+
}
|
|
10505
|
+
|
|
10506
|
+
constructor(map?: { [key: string]: any }) {
|
|
10507
|
+
super(map);
|
|
10508
|
+
}
|
|
10509
|
+
}
|
|
10510
|
+
|
|
10511
|
+
export class DeleteExpressConnectTrafficQosRuleRequest extends $tea.Model {
|
|
10512
|
+
clientToken?: string;
|
|
10513
|
+
ownerAccount?: string;
|
|
10514
|
+
ownerId?: number;
|
|
10515
|
+
qosId?: string;
|
|
10516
|
+
queueId?: string;
|
|
10517
|
+
regionId?: string;
|
|
10518
|
+
resourceOwnerAccount?: string;
|
|
10519
|
+
ruleId?: string;
|
|
10520
|
+
static names(): { [key: string]: string } {
|
|
10521
|
+
return {
|
|
10522
|
+
clientToken: 'ClientToken',
|
|
10523
|
+
ownerAccount: 'OwnerAccount',
|
|
10524
|
+
ownerId: 'OwnerId',
|
|
10525
|
+
qosId: 'QosId',
|
|
10526
|
+
queueId: 'QueueId',
|
|
10527
|
+
regionId: 'RegionId',
|
|
10528
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
10529
|
+
ruleId: 'RuleId',
|
|
10530
|
+
};
|
|
10531
|
+
}
|
|
10532
|
+
|
|
10533
|
+
static types(): { [key: string]: any } {
|
|
10534
|
+
return {
|
|
10535
|
+
clientToken: 'string',
|
|
10536
|
+
ownerAccount: 'string',
|
|
10537
|
+
ownerId: 'number',
|
|
10538
|
+
qosId: 'string',
|
|
10539
|
+
queueId: 'string',
|
|
10540
|
+
regionId: 'string',
|
|
10541
|
+
resourceOwnerAccount: 'string',
|
|
10542
|
+
ruleId: 'string',
|
|
10543
|
+
};
|
|
10544
|
+
}
|
|
10545
|
+
|
|
10546
|
+
constructor(map?: { [key: string]: any }) {
|
|
10547
|
+
super(map);
|
|
10548
|
+
}
|
|
10549
|
+
}
|
|
10550
|
+
|
|
10551
|
+
export class DeleteExpressConnectTrafficQosRuleResponseBody extends $tea.Model {
|
|
10552
|
+
requestId?: string;
|
|
10553
|
+
static names(): { [key: string]: string } {
|
|
10554
|
+
return {
|
|
10555
|
+
requestId: 'RequestId',
|
|
10556
|
+
};
|
|
10557
|
+
}
|
|
10558
|
+
|
|
10559
|
+
static types(): { [key: string]: any } {
|
|
10560
|
+
return {
|
|
10561
|
+
requestId: 'string',
|
|
10562
|
+
};
|
|
10563
|
+
}
|
|
10564
|
+
|
|
10565
|
+
constructor(map?: { [key: string]: any }) {
|
|
10566
|
+
super(map);
|
|
10567
|
+
}
|
|
10568
|
+
}
|
|
10569
|
+
|
|
10570
|
+
export class DeleteExpressConnectTrafficQosRuleResponse extends $tea.Model {
|
|
10571
|
+
headers?: { [key: string]: string };
|
|
10572
|
+
statusCode?: number;
|
|
10573
|
+
body?: DeleteExpressConnectTrafficQosRuleResponseBody;
|
|
10574
|
+
static names(): { [key: string]: string } {
|
|
10575
|
+
return {
|
|
10576
|
+
headers: 'headers',
|
|
10577
|
+
statusCode: 'statusCode',
|
|
10578
|
+
body: 'body',
|
|
10579
|
+
};
|
|
10580
|
+
}
|
|
10581
|
+
|
|
10582
|
+
static types(): { [key: string]: any } {
|
|
10583
|
+
return {
|
|
10584
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
10585
|
+
statusCode: 'number',
|
|
10586
|
+
body: DeleteExpressConnectTrafficQosRuleResponseBody,
|
|
10587
|
+
};
|
|
10588
|
+
}
|
|
10589
|
+
|
|
10590
|
+
constructor(map?: { [key: string]: any }) {
|
|
10591
|
+
super(map);
|
|
10592
|
+
}
|
|
10593
|
+
}
|
|
10594
|
+
|
|
10040
10595
|
export class DeleteFailoverTestJobRequest extends $tea.Model {
|
|
10041
10596
|
clientToken?: string;
|
|
10042
10597
|
jobId?: string;
|
|
@@ -13778,6 +14333,93 @@ export class DeletionProtectionResponse extends $tea.Model {
|
|
|
13778
14333
|
}
|
|
13779
14334
|
}
|
|
13780
14335
|
|
|
14336
|
+
export class Describe95TrafficRequest extends $tea.Model {
|
|
14337
|
+
day?: string;
|
|
14338
|
+
instanceId?: string;
|
|
14339
|
+
ownerAccount?: string;
|
|
14340
|
+
ownerId?: number;
|
|
14341
|
+
regionId?: string;
|
|
14342
|
+
resourceOwnerAccount?: string;
|
|
14343
|
+
resourceOwnerId?: number;
|
|
14344
|
+
resourceType?: string;
|
|
14345
|
+
static names(): { [key: string]: string } {
|
|
14346
|
+
return {
|
|
14347
|
+
day: 'Day',
|
|
14348
|
+
instanceId: 'InstanceId',
|
|
14349
|
+
ownerAccount: 'OwnerAccount',
|
|
14350
|
+
ownerId: 'OwnerId',
|
|
14351
|
+
regionId: 'RegionId',
|
|
14352
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
14353
|
+
resourceOwnerId: 'ResourceOwnerId',
|
|
14354
|
+
resourceType: 'ResourceType',
|
|
14355
|
+
};
|
|
14356
|
+
}
|
|
14357
|
+
|
|
14358
|
+
static types(): { [key: string]: any } {
|
|
14359
|
+
return {
|
|
14360
|
+
day: 'string',
|
|
14361
|
+
instanceId: 'string',
|
|
14362
|
+
ownerAccount: 'string',
|
|
14363
|
+
ownerId: 'number',
|
|
14364
|
+
regionId: 'string',
|
|
14365
|
+
resourceOwnerAccount: 'string',
|
|
14366
|
+
resourceOwnerId: 'number',
|
|
14367
|
+
resourceType: 'string',
|
|
14368
|
+
};
|
|
14369
|
+
}
|
|
14370
|
+
|
|
14371
|
+
constructor(map?: { [key: string]: any }) {
|
|
14372
|
+
super(map);
|
|
14373
|
+
}
|
|
14374
|
+
}
|
|
14375
|
+
|
|
14376
|
+
export class Describe95TrafficResponseBody extends $tea.Model {
|
|
14377
|
+
requestId?: string;
|
|
14378
|
+
traffic95Summary?: Describe95TrafficResponseBodyTraffic95Summary;
|
|
14379
|
+
static names(): { [key: string]: string } {
|
|
14380
|
+
return {
|
|
14381
|
+
requestId: 'RequestId',
|
|
14382
|
+
traffic95Summary: 'Traffic95Summary',
|
|
14383
|
+
};
|
|
14384
|
+
}
|
|
14385
|
+
|
|
14386
|
+
static types(): { [key: string]: any } {
|
|
14387
|
+
return {
|
|
14388
|
+
requestId: 'string',
|
|
14389
|
+
traffic95Summary: Describe95TrafficResponseBodyTraffic95Summary,
|
|
14390
|
+
};
|
|
14391
|
+
}
|
|
14392
|
+
|
|
14393
|
+
constructor(map?: { [key: string]: any }) {
|
|
14394
|
+
super(map);
|
|
14395
|
+
}
|
|
14396
|
+
}
|
|
14397
|
+
|
|
14398
|
+
export class Describe95TrafficResponse extends $tea.Model {
|
|
14399
|
+
headers?: { [key: string]: string };
|
|
14400
|
+
statusCode?: number;
|
|
14401
|
+
body?: Describe95TrafficResponseBody;
|
|
14402
|
+
static names(): { [key: string]: string } {
|
|
14403
|
+
return {
|
|
14404
|
+
headers: 'headers',
|
|
14405
|
+
statusCode: 'statusCode',
|
|
14406
|
+
body: 'body',
|
|
14407
|
+
};
|
|
14408
|
+
}
|
|
14409
|
+
|
|
14410
|
+
static types(): { [key: string]: any } {
|
|
14411
|
+
return {
|
|
14412
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
14413
|
+
statusCode: 'number',
|
|
14414
|
+
body: Describe95TrafficResponseBody,
|
|
14415
|
+
};
|
|
14416
|
+
}
|
|
14417
|
+
|
|
14418
|
+
constructor(map?: { [key: string]: any }) {
|
|
14419
|
+
super(map);
|
|
14420
|
+
}
|
|
14421
|
+
}
|
|
14422
|
+
|
|
13781
14423
|
export class DescribeAccessPointsRequest extends $tea.Model {
|
|
13782
14424
|
acceptLanguage?: string;
|
|
13783
14425
|
ownerId?: number;
|
|
@@ -14608,6 +15250,7 @@ export class DescribeEipAddressesRequest extends $tea.Model {
|
|
|
14608
15250
|
resourceOwnerId?: number;
|
|
14609
15251
|
securityProtectionEnabled?: boolean;
|
|
14610
15252
|
segmentInstanceId?: string;
|
|
15253
|
+
serviceManaged?: boolean;
|
|
14611
15254
|
status?: string;
|
|
14612
15255
|
tag?: DescribeEipAddressesRequestTag[];
|
|
14613
15256
|
static names(): { [key: string]: string } {
|
|
@@ -14634,6 +15277,7 @@ export class DescribeEipAddressesRequest extends $tea.Model {
|
|
|
14634
15277
|
resourceOwnerId: 'ResourceOwnerId',
|
|
14635
15278
|
securityProtectionEnabled: 'SecurityProtectionEnabled',
|
|
14636
15279
|
segmentInstanceId: 'SegmentInstanceId',
|
|
15280
|
+
serviceManaged: 'ServiceManaged',
|
|
14637
15281
|
status: 'Status',
|
|
14638
15282
|
tag: 'Tag',
|
|
14639
15283
|
};
|
|
@@ -14663,6 +15307,7 @@ export class DescribeEipAddressesRequest extends $tea.Model {
|
|
|
14663
15307
|
resourceOwnerId: 'number',
|
|
14664
15308
|
securityProtectionEnabled: 'boolean',
|
|
14665
15309
|
segmentInstanceId: 'string',
|
|
15310
|
+
serviceManaged: 'boolean',
|
|
14666
15311
|
status: 'string',
|
|
14667
15312
|
tag: { 'type': 'array', 'itemType': DescribeEipAddressesRequestTag },
|
|
14668
15313
|
};
|
|
@@ -15005,6 +15650,285 @@ export class DescribeEipSegmentResponse extends $tea.Model {
|
|
|
15005
15650
|
}
|
|
15006
15651
|
}
|
|
15007
15652
|
|
|
15653
|
+
export class DescribeExpressConnectTrafficQosRequest extends $tea.Model {
|
|
15654
|
+
clientToken?: string;
|
|
15655
|
+
maxResults?: number;
|
|
15656
|
+
nextToken?: string;
|
|
15657
|
+
ownerAccount?: string;
|
|
15658
|
+
ownerId?: number;
|
|
15659
|
+
qosIdList?: string[];
|
|
15660
|
+
qosNameList?: string[];
|
|
15661
|
+
regionId?: string;
|
|
15662
|
+
resourceOwnerAccount?: string;
|
|
15663
|
+
static names(): { [key: string]: string } {
|
|
15664
|
+
return {
|
|
15665
|
+
clientToken: 'ClientToken',
|
|
15666
|
+
maxResults: 'MaxResults',
|
|
15667
|
+
nextToken: 'NextToken',
|
|
15668
|
+
ownerAccount: 'OwnerAccount',
|
|
15669
|
+
ownerId: 'OwnerId',
|
|
15670
|
+
qosIdList: 'QosIdList',
|
|
15671
|
+
qosNameList: 'QosNameList',
|
|
15672
|
+
regionId: 'RegionId',
|
|
15673
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
15674
|
+
};
|
|
15675
|
+
}
|
|
15676
|
+
|
|
15677
|
+
static types(): { [key: string]: any } {
|
|
15678
|
+
return {
|
|
15679
|
+
clientToken: 'string',
|
|
15680
|
+
maxResults: 'number',
|
|
15681
|
+
nextToken: 'string',
|
|
15682
|
+
ownerAccount: 'string',
|
|
15683
|
+
ownerId: 'number',
|
|
15684
|
+
qosIdList: { 'type': 'array', 'itemType': 'string' },
|
|
15685
|
+
qosNameList: { 'type': 'array', 'itemType': 'string' },
|
|
15686
|
+
regionId: 'string',
|
|
15687
|
+
resourceOwnerAccount: 'string',
|
|
15688
|
+
};
|
|
15689
|
+
}
|
|
15690
|
+
|
|
15691
|
+
constructor(map?: { [key: string]: any }) {
|
|
15692
|
+
super(map);
|
|
15693
|
+
}
|
|
15694
|
+
}
|
|
15695
|
+
|
|
15696
|
+
export class DescribeExpressConnectTrafficQosResponseBody extends $tea.Model {
|
|
15697
|
+
count?: string;
|
|
15698
|
+
maxResults?: number;
|
|
15699
|
+
nextToken?: string;
|
|
15700
|
+
qosList?: DescribeExpressConnectTrafficQosResponseBodyQosList[];
|
|
15701
|
+
requestId?: string;
|
|
15702
|
+
totalCount?: number;
|
|
15703
|
+
static names(): { [key: string]: string } {
|
|
15704
|
+
return {
|
|
15705
|
+
count: 'Count',
|
|
15706
|
+
maxResults: 'MaxResults',
|
|
15707
|
+
nextToken: 'NextToken',
|
|
15708
|
+
qosList: 'QosList',
|
|
15709
|
+
requestId: 'RequestId',
|
|
15710
|
+
totalCount: 'TotalCount',
|
|
15711
|
+
};
|
|
15712
|
+
}
|
|
15713
|
+
|
|
15714
|
+
static types(): { [key: string]: any } {
|
|
15715
|
+
return {
|
|
15716
|
+
count: 'string',
|
|
15717
|
+
maxResults: 'number',
|
|
15718
|
+
nextToken: 'string',
|
|
15719
|
+
qosList: { 'type': 'array', 'itemType': DescribeExpressConnectTrafficQosResponseBodyQosList },
|
|
15720
|
+
requestId: 'string',
|
|
15721
|
+
totalCount: 'number',
|
|
15722
|
+
};
|
|
15723
|
+
}
|
|
15724
|
+
|
|
15725
|
+
constructor(map?: { [key: string]: any }) {
|
|
15726
|
+
super(map);
|
|
15727
|
+
}
|
|
15728
|
+
}
|
|
15729
|
+
|
|
15730
|
+
export class DescribeExpressConnectTrafficQosResponse extends $tea.Model {
|
|
15731
|
+
headers?: { [key: string]: string };
|
|
15732
|
+
statusCode?: number;
|
|
15733
|
+
body?: DescribeExpressConnectTrafficQosResponseBody;
|
|
15734
|
+
static names(): { [key: string]: string } {
|
|
15735
|
+
return {
|
|
15736
|
+
headers: 'headers',
|
|
15737
|
+
statusCode: 'statusCode',
|
|
15738
|
+
body: 'body',
|
|
15739
|
+
};
|
|
15740
|
+
}
|
|
15741
|
+
|
|
15742
|
+
static types(): { [key: string]: any } {
|
|
15743
|
+
return {
|
|
15744
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
15745
|
+
statusCode: 'number',
|
|
15746
|
+
body: DescribeExpressConnectTrafficQosResponseBody,
|
|
15747
|
+
};
|
|
15748
|
+
}
|
|
15749
|
+
|
|
15750
|
+
constructor(map?: { [key: string]: any }) {
|
|
15751
|
+
super(map);
|
|
15752
|
+
}
|
|
15753
|
+
}
|
|
15754
|
+
|
|
15755
|
+
export class DescribeExpressConnectTrafficQosQueueRequest extends $tea.Model {
|
|
15756
|
+
clientToken?: string;
|
|
15757
|
+
ownerAccount?: string;
|
|
15758
|
+
ownerId?: number;
|
|
15759
|
+
qosId?: string;
|
|
15760
|
+
queueIdList?: string[];
|
|
15761
|
+
queueNameList?: string[];
|
|
15762
|
+
regionId?: string;
|
|
15763
|
+
resourceOwnerAccount?: string;
|
|
15764
|
+
static names(): { [key: string]: string } {
|
|
15765
|
+
return {
|
|
15766
|
+
clientToken: 'ClientToken',
|
|
15767
|
+
ownerAccount: 'OwnerAccount',
|
|
15768
|
+
ownerId: 'OwnerId',
|
|
15769
|
+
qosId: 'QosId',
|
|
15770
|
+
queueIdList: 'QueueIdList',
|
|
15771
|
+
queueNameList: 'QueueNameList',
|
|
15772
|
+
regionId: 'RegionId',
|
|
15773
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
15774
|
+
};
|
|
15775
|
+
}
|
|
15776
|
+
|
|
15777
|
+
static types(): { [key: string]: any } {
|
|
15778
|
+
return {
|
|
15779
|
+
clientToken: 'string',
|
|
15780
|
+
ownerAccount: 'string',
|
|
15781
|
+
ownerId: 'number',
|
|
15782
|
+
qosId: 'string',
|
|
15783
|
+
queueIdList: { 'type': 'array', 'itemType': 'string' },
|
|
15784
|
+
queueNameList: { 'type': 'array', 'itemType': 'string' },
|
|
15785
|
+
regionId: 'string',
|
|
15786
|
+
resourceOwnerAccount: 'string',
|
|
15787
|
+
};
|
|
15788
|
+
}
|
|
15789
|
+
|
|
15790
|
+
constructor(map?: { [key: string]: any }) {
|
|
15791
|
+
super(map);
|
|
15792
|
+
}
|
|
15793
|
+
}
|
|
15794
|
+
|
|
15795
|
+
export class DescribeExpressConnectTrafficQosQueueResponseBody extends $tea.Model {
|
|
15796
|
+
queueList?: DescribeExpressConnectTrafficQosQueueResponseBodyQueueList[];
|
|
15797
|
+
requestId?: string;
|
|
15798
|
+
static names(): { [key: string]: string } {
|
|
15799
|
+
return {
|
|
15800
|
+
queueList: 'QueueList',
|
|
15801
|
+
requestId: 'RequestId',
|
|
15802
|
+
};
|
|
15803
|
+
}
|
|
15804
|
+
|
|
15805
|
+
static types(): { [key: string]: any } {
|
|
15806
|
+
return {
|
|
15807
|
+
queueList: { 'type': 'array', 'itemType': DescribeExpressConnectTrafficQosQueueResponseBodyQueueList },
|
|
15808
|
+
requestId: 'string',
|
|
15809
|
+
};
|
|
15810
|
+
}
|
|
15811
|
+
|
|
15812
|
+
constructor(map?: { [key: string]: any }) {
|
|
15813
|
+
super(map);
|
|
15814
|
+
}
|
|
15815
|
+
}
|
|
15816
|
+
|
|
15817
|
+
export class DescribeExpressConnectTrafficQosQueueResponse extends $tea.Model {
|
|
15818
|
+
headers?: { [key: string]: string };
|
|
15819
|
+
statusCode?: number;
|
|
15820
|
+
body?: DescribeExpressConnectTrafficQosQueueResponseBody;
|
|
15821
|
+
static names(): { [key: string]: string } {
|
|
15822
|
+
return {
|
|
15823
|
+
headers: 'headers',
|
|
15824
|
+
statusCode: 'statusCode',
|
|
15825
|
+
body: 'body',
|
|
15826
|
+
};
|
|
15827
|
+
}
|
|
15828
|
+
|
|
15829
|
+
static types(): { [key: string]: any } {
|
|
15830
|
+
return {
|
|
15831
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
15832
|
+
statusCode: 'number',
|
|
15833
|
+
body: DescribeExpressConnectTrafficQosQueueResponseBody,
|
|
15834
|
+
};
|
|
15835
|
+
}
|
|
15836
|
+
|
|
15837
|
+
constructor(map?: { [key: string]: any }) {
|
|
15838
|
+
super(map);
|
|
15839
|
+
}
|
|
15840
|
+
}
|
|
15841
|
+
|
|
15842
|
+
export class DescribeExpressConnectTrafficQosRuleRequest extends $tea.Model {
|
|
15843
|
+
clientToken?: string;
|
|
15844
|
+
ownerAccount?: string;
|
|
15845
|
+
ownerId?: number;
|
|
15846
|
+
qosId?: string;
|
|
15847
|
+
queueId?: string;
|
|
15848
|
+
regionId?: string;
|
|
15849
|
+
resourceOwnerAccount?: string;
|
|
15850
|
+
ruleIdList?: string[];
|
|
15851
|
+
ruleNameList?: string[];
|
|
15852
|
+
static names(): { [key: string]: string } {
|
|
15853
|
+
return {
|
|
15854
|
+
clientToken: 'ClientToken',
|
|
15855
|
+
ownerAccount: 'OwnerAccount',
|
|
15856
|
+
ownerId: 'OwnerId',
|
|
15857
|
+
qosId: 'QosId',
|
|
15858
|
+
queueId: 'QueueId',
|
|
15859
|
+
regionId: 'RegionId',
|
|
15860
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
15861
|
+
ruleIdList: 'RuleIdList',
|
|
15862
|
+
ruleNameList: 'RuleNameList',
|
|
15863
|
+
};
|
|
15864
|
+
}
|
|
15865
|
+
|
|
15866
|
+
static types(): { [key: string]: any } {
|
|
15867
|
+
return {
|
|
15868
|
+
clientToken: 'string',
|
|
15869
|
+
ownerAccount: 'string',
|
|
15870
|
+
ownerId: 'number',
|
|
15871
|
+
qosId: 'string',
|
|
15872
|
+
queueId: 'string',
|
|
15873
|
+
regionId: 'string',
|
|
15874
|
+
resourceOwnerAccount: 'string',
|
|
15875
|
+
ruleIdList: { 'type': 'array', 'itemType': 'string' },
|
|
15876
|
+
ruleNameList: { 'type': 'array', 'itemType': 'string' },
|
|
15877
|
+
};
|
|
15878
|
+
}
|
|
15879
|
+
|
|
15880
|
+
constructor(map?: { [key: string]: any }) {
|
|
15881
|
+
super(map);
|
|
15882
|
+
}
|
|
15883
|
+
}
|
|
15884
|
+
|
|
15885
|
+
export class DescribeExpressConnectTrafficQosRuleResponseBody extends $tea.Model {
|
|
15886
|
+
requestId?: string;
|
|
15887
|
+
ruleList?: DescribeExpressConnectTrafficQosRuleResponseBodyRuleList[];
|
|
15888
|
+
static names(): { [key: string]: string } {
|
|
15889
|
+
return {
|
|
15890
|
+
requestId: 'RequestId',
|
|
15891
|
+
ruleList: 'RuleList',
|
|
15892
|
+
};
|
|
15893
|
+
}
|
|
15894
|
+
|
|
15895
|
+
static types(): { [key: string]: any } {
|
|
15896
|
+
return {
|
|
15897
|
+
requestId: 'string',
|
|
15898
|
+
ruleList: { 'type': 'array', 'itemType': DescribeExpressConnectTrafficQosRuleResponseBodyRuleList },
|
|
15899
|
+
};
|
|
15900
|
+
}
|
|
15901
|
+
|
|
15902
|
+
constructor(map?: { [key: string]: any }) {
|
|
15903
|
+
super(map);
|
|
15904
|
+
}
|
|
15905
|
+
}
|
|
15906
|
+
|
|
15907
|
+
export class DescribeExpressConnectTrafficQosRuleResponse extends $tea.Model {
|
|
15908
|
+
headers?: { [key: string]: string };
|
|
15909
|
+
statusCode?: number;
|
|
15910
|
+
body?: DescribeExpressConnectTrafficQosRuleResponseBody;
|
|
15911
|
+
static names(): { [key: string]: string } {
|
|
15912
|
+
return {
|
|
15913
|
+
headers: 'headers',
|
|
15914
|
+
statusCode: 'statusCode',
|
|
15915
|
+
body: 'body',
|
|
15916
|
+
};
|
|
15917
|
+
}
|
|
15918
|
+
|
|
15919
|
+
static types(): { [key: string]: any } {
|
|
15920
|
+
return {
|
|
15921
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
15922
|
+
statusCode: 'number',
|
|
15923
|
+
body: DescribeExpressConnectTrafficQosRuleResponseBody,
|
|
15924
|
+
};
|
|
15925
|
+
}
|
|
15926
|
+
|
|
15927
|
+
constructor(map?: { [key: string]: any }) {
|
|
15928
|
+
super(map);
|
|
15929
|
+
}
|
|
15930
|
+
}
|
|
15931
|
+
|
|
15008
15932
|
export class DescribeFailoverTestJobRequest extends $tea.Model {
|
|
15009
15933
|
clientToken?: string;
|
|
15010
15934
|
jobId?: string;
|
|
@@ -16321,6 +17245,7 @@ export class DescribeIpv6AddressesRequest extends $tea.Model {
|
|
|
16321
17245
|
resourceGroupId?: string;
|
|
16322
17246
|
resourceOwnerAccount?: string;
|
|
16323
17247
|
resourceOwnerId?: number;
|
|
17248
|
+
serviceManaged?: boolean;
|
|
16324
17249
|
tag?: DescribeIpv6AddressesRequestTag[];
|
|
16325
17250
|
vSwitchId?: string;
|
|
16326
17251
|
vpcId?: string;
|
|
@@ -16342,6 +17267,7 @@ export class DescribeIpv6AddressesRequest extends $tea.Model {
|
|
|
16342
17267
|
resourceGroupId: 'ResourceGroupId',
|
|
16343
17268
|
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
16344
17269
|
resourceOwnerId: 'ResourceOwnerId',
|
|
17270
|
+
serviceManaged: 'ServiceManaged',
|
|
16345
17271
|
tag: 'Tag',
|
|
16346
17272
|
vSwitchId: 'VSwitchId',
|
|
16347
17273
|
vpcId: 'VpcId',
|
|
@@ -16366,6 +17292,7 @@ export class DescribeIpv6AddressesRequest extends $tea.Model {
|
|
|
16366
17292
|
resourceGroupId: 'string',
|
|
16367
17293
|
resourceOwnerAccount: 'string',
|
|
16368
17294
|
resourceOwnerId: 'number',
|
|
17295
|
+
serviceManaged: 'boolean',
|
|
16369
17296
|
tag: { 'type': 'array', 'itemType': DescribeIpv6AddressesRequestTag },
|
|
16370
17297
|
vSwitchId: 'string',
|
|
16371
17298
|
vpcId: 'string',
|
|
@@ -19855,6 +20782,7 @@ export class DescribeVpcAttributeResponseBody extends $tea.Model {
|
|
|
19855
20782
|
description?: string;
|
|
19856
20783
|
dhcpOptionsSetId?: string;
|
|
19857
20784
|
dhcpOptionsSetStatus?: string;
|
|
20785
|
+
enabledIpv6?: boolean;
|
|
19858
20786
|
ipv4GatewayId?: string;
|
|
19859
20787
|
ipv6CidrBlock?: string;
|
|
19860
20788
|
ipv6CidrBlocks?: DescribeVpcAttributeResponseBodyIpv6CidrBlocks;
|
|
@@ -19883,6 +20811,7 @@ export class DescribeVpcAttributeResponseBody extends $tea.Model {
|
|
|
19883
20811
|
description: 'Description',
|
|
19884
20812
|
dhcpOptionsSetId: 'DhcpOptionsSetId',
|
|
19885
20813
|
dhcpOptionsSetStatus: 'DhcpOptionsSetStatus',
|
|
20814
|
+
enabledIpv6: 'EnabledIpv6',
|
|
19886
20815
|
ipv4GatewayId: 'Ipv4GatewayId',
|
|
19887
20816
|
ipv6CidrBlock: 'Ipv6CidrBlock',
|
|
19888
20817
|
ipv6CidrBlocks: 'Ipv6CidrBlocks',
|
|
@@ -19914,6 +20843,7 @@ export class DescribeVpcAttributeResponseBody extends $tea.Model {
|
|
|
19914
20843
|
description: 'string',
|
|
19915
20844
|
dhcpOptionsSetId: 'string',
|
|
19916
20845
|
dhcpOptionsSetStatus: 'string',
|
|
20846
|
+
enabledIpv6: 'boolean',
|
|
19917
20847
|
ipv4GatewayId: 'string',
|
|
19918
20848
|
ipv6CidrBlock: 'string',
|
|
19919
20849
|
ipv6CidrBlocks: DescribeVpcAttributeResponseBodyIpv6CidrBlocks,
|
|
@@ -26972,6 +27902,306 @@ export class ModifyExpressCloudConnectionBandwidthResponse extends $tea.Model {
|
|
|
26972
27902
|
}
|
|
26973
27903
|
}
|
|
26974
27904
|
|
|
27905
|
+
export class ModifyExpressConnectTrafficQosRequest extends $tea.Model {
|
|
27906
|
+
addInstanceList?: ModifyExpressConnectTrafficQosRequestAddInstanceList[];
|
|
27907
|
+
clientToken?: string;
|
|
27908
|
+
ownerAccount?: string;
|
|
27909
|
+
ownerId?: number;
|
|
27910
|
+
qosDescription?: string;
|
|
27911
|
+
qosId?: string;
|
|
27912
|
+
qosName?: string;
|
|
27913
|
+
regionId?: string;
|
|
27914
|
+
removeInstanceList?: ModifyExpressConnectTrafficQosRequestRemoveInstanceList[];
|
|
27915
|
+
resourceOwnerAccount?: string;
|
|
27916
|
+
static names(): { [key: string]: string } {
|
|
27917
|
+
return {
|
|
27918
|
+
addInstanceList: 'AddInstanceList',
|
|
27919
|
+
clientToken: 'ClientToken',
|
|
27920
|
+
ownerAccount: 'OwnerAccount',
|
|
27921
|
+
ownerId: 'OwnerId',
|
|
27922
|
+
qosDescription: 'QosDescription',
|
|
27923
|
+
qosId: 'QosId',
|
|
27924
|
+
qosName: 'QosName',
|
|
27925
|
+
regionId: 'RegionId',
|
|
27926
|
+
removeInstanceList: 'RemoveInstanceList',
|
|
27927
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
27928
|
+
};
|
|
27929
|
+
}
|
|
27930
|
+
|
|
27931
|
+
static types(): { [key: string]: any } {
|
|
27932
|
+
return {
|
|
27933
|
+
addInstanceList: { 'type': 'array', 'itemType': ModifyExpressConnectTrafficQosRequestAddInstanceList },
|
|
27934
|
+
clientToken: 'string',
|
|
27935
|
+
ownerAccount: 'string',
|
|
27936
|
+
ownerId: 'number',
|
|
27937
|
+
qosDescription: 'string',
|
|
27938
|
+
qosId: 'string',
|
|
27939
|
+
qosName: 'string',
|
|
27940
|
+
regionId: 'string',
|
|
27941
|
+
removeInstanceList: { 'type': 'array', 'itemType': ModifyExpressConnectTrafficQosRequestRemoveInstanceList },
|
|
27942
|
+
resourceOwnerAccount: 'string',
|
|
27943
|
+
};
|
|
27944
|
+
}
|
|
27945
|
+
|
|
27946
|
+
constructor(map?: { [key: string]: any }) {
|
|
27947
|
+
super(map);
|
|
27948
|
+
}
|
|
27949
|
+
}
|
|
27950
|
+
|
|
27951
|
+
export class ModifyExpressConnectTrafficQosResponseBody extends $tea.Model {
|
|
27952
|
+
requestId?: string;
|
|
27953
|
+
static names(): { [key: string]: string } {
|
|
27954
|
+
return {
|
|
27955
|
+
requestId: 'RequestId',
|
|
27956
|
+
};
|
|
27957
|
+
}
|
|
27958
|
+
|
|
27959
|
+
static types(): { [key: string]: any } {
|
|
27960
|
+
return {
|
|
27961
|
+
requestId: 'string',
|
|
27962
|
+
};
|
|
27963
|
+
}
|
|
27964
|
+
|
|
27965
|
+
constructor(map?: { [key: string]: any }) {
|
|
27966
|
+
super(map);
|
|
27967
|
+
}
|
|
27968
|
+
}
|
|
27969
|
+
|
|
27970
|
+
export class ModifyExpressConnectTrafficQosResponse extends $tea.Model {
|
|
27971
|
+
headers?: { [key: string]: string };
|
|
27972
|
+
statusCode?: number;
|
|
27973
|
+
body?: ModifyExpressConnectTrafficQosResponseBody;
|
|
27974
|
+
static names(): { [key: string]: string } {
|
|
27975
|
+
return {
|
|
27976
|
+
headers: 'headers',
|
|
27977
|
+
statusCode: 'statusCode',
|
|
27978
|
+
body: 'body',
|
|
27979
|
+
};
|
|
27980
|
+
}
|
|
27981
|
+
|
|
27982
|
+
static types(): { [key: string]: any } {
|
|
27983
|
+
return {
|
|
27984
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
27985
|
+
statusCode: 'number',
|
|
27986
|
+
body: ModifyExpressConnectTrafficQosResponseBody,
|
|
27987
|
+
};
|
|
27988
|
+
}
|
|
27989
|
+
|
|
27990
|
+
constructor(map?: { [key: string]: any }) {
|
|
27991
|
+
super(map);
|
|
27992
|
+
}
|
|
27993
|
+
}
|
|
27994
|
+
|
|
27995
|
+
export class ModifyExpressConnectTrafficQosQueueRequest extends $tea.Model {
|
|
27996
|
+
bandwidthPercent?: string;
|
|
27997
|
+
clientToken?: string;
|
|
27998
|
+
ownerAccount?: string;
|
|
27999
|
+
ownerId?: number;
|
|
28000
|
+
qosId?: string;
|
|
28001
|
+
queueDescription?: string;
|
|
28002
|
+
queueId?: string;
|
|
28003
|
+
queueName?: string;
|
|
28004
|
+
regionId?: string;
|
|
28005
|
+
resourceOwnerAccount?: string;
|
|
28006
|
+
static names(): { [key: string]: string } {
|
|
28007
|
+
return {
|
|
28008
|
+
bandwidthPercent: 'BandwidthPercent',
|
|
28009
|
+
clientToken: 'ClientToken',
|
|
28010
|
+
ownerAccount: 'OwnerAccount',
|
|
28011
|
+
ownerId: 'OwnerId',
|
|
28012
|
+
qosId: 'QosId',
|
|
28013
|
+
queueDescription: 'QueueDescription',
|
|
28014
|
+
queueId: 'QueueId',
|
|
28015
|
+
queueName: 'QueueName',
|
|
28016
|
+
regionId: 'RegionId',
|
|
28017
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
28018
|
+
};
|
|
28019
|
+
}
|
|
28020
|
+
|
|
28021
|
+
static types(): { [key: string]: any } {
|
|
28022
|
+
return {
|
|
28023
|
+
bandwidthPercent: 'string',
|
|
28024
|
+
clientToken: 'string',
|
|
28025
|
+
ownerAccount: 'string',
|
|
28026
|
+
ownerId: 'number',
|
|
28027
|
+
qosId: 'string',
|
|
28028
|
+
queueDescription: 'string',
|
|
28029
|
+
queueId: 'string',
|
|
28030
|
+
queueName: 'string',
|
|
28031
|
+
regionId: 'string',
|
|
28032
|
+
resourceOwnerAccount: 'string',
|
|
28033
|
+
};
|
|
28034
|
+
}
|
|
28035
|
+
|
|
28036
|
+
constructor(map?: { [key: string]: any }) {
|
|
28037
|
+
super(map);
|
|
28038
|
+
}
|
|
28039
|
+
}
|
|
28040
|
+
|
|
28041
|
+
export class ModifyExpressConnectTrafficQosQueueResponseBody extends $tea.Model {
|
|
28042
|
+
requestId?: string;
|
|
28043
|
+
static names(): { [key: string]: string } {
|
|
28044
|
+
return {
|
|
28045
|
+
requestId: 'RequestId',
|
|
28046
|
+
};
|
|
28047
|
+
}
|
|
28048
|
+
|
|
28049
|
+
static types(): { [key: string]: any } {
|
|
28050
|
+
return {
|
|
28051
|
+
requestId: 'string',
|
|
28052
|
+
};
|
|
28053
|
+
}
|
|
28054
|
+
|
|
28055
|
+
constructor(map?: { [key: string]: any }) {
|
|
28056
|
+
super(map);
|
|
28057
|
+
}
|
|
28058
|
+
}
|
|
28059
|
+
|
|
28060
|
+
export class ModifyExpressConnectTrafficQosQueueResponse extends $tea.Model {
|
|
28061
|
+
headers?: { [key: string]: string };
|
|
28062
|
+
statusCode?: number;
|
|
28063
|
+
body?: ModifyExpressConnectTrafficQosQueueResponseBody;
|
|
28064
|
+
static names(): { [key: string]: string } {
|
|
28065
|
+
return {
|
|
28066
|
+
headers: 'headers',
|
|
28067
|
+
statusCode: 'statusCode',
|
|
28068
|
+
body: 'body',
|
|
28069
|
+
};
|
|
28070
|
+
}
|
|
28071
|
+
|
|
28072
|
+
static types(): { [key: string]: any } {
|
|
28073
|
+
return {
|
|
28074
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
28075
|
+
statusCode: 'number',
|
|
28076
|
+
body: ModifyExpressConnectTrafficQosQueueResponseBody,
|
|
28077
|
+
};
|
|
28078
|
+
}
|
|
28079
|
+
|
|
28080
|
+
constructor(map?: { [key: string]: any }) {
|
|
28081
|
+
super(map);
|
|
28082
|
+
}
|
|
28083
|
+
}
|
|
28084
|
+
|
|
28085
|
+
export class ModifyExpressConnectTrafficQosRuleRequest extends $tea.Model {
|
|
28086
|
+
clientToken?: string;
|
|
28087
|
+
dstCidr?: string;
|
|
28088
|
+
dstIPv6Cidr?: string;
|
|
28089
|
+
dstPortRange?: string;
|
|
28090
|
+
matchDscp?: number;
|
|
28091
|
+
ownerAccount?: string;
|
|
28092
|
+
ownerId?: number;
|
|
28093
|
+
priority?: number;
|
|
28094
|
+
protocol?: string;
|
|
28095
|
+
qosId?: string;
|
|
28096
|
+
queueId?: string;
|
|
28097
|
+
regionId?: string;
|
|
28098
|
+
remarkingDscp?: number;
|
|
28099
|
+
resourceOwnerAccount?: string;
|
|
28100
|
+
ruleDescription?: string;
|
|
28101
|
+
ruleId?: string;
|
|
28102
|
+
ruleName?: string;
|
|
28103
|
+
srcCidr?: string;
|
|
28104
|
+
srcIPv6Cidr?: string;
|
|
28105
|
+
srcPortRange?: string;
|
|
28106
|
+
static names(): { [key: string]: string } {
|
|
28107
|
+
return {
|
|
28108
|
+
clientToken: 'ClientToken',
|
|
28109
|
+
dstCidr: 'DstCidr',
|
|
28110
|
+
dstIPv6Cidr: 'DstIPv6Cidr',
|
|
28111
|
+
dstPortRange: 'DstPortRange',
|
|
28112
|
+
matchDscp: 'MatchDscp',
|
|
28113
|
+
ownerAccount: 'OwnerAccount',
|
|
28114
|
+
ownerId: 'OwnerId',
|
|
28115
|
+
priority: 'Priority',
|
|
28116
|
+
protocol: 'Protocol',
|
|
28117
|
+
qosId: 'QosId',
|
|
28118
|
+
queueId: 'QueueId',
|
|
28119
|
+
regionId: 'RegionId',
|
|
28120
|
+
remarkingDscp: 'RemarkingDscp',
|
|
28121
|
+
resourceOwnerAccount: 'ResourceOwnerAccount',
|
|
28122
|
+
ruleDescription: 'RuleDescription',
|
|
28123
|
+
ruleId: 'RuleId',
|
|
28124
|
+
ruleName: 'RuleName',
|
|
28125
|
+
srcCidr: 'SrcCidr',
|
|
28126
|
+
srcIPv6Cidr: 'SrcIPv6Cidr',
|
|
28127
|
+
srcPortRange: 'SrcPortRange',
|
|
28128
|
+
};
|
|
28129
|
+
}
|
|
28130
|
+
|
|
28131
|
+
static types(): { [key: string]: any } {
|
|
28132
|
+
return {
|
|
28133
|
+
clientToken: 'string',
|
|
28134
|
+
dstCidr: 'string',
|
|
28135
|
+
dstIPv6Cidr: 'string',
|
|
28136
|
+
dstPortRange: 'string',
|
|
28137
|
+
matchDscp: 'number',
|
|
28138
|
+
ownerAccount: 'string',
|
|
28139
|
+
ownerId: 'number',
|
|
28140
|
+
priority: 'number',
|
|
28141
|
+
protocol: 'string',
|
|
28142
|
+
qosId: 'string',
|
|
28143
|
+
queueId: 'string',
|
|
28144
|
+
regionId: 'string',
|
|
28145
|
+
remarkingDscp: 'number',
|
|
28146
|
+
resourceOwnerAccount: 'string',
|
|
28147
|
+
ruleDescription: 'string',
|
|
28148
|
+
ruleId: 'string',
|
|
28149
|
+
ruleName: 'string',
|
|
28150
|
+
srcCidr: 'string',
|
|
28151
|
+
srcIPv6Cidr: 'string',
|
|
28152
|
+
srcPortRange: 'string',
|
|
28153
|
+
};
|
|
28154
|
+
}
|
|
28155
|
+
|
|
28156
|
+
constructor(map?: { [key: string]: any }) {
|
|
28157
|
+
super(map);
|
|
28158
|
+
}
|
|
28159
|
+
}
|
|
28160
|
+
|
|
28161
|
+
export class ModifyExpressConnectTrafficQosRuleResponseBody extends $tea.Model {
|
|
28162
|
+
requestId?: string;
|
|
28163
|
+
static names(): { [key: string]: string } {
|
|
28164
|
+
return {
|
|
28165
|
+
requestId: 'RequestId',
|
|
28166
|
+
};
|
|
28167
|
+
}
|
|
28168
|
+
|
|
28169
|
+
static types(): { [key: string]: any } {
|
|
28170
|
+
return {
|
|
28171
|
+
requestId: 'string',
|
|
28172
|
+
};
|
|
28173
|
+
}
|
|
28174
|
+
|
|
28175
|
+
constructor(map?: { [key: string]: any }) {
|
|
28176
|
+
super(map);
|
|
28177
|
+
}
|
|
28178
|
+
}
|
|
28179
|
+
|
|
28180
|
+
export class ModifyExpressConnectTrafficQosRuleResponse extends $tea.Model {
|
|
28181
|
+
headers?: { [key: string]: string };
|
|
28182
|
+
statusCode?: number;
|
|
28183
|
+
body?: ModifyExpressConnectTrafficQosRuleResponseBody;
|
|
28184
|
+
static names(): { [key: string]: string } {
|
|
28185
|
+
return {
|
|
28186
|
+
headers: 'headers',
|
|
28187
|
+
statusCode: 'statusCode',
|
|
28188
|
+
body: 'body',
|
|
28189
|
+
};
|
|
28190
|
+
}
|
|
28191
|
+
|
|
28192
|
+
static types(): { [key: string]: any } {
|
|
28193
|
+
return {
|
|
28194
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
28195
|
+
statusCode: 'number',
|
|
28196
|
+
body: ModifyExpressConnectTrafficQosRuleResponseBody,
|
|
28197
|
+
};
|
|
28198
|
+
}
|
|
28199
|
+
|
|
28200
|
+
constructor(map?: { [key: string]: any }) {
|
|
28201
|
+
super(map);
|
|
28202
|
+
}
|
|
28203
|
+
}
|
|
28204
|
+
|
|
26975
28205
|
export class ModifyFlowLogAttributeRequest extends $tea.Model {
|
|
26976
28206
|
aggregationInterval?: number;
|
|
26977
28207
|
description?: string;
|
|
@@ -37233,6 +38463,87 @@ export class DeleteRouteEntryRequestNextHopList extends $tea.Model {
|
|
|
37233
38463
|
}
|
|
37234
38464
|
}
|
|
37235
38465
|
|
|
38466
|
+
export class Describe95TrafficResponseBodyTraffic95SummaryTraffic95DetailListTraffic95Detail extends $tea.Model {
|
|
38467
|
+
billBandwidth?: string;
|
|
38468
|
+
inBandwidth?: string;
|
|
38469
|
+
outBandwidth?: string;
|
|
38470
|
+
time?: string;
|
|
38471
|
+
static names(): { [key: string]: string } {
|
|
38472
|
+
return {
|
|
38473
|
+
billBandwidth: 'BillBandwidth',
|
|
38474
|
+
inBandwidth: 'InBandwidth',
|
|
38475
|
+
outBandwidth: 'OutBandwidth',
|
|
38476
|
+
time: 'Time',
|
|
38477
|
+
};
|
|
38478
|
+
}
|
|
38479
|
+
|
|
38480
|
+
static types(): { [key: string]: any } {
|
|
38481
|
+
return {
|
|
38482
|
+
billBandwidth: 'string',
|
|
38483
|
+
inBandwidth: 'string',
|
|
38484
|
+
outBandwidth: 'string',
|
|
38485
|
+
time: 'string',
|
|
38486
|
+
};
|
|
38487
|
+
}
|
|
38488
|
+
|
|
38489
|
+
constructor(map?: { [key: string]: any }) {
|
|
38490
|
+
super(map);
|
|
38491
|
+
}
|
|
38492
|
+
}
|
|
38493
|
+
|
|
38494
|
+
export class Describe95TrafficResponseBodyTraffic95SummaryTraffic95DetailList extends $tea.Model {
|
|
38495
|
+
traffic95Detail?: Describe95TrafficResponseBodyTraffic95SummaryTraffic95DetailListTraffic95Detail[];
|
|
38496
|
+
static names(): { [key: string]: string } {
|
|
38497
|
+
return {
|
|
38498
|
+
traffic95Detail: 'Traffic95Detail',
|
|
38499
|
+
};
|
|
38500
|
+
}
|
|
38501
|
+
|
|
38502
|
+
static types(): { [key: string]: any } {
|
|
38503
|
+
return {
|
|
38504
|
+
traffic95Detail: { 'type': 'array', 'itemType': Describe95TrafficResponseBodyTraffic95SummaryTraffic95DetailListTraffic95Detail },
|
|
38505
|
+
};
|
|
38506
|
+
}
|
|
38507
|
+
|
|
38508
|
+
constructor(map?: { [key: string]: any }) {
|
|
38509
|
+
super(map);
|
|
38510
|
+
}
|
|
38511
|
+
}
|
|
38512
|
+
|
|
38513
|
+
export class Describe95TrafficResponseBodyTraffic95Summary extends $tea.Model {
|
|
38514
|
+
bandwidth?: number;
|
|
38515
|
+
fifthPeakBandwidth?: string;
|
|
38516
|
+
instanceId?: string;
|
|
38517
|
+
internetChargeType?: string;
|
|
38518
|
+
minimumConsumeBandwidth?: string;
|
|
38519
|
+
traffic95DetailList?: Describe95TrafficResponseBodyTraffic95SummaryTraffic95DetailList;
|
|
38520
|
+
static names(): { [key: string]: string } {
|
|
38521
|
+
return {
|
|
38522
|
+
bandwidth: 'Bandwidth',
|
|
38523
|
+
fifthPeakBandwidth: 'FifthPeakBandwidth',
|
|
38524
|
+
instanceId: 'InstanceId',
|
|
38525
|
+
internetChargeType: 'InternetChargeType',
|
|
38526
|
+
minimumConsumeBandwidth: 'MinimumConsumeBandwidth',
|
|
38527
|
+
traffic95DetailList: 'Traffic95DetailList',
|
|
38528
|
+
};
|
|
38529
|
+
}
|
|
38530
|
+
|
|
38531
|
+
static types(): { [key: string]: any } {
|
|
38532
|
+
return {
|
|
38533
|
+
bandwidth: 'number',
|
|
38534
|
+
fifthPeakBandwidth: 'string',
|
|
38535
|
+
instanceId: 'string',
|
|
38536
|
+
internetChargeType: 'string',
|
|
38537
|
+
minimumConsumeBandwidth: 'string',
|
|
38538
|
+
traffic95DetailList: Describe95TrafficResponseBodyTraffic95SummaryTraffic95DetailList,
|
|
38539
|
+
};
|
|
38540
|
+
}
|
|
38541
|
+
|
|
38542
|
+
constructor(map?: { [key: string]: any }) {
|
|
38543
|
+
super(map);
|
|
38544
|
+
}
|
|
38545
|
+
}
|
|
38546
|
+
|
|
37236
38547
|
export class DescribeAccessPointsResponseBodyAccessPointSetAccessPointTypeAccessPointFeatureModelsAccessPointFeatureModel extends $tea.Model {
|
|
37237
38548
|
featureKey?: string;
|
|
37238
38549
|
featureValue?: string;
|
|
@@ -38474,6 +39785,276 @@ export class DescribeEipSegmentResponseBodyEipSegments extends $tea.Model {
|
|
|
38474
39785
|
}
|
|
38475
39786
|
}
|
|
38476
39787
|
|
|
39788
|
+
export class DescribeExpressConnectTrafficQosResponseBodyQosListAssociatedInstanceList extends $tea.Model {
|
|
39789
|
+
instanceId?: string;
|
|
39790
|
+
instanceProgressing?: number;
|
|
39791
|
+
instanceStatus?: string;
|
|
39792
|
+
instanceType?: string;
|
|
39793
|
+
static names(): { [key: string]: string } {
|
|
39794
|
+
return {
|
|
39795
|
+
instanceId: 'InstanceId',
|
|
39796
|
+
instanceProgressing: 'InstanceProgressing',
|
|
39797
|
+
instanceStatus: 'InstanceStatus',
|
|
39798
|
+
instanceType: 'InstanceType',
|
|
39799
|
+
};
|
|
39800
|
+
}
|
|
39801
|
+
|
|
39802
|
+
static types(): { [key: string]: any } {
|
|
39803
|
+
return {
|
|
39804
|
+
instanceId: 'string',
|
|
39805
|
+
instanceProgressing: 'number',
|
|
39806
|
+
instanceStatus: 'string',
|
|
39807
|
+
instanceType: 'string',
|
|
39808
|
+
};
|
|
39809
|
+
}
|
|
39810
|
+
|
|
39811
|
+
constructor(map?: { [key: string]: any }) {
|
|
39812
|
+
super(map);
|
|
39813
|
+
}
|
|
39814
|
+
}
|
|
39815
|
+
|
|
39816
|
+
export class DescribeExpressConnectTrafficQosResponseBodyQosListQueueList extends $tea.Model {
|
|
39817
|
+
bandwidthPercent?: string;
|
|
39818
|
+
qosId?: string;
|
|
39819
|
+
queueDescription?: string;
|
|
39820
|
+
queueId?: string;
|
|
39821
|
+
queueName?: string;
|
|
39822
|
+
queueType?: string;
|
|
39823
|
+
status?: string;
|
|
39824
|
+
static names(): { [key: string]: string } {
|
|
39825
|
+
return {
|
|
39826
|
+
bandwidthPercent: 'BandwidthPercent',
|
|
39827
|
+
qosId: 'QosId',
|
|
39828
|
+
queueDescription: 'QueueDescription',
|
|
39829
|
+
queueId: 'QueueId',
|
|
39830
|
+
queueName: 'QueueName',
|
|
39831
|
+
queueType: 'QueueType',
|
|
39832
|
+
status: 'Status',
|
|
39833
|
+
};
|
|
39834
|
+
}
|
|
39835
|
+
|
|
39836
|
+
static types(): { [key: string]: any } {
|
|
39837
|
+
return {
|
|
39838
|
+
bandwidthPercent: 'string',
|
|
39839
|
+
qosId: 'string',
|
|
39840
|
+
queueDescription: 'string',
|
|
39841
|
+
queueId: 'string',
|
|
39842
|
+
queueName: 'string',
|
|
39843
|
+
queueType: 'string',
|
|
39844
|
+
status: 'string',
|
|
39845
|
+
};
|
|
39846
|
+
}
|
|
39847
|
+
|
|
39848
|
+
constructor(map?: { [key: string]: any }) {
|
|
39849
|
+
super(map);
|
|
39850
|
+
}
|
|
39851
|
+
}
|
|
39852
|
+
|
|
39853
|
+
export class DescribeExpressConnectTrafficQosResponseBodyQosList extends $tea.Model {
|
|
39854
|
+
associatedInstanceList?: DescribeExpressConnectTrafficQosResponseBodyQosListAssociatedInstanceList[];
|
|
39855
|
+
progressing?: number;
|
|
39856
|
+
qosDescription?: string;
|
|
39857
|
+
qosId?: string;
|
|
39858
|
+
qosName?: string;
|
|
39859
|
+
queueList?: DescribeExpressConnectTrafficQosResponseBodyQosListQueueList[];
|
|
39860
|
+
status?: string;
|
|
39861
|
+
static names(): { [key: string]: string } {
|
|
39862
|
+
return {
|
|
39863
|
+
associatedInstanceList: 'AssociatedInstanceList',
|
|
39864
|
+
progressing: 'Progressing',
|
|
39865
|
+
qosDescription: 'QosDescription',
|
|
39866
|
+
qosId: 'QosId',
|
|
39867
|
+
qosName: 'QosName',
|
|
39868
|
+
queueList: 'QueueList',
|
|
39869
|
+
status: 'Status',
|
|
39870
|
+
};
|
|
39871
|
+
}
|
|
39872
|
+
|
|
39873
|
+
static types(): { [key: string]: any } {
|
|
39874
|
+
return {
|
|
39875
|
+
associatedInstanceList: { 'type': 'array', 'itemType': DescribeExpressConnectTrafficQosResponseBodyQosListAssociatedInstanceList },
|
|
39876
|
+
progressing: 'number',
|
|
39877
|
+
qosDescription: 'string',
|
|
39878
|
+
qosId: 'string',
|
|
39879
|
+
qosName: 'string',
|
|
39880
|
+
queueList: { 'type': 'array', 'itemType': DescribeExpressConnectTrafficQosResponseBodyQosListQueueList },
|
|
39881
|
+
status: 'string',
|
|
39882
|
+
};
|
|
39883
|
+
}
|
|
39884
|
+
|
|
39885
|
+
constructor(map?: { [key: string]: any }) {
|
|
39886
|
+
super(map);
|
|
39887
|
+
}
|
|
39888
|
+
}
|
|
39889
|
+
|
|
39890
|
+
export class DescribeExpressConnectTrafficQosQueueResponseBodyQueueListRuleList extends $tea.Model {
|
|
39891
|
+
dstCidr?: string;
|
|
39892
|
+
dstIPv6Cidr?: string;
|
|
39893
|
+
dstPortRange?: string;
|
|
39894
|
+
matchDscp?: number;
|
|
39895
|
+
priority?: number;
|
|
39896
|
+
protocol?: string;
|
|
39897
|
+
qosId?: string;
|
|
39898
|
+
queueId?: string;
|
|
39899
|
+
remarkingDscp?: number;
|
|
39900
|
+
ruleDescription?: string;
|
|
39901
|
+
ruleId?: string;
|
|
39902
|
+
ruleName?: string;
|
|
39903
|
+
srcCidr?: string;
|
|
39904
|
+
srcIPv6Cidr?: string;
|
|
39905
|
+
srcPortRange?: string;
|
|
39906
|
+
status?: string;
|
|
39907
|
+
static names(): { [key: string]: string } {
|
|
39908
|
+
return {
|
|
39909
|
+
dstCidr: 'DstCidr',
|
|
39910
|
+
dstIPv6Cidr: 'DstIPv6Cidr',
|
|
39911
|
+
dstPortRange: 'DstPortRange',
|
|
39912
|
+
matchDscp: 'MatchDscp',
|
|
39913
|
+
priority: 'Priority',
|
|
39914
|
+
protocol: 'Protocol',
|
|
39915
|
+
qosId: 'QosId',
|
|
39916
|
+
queueId: 'QueueId',
|
|
39917
|
+
remarkingDscp: 'RemarkingDscp',
|
|
39918
|
+
ruleDescription: 'RuleDescription',
|
|
39919
|
+
ruleId: 'RuleId',
|
|
39920
|
+
ruleName: 'RuleName',
|
|
39921
|
+
srcCidr: 'SrcCidr',
|
|
39922
|
+
srcIPv6Cidr: 'SrcIPv6Cidr',
|
|
39923
|
+
srcPortRange: 'SrcPortRange',
|
|
39924
|
+
status: 'Status',
|
|
39925
|
+
};
|
|
39926
|
+
}
|
|
39927
|
+
|
|
39928
|
+
static types(): { [key: string]: any } {
|
|
39929
|
+
return {
|
|
39930
|
+
dstCidr: 'string',
|
|
39931
|
+
dstIPv6Cidr: 'string',
|
|
39932
|
+
dstPortRange: 'string',
|
|
39933
|
+
matchDscp: 'number',
|
|
39934
|
+
priority: 'number',
|
|
39935
|
+
protocol: 'string',
|
|
39936
|
+
qosId: 'string',
|
|
39937
|
+
queueId: 'string',
|
|
39938
|
+
remarkingDscp: 'number',
|
|
39939
|
+
ruleDescription: 'string',
|
|
39940
|
+
ruleId: 'string',
|
|
39941
|
+
ruleName: 'string',
|
|
39942
|
+
srcCidr: 'string',
|
|
39943
|
+
srcIPv6Cidr: 'string',
|
|
39944
|
+
srcPortRange: 'string',
|
|
39945
|
+
status: 'string',
|
|
39946
|
+
};
|
|
39947
|
+
}
|
|
39948
|
+
|
|
39949
|
+
constructor(map?: { [key: string]: any }) {
|
|
39950
|
+
super(map);
|
|
39951
|
+
}
|
|
39952
|
+
}
|
|
39953
|
+
|
|
39954
|
+
export class DescribeExpressConnectTrafficQosQueueResponseBodyQueueList extends $tea.Model {
|
|
39955
|
+
bandwidthPercent?: string;
|
|
39956
|
+
qosId?: string;
|
|
39957
|
+
queueDescription?: string;
|
|
39958
|
+
queueId?: string;
|
|
39959
|
+
queueName?: string;
|
|
39960
|
+
queueType?: string;
|
|
39961
|
+
ruleList?: DescribeExpressConnectTrafficQosQueueResponseBodyQueueListRuleList[];
|
|
39962
|
+
status?: string;
|
|
39963
|
+
static names(): { [key: string]: string } {
|
|
39964
|
+
return {
|
|
39965
|
+
bandwidthPercent: 'BandwidthPercent',
|
|
39966
|
+
qosId: 'QosId',
|
|
39967
|
+
queueDescription: 'QueueDescription',
|
|
39968
|
+
queueId: 'QueueId',
|
|
39969
|
+
queueName: 'QueueName',
|
|
39970
|
+
queueType: 'QueueType',
|
|
39971
|
+
ruleList: 'RuleList',
|
|
39972
|
+
status: 'Status',
|
|
39973
|
+
};
|
|
39974
|
+
}
|
|
39975
|
+
|
|
39976
|
+
static types(): { [key: string]: any } {
|
|
39977
|
+
return {
|
|
39978
|
+
bandwidthPercent: 'string',
|
|
39979
|
+
qosId: 'string',
|
|
39980
|
+
queueDescription: 'string',
|
|
39981
|
+
queueId: 'string',
|
|
39982
|
+
queueName: 'string',
|
|
39983
|
+
queueType: 'string',
|
|
39984
|
+
ruleList: { 'type': 'array', 'itemType': DescribeExpressConnectTrafficQosQueueResponseBodyQueueListRuleList },
|
|
39985
|
+
status: 'string',
|
|
39986
|
+
};
|
|
39987
|
+
}
|
|
39988
|
+
|
|
39989
|
+
constructor(map?: { [key: string]: any }) {
|
|
39990
|
+
super(map);
|
|
39991
|
+
}
|
|
39992
|
+
}
|
|
39993
|
+
|
|
39994
|
+
export class DescribeExpressConnectTrafficQosRuleResponseBodyRuleList extends $tea.Model {
|
|
39995
|
+
dstCidr?: string;
|
|
39996
|
+
dstIPv6Cidr?: string;
|
|
39997
|
+
dstPortRange?: string;
|
|
39998
|
+
matchDscp?: number;
|
|
39999
|
+
priority?: number;
|
|
40000
|
+
protocol?: string;
|
|
40001
|
+
qosId?: string;
|
|
40002
|
+
queueId?: string;
|
|
40003
|
+
remarkingDscp?: number;
|
|
40004
|
+
ruleDescription?: string;
|
|
40005
|
+
ruleId?: string;
|
|
40006
|
+
ruleName?: string;
|
|
40007
|
+
srcCidr?: string;
|
|
40008
|
+
srcIPv6Cidr?: string;
|
|
40009
|
+
srcPortRange?: string;
|
|
40010
|
+
status?: string;
|
|
40011
|
+
static names(): { [key: string]: string } {
|
|
40012
|
+
return {
|
|
40013
|
+
dstCidr: 'DstCidr',
|
|
40014
|
+
dstIPv6Cidr: 'DstIPv6Cidr',
|
|
40015
|
+
dstPortRange: 'DstPortRange',
|
|
40016
|
+
matchDscp: 'MatchDscp',
|
|
40017
|
+
priority: 'Priority',
|
|
40018
|
+
protocol: 'Protocol',
|
|
40019
|
+
qosId: 'QosId',
|
|
40020
|
+
queueId: 'QueueId',
|
|
40021
|
+
remarkingDscp: 'RemarkingDscp',
|
|
40022
|
+
ruleDescription: 'RuleDescription',
|
|
40023
|
+
ruleId: 'RuleId',
|
|
40024
|
+
ruleName: 'RuleName',
|
|
40025
|
+
srcCidr: 'SrcCidr',
|
|
40026
|
+
srcIPv6Cidr: 'SrcIPv6Cidr',
|
|
40027
|
+
srcPortRange: 'SrcPortRange',
|
|
40028
|
+
status: 'Status',
|
|
40029
|
+
};
|
|
40030
|
+
}
|
|
40031
|
+
|
|
40032
|
+
static types(): { [key: string]: any } {
|
|
40033
|
+
return {
|
|
40034
|
+
dstCidr: 'string',
|
|
40035
|
+
dstIPv6Cidr: 'string',
|
|
40036
|
+
dstPortRange: 'string',
|
|
40037
|
+
matchDscp: 'number',
|
|
40038
|
+
priority: 'number',
|
|
40039
|
+
protocol: 'string',
|
|
40040
|
+
qosId: 'string',
|
|
40041
|
+
queueId: 'string',
|
|
40042
|
+
remarkingDscp: 'number',
|
|
40043
|
+
ruleDescription: 'string',
|
|
40044
|
+
ruleId: 'string',
|
|
40045
|
+
ruleName: 'string',
|
|
40046
|
+
srcCidr: 'string',
|
|
40047
|
+
srcIPv6Cidr: 'string',
|
|
40048
|
+
srcPortRange: 'string',
|
|
40049
|
+
status: 'string',
|
|
40050
|
+
};
|
|
40051
|
+
}
|
|
40052
|
+
|
|
40053
|
+
constructor(map?: { [key: string]: any }) {
|
|
40054
|
+
super(map);
|
|
40055
|
+
}
|
|
40056
|
+
}
|
|
40057
|
+
|
|
38477
40058
|
export class DescribeFailoverTestJobResponseBodyFailoverTestJobModel extends $tea.Model {
|
|
38478
40059
|
description?: string;
|
|
38479
40060
|
jobDuration?: string;
|
|
@@ -39635,6 +41216,7 @@ export class DescribeIpv6AddressesResponseBodyIpv6AddressesIpv6Address extends $
|
|
|
39635
41216
|
networkType?: string;
|
|
39636
41217
|
realBandwidth?: number;
|
|
39637
41218
|
resourceGroupId?: string;
|
|
41219
|
+
serviceManaged?: number;
|
|
39638
41220
|
status?: string;
|
|
39639
41221
|
tags?: DescribeIpv6AddressesResponseBodyIpv6AddressesIpv6AddressTags;
|
|
39640
41222
|
vSwitchId?: string;
|
|
@@ -39654,6 +41236,7 @@ export class DescribeIpv6AddressesResponseBodyIpv6AddressesIpv6Address extends $
|
|
|
39654
41236
|
networkType: 'NetworkType',
|
|
39655
41237
|
realBandwidth: 'RealBandwidth',
|
|
39656
41238
|
resourceGroupId: 'ResourceGroupId',
|
|
41239
|
+
serviceManaged: 'ServiceManaged',
|
|
39657
41240
|
status: 'Status',
|
|
39658
41241
|
tags: 'Tags',
|
|
39659
41242
|
vSwitchId: 'VSwitchId',
|
|
@@ -39676,6 +41259,7 @@ export class DescribeIpv6AddressesResponseBodyIpv6AddressesIpv6Address extends $
|
|
|
39676
41259
|
networkType: 'string',
|
|
39677
41260
|
realBandwidth: 'number',
|
|
39678
41261
|
resourceGroupId: 'string',
|
|
41262
|
+
serviceManaged: 'number',
|
|
39679
41263
|
status: 'string',
|
|
39680
41264
|
tags: DescribeIpv6AddressesResponseBodyIpv6AddressesIpv6AddressTags,
|
|
39681
41265
|
vSwitchId: 'string',
|
|
@@ -43040,6 +44624,7 @@ export class DescribeVirtualBorderRoutersResponseBodyVirtualBorderRouterSetVirtu
|
|
|
43040
44624
|
eccId?: string;
|
|
43041
44625
|
ecrAttatchStatus?: string;
|
|
43042
44626
|
ecrId?: string;
|
|
44627
|
+
ecrOwnerId?: string;
|
|
43043
44628
|
enableIpv6?: boolean;
|
|
43044
44629
|
localGatewayIp?: string;
|
|
43045
44630
|
localIpv6GatewayIp?: string;
|
|
@@ -43082,6 +44667,7 @@ export class DescribeVirtualBorderRoutersResponseBodyVirtualBorderRouterSetVirtu
|
|
|
43082
44667
|
eccId: 'EccId',
|
|
43083
44668
|
ecrAttatchStatus: 'EcrAttatchStatus',
|
|
43084
44669
|
ecrId: 'EcrId',
|
|
44670
|
+
ecrOwnerId: 'EcrOwnerId',
|
|
43085
44671
|
enableIpv6: 'EnableIpv6',
|
|
43086
44672
|
localGatewayIp: 'LocalGatewayIp',
|
|
43087
44673
|
localIpv6GatewayIp: 'LocalIpv6GatewayIp',
|
|
@@ -43127,6 +44713,7 @@ export class DescribeVirtualBorderRoutersResponseBodyVirtualBorderRouterSetVirtu
|
|
|
43127
44713
|
eccId: 'string',
|
|
43128
44714
|
ecrAttatchStatus: 'string',
|
|
43129
44715
|
ecrId: 'string',
|
|
44716
|
+
ecrOwnerId: 'string',
|
|
43130
44717
|
enableIpv6: 'boolean',
|
|
43131
44718
|
localGatewayIp: 'string',
|
|
43132
44719
|
localIpv6GatewayIp: 'string',
|
|
@@ -43787,6 +45374,7 @@ export class DescribeVpcsResponseBodyVpcsVpc extends $tea.Model {
|
|
|
43787
45374
|
description?: string;
|
|
43788
45375
|
dhcpOptionsSetId?: string;
|
|
43789
45376
|
dhcpOptionsSetStatus?: string;
|
|
45377
|
+
enabledIpv6?: boolean;
|
|
43790
45378
|
ipv6CidrBlock?: string;
|
|
43791
45379
|
ipv6CidrBlocks?: DescribeVpcsResponseBodyVpcsVpcIpv6CidrBlocks;
|
|
43792
45380
|
isDefault?: boolean;
|
|
@@ -43811,6 +45399,7 @@ export class DescribeVpcsResponseBodyVpcsVpc extends $tea.Model {
|
|
|
43811
45399
|
description: 'Description',
|
|
43812
45400
|
dhcpOptionsSetId: 'DhcpOptionsSetId',
|
|
43813
45401
|
dhcpOptionsSetStatus: 'DhcpOptionsSetStatus',
|
|
45402
|
+
enabledIpv6: 'EnabledIpv6',
|
|
43814
45403
|
ipv6CidrBlock: 'Ipv6CidrBlock',
|
|
43815
45404
|
ipv6CidrBlocks: 'Ipv6CidrBlocks',
|
|
43816
45405
|
isDefault: 'IsDefault',
|
|
@@ -43838,6 +45427,7 @@ export class DescribeVpcsResponseBodyVpcsVpc extends $tea.Model {
|
|
|
43838
45427
|
description: 'string',
|
|
43839
45428
|
dhcpOptionsSetId: 'string',
|
|
43840
45429
|
dhcpOptionsSetStatus: 'string',
|
|
45430
|
+
enabledIpv6: 'boolean',
|
|
43841
45431
|
ipv6CidrBlock: 'string',
|
|
43842
45432
|
ipv6CidrBlocks: DescribeVpcsResponseBodyVpcsVpcIpv6CidrBlocks,
|
|
43843
45433
|
isDefault: 'boolean',
|
|
@@ -47797,6 +49387,50 @@ export class ListVpnCertificateAssociationsResponseBodyVpnCertificateRelations e
|
|
|
47797
49387
|
}
|
|
47798
49388
|
}
|
|
47799
49389
|
|
|
49390
|
+
export class ModifyExpressConnectTrafficQosRequestAddInstanceList extends $tea.Model {
|
|
49391
|
+
instanceId?: string;
|
|
49392
|
+
instanceType?: string;
|
|
49393
|
+
static names(): { [key: string]: string } {
|
|
49394
|
+
return {
|
|
49395
|
+
instanceId: 'InstanceId',
|
|
49396
|
+
instanceType: 'InstanceType',
|
|
49397
|
+
};
|
|
49398
|
+
}
|
|
49399
|
+
|
|
49400
|
+
static types(): { [key: string]: any } {
|
|
49401
|
+
return {
|
|
49402
|
+
instanceId: 'string',
|
|
49403
|
+
instanceType: 'string',
|
|
49404
|
+
};
|
|
49405
|
+
}
|
|
49406
|
+
|
|
49407
|
+
constructor(map?: { [key: string]: any }) {
|
|
49408
|
+
super(map);
|
|
49409
|
+
}
|
|
49410
|
+
}
|
|
49411
|
+
|
|
49412
|
+
export class ModifyExpressConnectTrafficQosRequestRemoveInstanceList extends $tea.Model {
|
|
49413
|
+
instanceId?: string;
|
|
49414
|
+
instanceType?: string;
|
|
49415
|
+
static names(): { [key: string]: string } {
|
|
49416
|
+
return {
|
|
49417
|
+
instanceId: 'InstanceId',
|
|
49418
|
+
instanceType: 'InstanceType',
|
|
49419
|
+
};
|
|
49420
|
+
}
|
|
49421
|
+
|
|
49422
|
+
static types(): { [key: string]: any } {
|
|
49423
|
+
return {
|
|
49424
|
+
instanceId: 'string',
|
|
49425
|
+
instanceType: 'string',
|
|
49426
|
+
};
|
|
49427
|
+
}
|
|
49428
|
+
|
|
49429
|
+
constructor(map?: { [key: string]: any }) {
|
|
49430
|
+
super(map);
|
|
49431
|
+
}
|
|
49432
|
+
}
|
|
49433
|
+
|
|
47800
49434
|
export class ModifyTunnelAttributeRequestTunnelOptionsSpecificationTunnelBgpConfig extends $tea.Model {
|
|
47801
49435
|
localAsn?: number;
|
|
47802
49436
|
localBgpIp?: string;
|
|
@@ -52594,6 +54228,237 @@ export default class Client extends OpenApi {
|
|
|
52594
54228
|
return await this.createExpressCloudConnectionWithOptions(request, runtime);
|
|
52595
54229
|
}
|
|
52596
54230
|
|
|
54231
|
+
async createExpressConnectTrafficQosWithOptions(request: CreateExpressConnectTrafficQosRequest, runtime: $Util.RuntimeOptions): Promise<CreateExpressConnectTrafficQosResponse> {
|
|
54232
|
+
Util.validateModel(request);
|
|
54233
|
+
let query = { };
|
|
54234
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
54235
|
+
query["ClientToken"] = request.clientToken;
|
|
54236
|
+
}
|
|
54237
|
+
|
|
54238
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
54239
|
+
query["ClientToken"] = request.clientToken;
|
|
54240
|
+
}
|
|
54241
|
+
|
|
54242
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
54243
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
54244
|
+
}
|
|
54245
|
+
|
|
54246
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
54247
|
+
query["OwnerId"] = request.ownerId;
|
|
54248
|
+
}
|
|
54249
|
+
|
|
54250
|
+
if (!Util.isUnset(request.qosDescription)) {
|
|
54251
|
+
query["QosDescription"] = request.qosDescription;
|
|
54252
|
+
}
|
|
54253
|
+
|
|
54254
|
+
if (!Util.isUnset(request.qosName)) {
|
|
54255
|
+
query["QosName"] = request.qosName;
|
|
54256
|
+
}
|
|
54257
|
+
|
|
54258
|
+
if (!Util.isUnset(request.regionId)) {
|
|
54259
|
+
query["RegionId"] = request.regionId;
|
|
54260
|
+
}
|
|
54261
|
+
|
|
54262
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
54263
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
54264
|
+
}
|
|
54265
|
+
|
|
54266
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
54267
|
+
query: OpenApiUtil.query(query),
|
|
54268
|
+
});
|
|
54269
|
+
let params = new $OpenApi.Params({
|
|
54270
|
+
action: "CreateExpressConnectTrafficQos",
|
|
54271
|
+
version: "2016-04-28",
|
|
54272
|
+
protocol: "HTTPS",
|
|
54273
|
+
pathname: "/",
|
|
54274
|
+
method: "POST",
|
|
54275
|
+
authType: "AK",
|
|
54276
|
+
style: "RPC",
|
|
54277
|
+
reqBodyType: "formData",
|
|
54278
|
+
bodyType: "json",
|
|
54279
|
+
});
|
|
54280
|
+
return $tea.cast<CreateExpressConnectTrafficQosResponse>(await this.callApi(params, req, runtime), new CreateExpressConnectTrafficQosResponse({}));
|
|
54281
|
+
}
|
|
54282
|
+
|
|
54283
|
+
async createExpressConnectTrafficQos(request: CreateExpressConnectTrafficQosRequest): Promise<CreateExpressConnectTrafficQosResponse> {
|
|
54284
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
54285
|
+
return await this.createExpressConnectTrafficQosWithOptions(request, runtime);
|
|
54286
|
+
}
|
|
54287
|
+
|
|
54288
|
+
async createExpressConnectTrafficQosQueueWithOptions(request: CreateExpressConnectTrafficQosQueueRequest, runtime: $Util.RuntimeOptions): Promise<CreateExpressConnectTrafficQosQueueResponse> {
|
|
54289
|
+
Util.validateModel(request);
|
|
54290
|
+
let query = { };
|
|
54291
|
+
if (!Util.isUnset(request.bandwidthPercent)) {
|
|
54292
|
+
query["BandwidthPercent"] = request.bandwidthPercent;
|
|
54293
|
+
}
|
|
54294
|
+
|
|
54295
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
54296
|
+
query["ClientToken"] = request.clientToken;
|
|
54297
|
+
}
|
|
54298
|
+
|
|
54299
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
54300
|
+
query["ClientToken"] = request.clientToken;
|
|
54301
|
+
}
|
|
54302
|
+
|
|
54303
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
54304
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
54305
|
+
}
|
|
54306
|
+
|
|
54307
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
54308
|
+
query["OwnerId"] = request.ownerId;
|
|
54309
|
+
}
|
|
54310
|
+
|
|
54311
|
+
if (!Util.isUnset(request.qosId)) {
|
|
54312
|
+
query["QosId"] = request.qosId;
|
|
54313
|
+
}
|
|
54314
|
+
|
|
54315
|
+
if (!Util.isUnset(request.queueDescription)) {
|
|
54316
|
+
query["QueueDescription"] = request.queueDescription;
|
|
54317
|
+
}
|
|
54318
|
+
|
|
54319
|
+
if (!Util.isUnset(request.queueName)) {
|
|
54320
|
+
query["QueueName"] = request.queueName;
|
|
54321
|
+
}
|
|
54322
|
+
|
|
54323
|
+
if (!Util.isUnset(request.queueType)) {
|
|
54324
|
+
query["QueueType"] = request.queueType;
|
|
54325
|
+
}
|
|
54326
|
+
|
|
54327
|
+
if (!Util.isUnset(request.regionId)) {
|
|
54328
|
+
query["RegionId"] = request.regionId;
|
|
54329
|
+
}
|
|
54330
|
+
|
|
54331
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
54332
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
54333
|
+
}
|
|
54334
|
+
|
|
54335
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
54336
|
+
query: OpenApiUtil.query(query),
|
|
54337
|
+
});
|
|
54338
|
+
let params = new $OpenApi.Params({
|
|
54339
|
+
action: "CreateExpressConnectTrafficQosQueue",
|
|
54340
|
+
version: "2016-04-28",
|
|
54341
|
+
protocol: "HTTPS",
|
|
54342
|
+
pathname: "/",
|
|
54343
|
+
method: "POST",
|
|
54344
|
+
authType: "AK",
|
|
54345
|
+
style: "RPC",
|
|
54346
|
+
reqBodyType: "formData",
|
|
54347
|
+
bodyType: "json",
|
|
54348
|
+
});
|
|
54349
|
+
return $tea.cast<CreateExpressConnectTrafficQosQueueResponse>(await this.callApi(params, req, runtime), new CreateExpressConnectTrafficQosQueueResponse({}));
|
|
54350
|
+
}
|
|
54351
|
+
|
|
54352
|
+
async createExpressConnectTrafficQosQueue(request: CreateExpressConnectTrafficQosQueueRequest): Promise<CreateExpressConnectTrafficQosQueueResponse> {
|
|
54353
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
54354
|
+
return await this.createExpressConnectTrafficQosQueueWithOptions(request, runtime);
|
|
54355
|
+
}
|
|
54356
|
+
|
|
54357
|
+
async createExpressConnectTrafficQosRuleWithOptions(request: CreateExpressConnectTrafficQosRuleRequest, runtime: $Util.RuntimeOptions): Promise<CreateExpressConnectTrafficQosRuleResponse> {
|
|
54358
|
+
Util.validateModel(request);
|
|
54359
|
+
let query = { };
|
|
54360
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
54361
|
+
query["ClientToken"] = request.clientToken;
|
|
54362
|
+
}
|
|
54363
|
+
|
|
54364
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
54365
|
+
query["ClientToken"] = request.clientToken;
|
|
54366
|
+
}
|
|
54367
|
+
|
|
54368
|
+
if (!Util.isUnset(request.dstCidr)) {
|
|
54369
|
+
query["DstCidr"] = request.dstCidr;
|
|
54370
|
+
}
|
|
54371
|
+
|
|
54372
|
+
if (!Util.isUnset(request.dstIPv6Cidr)) {
|
|
54373
|
+
query["DstIPv6Cidr"] = request.dstIPv6Cidr;
|
|
54374
|
+
}
|
|
54375
|
+
|
|
54376
|
+
if (!Util.isUnset(request.dstPortRange)) {
|
|
54377
|
+
query["DstPortRange"] = request.dstPortRange;
|
|
54378
|
+
}
|
|
54379
|
+
|
|
54380
|
+
if (!Util.isUnset(request.matchDscp)) {
|
|
54381
|
+
query["MatchDscp"] = request.matchDscp;
|
|
54382
|
+
}
|
|
54383
|
+
|
|
54384
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
54385
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
54386
|
+
}
|
|
54387
|
+
|
|
54388
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
54389
|
+
query["OwnerId"] = request.ownerId;
|
|
54390
|
+
}
|
|
54391
|
+
|
|
54392
|
+
if (!Util.isUnset(request.priority)) {
|
|
54393
|
+
query["Priority"] = request.priority;
|
|
54394
|
+
}
|
|
54395
|
+
|
|
54396
|
+
if (!Util.isUnset(request.protocol)) {
|
|
54397
|
+
query["Protocol"] = request.protocol;
|
|
54398
|
+
}
|
|
54399
|
+
|
|
54400
|
+
if (!Util.isUnset(request.qosId)) {
|
|
54401
|
+
query["QosId"] = request.qosId;
|
|
54402
|
+
}
|
|
54403
|
+
|
|
54404
|
+
if (!Util.isUnset(request.queueId)) {
|
|
54405
|
+
query["QueueId"] = request.queueId;
|
|
54406
|
+
}
|
|
54407
|
+
|
|
54408
|
+
if (!Util.isUnset(request.regionId)) {
|
|
54409
|
+
query["RegionId"] = request.regionId;
|
|
54410
|
+
}
|
|
54411
|
+
|
|
54412
|
+
if (!Util.isUnset(request.remarkingDscp)) {
|
|
54413
|
+
query["RemarkingDscp"] = request.remarkingDscp;
|
|
54414
|
+
}
|
|
54415
|
+
|
|
54416
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
54417
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
54418
|
+
}
|
|
54419
|
+
|
|
54420
|
+
if (!Util.isUnset(request.ruleDescription)) {
|
|
54421
|
+
query["RuleDescription"] = request.ruleDescription;
|
|
54422
|
+
}
|
|
54423
|
+
|
|
54424
|
+
if (!Util.isUnset(request.ruleName)) {
|
|
54425
|
+
query["RuleName"] = request.ruleName;
|
|
54426
|
+
}
|
|
54427
|
+
|
|
54428
|
+
if (!Util.isUnset(request.srcCidr)) {
|
|
54429
|
+
query["SrcCidr"] = request.srcCidr;
|
|
54430
|
+
}
|
|
54431
|
+
|
|
54432
|
+
if (!Util.isUnset(request.srcIPv6Cidr)) {
|
|
54433
|
+
query["SrcIPv6Cidr"] = request.srcIPv6Cidr;
|
|
54434
|
+
}
|
|
54435
|
+
|
|
54436
|
+
if (!Util.isUnset(request.srcPortRange)) {
|
|
54437
|
+
query["SrcPortRange"] = request.srcPortRange;
|
|
54438
|
+
}
|
|
54439
|
+
|
|
54440
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
54441
|
+
query: OpenApiUtil.query(query),
|
|
54442
|
+
});
|
|
54443
|
+
let params = new $OpenApi.Params({
|
|
54444
|
+
action: "CreateExpressConnectTrafficQosRule",
|
|
54445
|
+
version: "2016-04-28",
|
|
54446
|
+
protocol: "HTTPS",
|
|
54447
|
+
pathname: "/",
|
|
54448
|
+
method: "POST",
|
|
54449
|
+
authType: "AK",
|
|
54450
|
+
style: "RPC",
|
|
54451
|
+
reqBodyType: "formData",
|
|
54452
|
+
bodyType: "json",
|
|
54453
|
+
});
|
|
54454
|
+
return $tea.cast<CreateExpressConnectTrafficQosRuleResponse>(await this.callApi(params, req, runtime), new CreateExpressConnectTrafficQosRuleResponse({}));
|
|
54455
|
+
}
|
|
54456
|
+
|
|
54457
|
+
async createExpressConnectTrafficQosRule(request: CreateExpressConnectTrafficQosRuleRequest): Promise<CreateExpressConnectTrafficQosRuleResponse> {
|
|
54458
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
54459
|
+
return await this.createExpressConnectTrafficQosRuleWithOptions(request, runtime);
|
|
54460
|
+
}
|
|
54461
|
+
|
|
52597
54462
|
async createFailoverTestJobWithOptions(request: CreateFailoverTestJobRequest, runtime: $Util.RuntimeOptions): Promise<CreateFailoverTestJobResponse> {
|
|
52598
54463
|
Util.validateModel(request);
|
|
52599
54464
|
let query = { };
|
|
@@ -52668,7 +54533,7 @@ export default class Client extends OpenApi {
|
|
|
52668
54533
|
}
|
|
52669
54534
|
|
|
52670
54535
|
/**
|
|
52671
|
-
* **CreateFlowLog** is an asynchronous operation. After
|
|
54536
|
+
* **CreateFlowLog** 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 [DescribeFlowLogs](~~87923~~) operation to query the status of the flow log.
|
|
52672
54537
|
* * If the flow log is in the **Activating** state, the flow log is being created.
|
|
52673
54538
|
* * If the flow log is in the **Active** state, the flow log is created and started.
|
|
52674
54539
|
*
|
|
@@ -52761,7 +54626,7 @@ export default class Client extends OpenApi {
|
|
|
52761
54626
|
}
|
|
52762
54627
|
|
|
52763
54628
|
/**
|
|
52764
|
-
* **CreateFlowLog** is an asynchronous operation. After
|
|
54629
|
+
* **CreateFlowLog** 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 [DescribeFlowLogs](~~87923~~) operation to query the status of the flow log.
|
|
52765
54630
|
* * If the flow log is in the **Activating** state, the flow log is being created.
|
|
52766
54631
|
* * If the flow log is in the **Active** state, the flow log is created and started.
|
|
52767
54632
|
*
|
|
@@ -53526,10 +55391,11 @@ export default class Client extends OpenApi {
|
|
|
53526
55391
|
|
|
53527
55392
|
/**
|
|
53528
55393
|
* * 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~~).
|
|
53529
|
-
* *
|
|
55394
|
+
* * Before you create an IPsec server, make sure that no IPsec-VPN connection exists on the VPN gateway. For more information, see [DeleteVpnConnection](~~2526948~~).
|
|
55395
|
+
* * **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.
|
|
53530
55396
|
* * If the VPN gateway is in the **updating** state, the IPsec server is being created.
|
|
53531
55397
|
* * If the VPN gateway is in the **active** state, the IPsec server is created.
|
|
53532
|
-
* * You cannot repeatedly call
|
|
55398
|
+
* * You cannot repeatedly call **CreateIpsecServer** within the specified period of time.
|
|
53533
55399
|
*
|
|
53534
55400
|
* @param request CreateIpsecServerRequest
|
|
53535
55401
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -53605,10 +55471,11 @@ export default class Client extends OpenApi {
|
|
|
53605
55471
|
|
|
53606
55472
|
/**
|
|
53607
55473
|
* * 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~~).
|
|
53608
|
-
* *
|
|
55474
|
+
* * Before you create an IPsec server, make sure that no IPsec-VPN connection exists on the VPN gateway. For more information, see [DeleteVpnConnection](~~2526948~~).
|
|
55475
|
+
* * **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.
|
|
53609
55476
|
* * If the VPN gateway is in the **updating** state, the IPsec server is being created.
|
|
53610
55477
|
* * If the VPN gateway is in the **active** state, the IPsec server is created.
|
|
53611
|
-
* * You cannot repeatedly call
|
|
55478
|
+
* * You cannot repeatedly call **CreateIpsecServer** within the specified period of time.
|
|
53612
55479
|
*
|
|
53613
55480
|
* @param request CreateIpsecServerRequest
|
|
53614
55481
|
* @return CreateIpsecServerResponse
|
|
@@ -54995,7 +56862,6 @@ export default class Client extends OpenApi {
|
|
|
54995
56862
|
}
|
|
54996
56863
|
|
|
54997
56864
|
/**
|
|
54998
|
-
* ## [](#)
|
|
54999
56865
|
* When you call this operation, take note of the following limits:
|
|
55000
56866
|
* * You can create only one pair of interfaces to be connected between two routers.
|
|
55001
56867
|
* * You can create a maximum of five router interfaces for a router.
|
|
@@ -55149,7 +57015,6 @@ export default class Client extends OpenApi {
|
|
|
55149
57015
|
}
|
|
55150
57016
|
|
|
55151
57017
|
/**
|
|
55152
|
-
* ## [](#)
|
|
55153
57018
|
* When you call this operation, take note of the following limits:
|
|
55154
57019
|
* * You can create only one pair of interfaces to be connected between two routers.
|
|
55155
57020
|
* * You can create a maximum of five router interfaces for a router.
|
|
@@ -55329,7 +57194,9 @@ export default class Client extends OpenApi {
|
|
|
55329
57194
|
* * **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.
|
|
55330
57195
|
* * If the VPN gateway is in the **updating** state, the SSL server is being created.
|
|
55331
57196
|
* * If the VPN gateway is in the **active** state, the SSL server is created.
|
|
55332
|
-
* * You cannot
|
|
57197
|
+
* * You cannot call the **CreateSslVpnServer** operation to create multiple SSL servers at a time for the same VPN gateway.
|
|
57198
|
+
* ### [](#)Prerequisites
|
|
57199
|
+
* A VPN gateway is created, and the SSL-VPN feature is enabled for the VPN gateway. For more information, see [CreateVpnGateway](~~2526913~~).
|
|
55333
57200
|
*
|
|
55334
57201
|
* @param request CreateSslVpnServerRequest
|
|
55335
57202
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -55427,7 +57294,9 @@ export default class Client extends OpenApi {
|
|
|
55427
57294
|
* * **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.
|
|
55428
57295
|
* * If the VPN gateway is in the **updating** state, the SSL server is being created.
|
|
55429
57296
|
* * If the VPN gateway is in the **active** state, the SSL server is created.
|
|
55430
|
-
* * You cannot
|
|
57297
|
+
* * You cannot call the **CreateSslVpnServer** operation to create multiple SSL servers at a time for the same VPN gateway.
|
|
57298
|
+
* ### [](#)Prerequisites
|
|
57299
|
+
* A VPN gateway is created, and the SSL-VPN feature is enabled for the VPN gateway. For more information, see [CreateVpnGateway](~~2526913~~).
|
|
55431
57300
|
*
|
|
55432
57301
|
* @param request CreateSslVpnServerRequest
|
|
55433
57302
|
* @return CreateSslVpnServerResponse
|
|
@@ -56031,12 +57900,13 @@ export default class Client extends OpenApi {
|
|
|
56031
57900
|
}
|
|
56032
57901
|
|
|
56033
57902
|
/**
|
|
57903
|
+
* * The IPsec-VPN connection must be associated with a transit router. For more information, see [CreateTransitRouterVpnAttachment](~~468249~~).
|
|
56034
57904
|
* * You cannot create a destination-based route whose destination CIDR block is 0.0.0.0/0.
|
|
56035
|
-
* * Do not add a route whose destination CIDR block is 100.64.0.0/10, a
|
|
56036
|
-
* * **CreateVcoRouteEntry** is an asynchronous operation. After
|
|
56037
|
-
* * If the IPsec-VPN connection is in the **updating** state, the route is being created.
|
|
56038
|
-
* * If the IPsec-VPN connection is in the **attached** state, the route is created.
|
|
56039
|
-
* * You cannot repeatedly call **CreateVcoRouteEntry**
|
|
57905
|
+
* * Do not add a destination-based route whose destination CIDR block is 100.64.0.0/10, or a CIDR block that contains 100.64.0.0/10 or belongs to 100.64.0.0/10. Such a route will make the console fail to display the status of the IPsec-VPN connection or cause IPsec negotiation failures.
|
|
57906
|
+
* * **CreateVcoRouteEntry** 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 [DescribeVpnConnection](~~53046~~) to query the status of the task.
|
|
57907
|
+
* * If the IPsec-VPN connection is in the **updating** state, the destination-based route is being created.
|
|
57908
|
+
* * If the IPsec-VPN connection is in the **attached** state, the destination-based route is created.
|
|
57909
|
+
* * You cannot repeatedly call **CreateVcoRouteEntry** within the specified period of time.
|
|
56040
57910
|
*
|
|
56041
57911
|
* @param request CreateVcoRouteEntryRequest
|
|
56042
57912
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -56107,12 +57977,13 @@ export default class Client extends OpenApi {
|
|
|
56107
57977
|
}
|
|
56108
57978
|
|
|
56109
57979
|
/**
|
|
57980
|
+
* * The IPsec-VPN connection must be associated with a transit router. For more information, see [CreateTransitRouterVpnAttachment](~~468249~~).
|
|
56110
57981
|
* * You cannot create a destination-based route whose destination CIDR block is 0.0.0.0/0.
|
|
56111
|
-
* * Do not add a route whose destination CIDR block is 100.64.0.0/10, a
|
|
56112
|
-
* * **CreateVcoRouteEntry** is an asynchronous operation. After
|
|
56113
|
-
* * If the IPsec-VPN connection is in the **updating** state, the route is being created.
|
|
56114
|
-
* * If the IPsec-VPN connection is in the **attached** state, the route is created.
|
|
56115
|
-
* * You cannot repeatedly call **CreateVcoRouteEntry**
|
|
57982
|
+
* * Do not add a destination-based route whose destination CIDR block is 100.64.0.0/10, or a CIDR block that contains 100.64.0.0/10 or belongs to 100.64.0.0/10. Such a route will make the console fail to display the status of the IPsec-VPN connection or cause IPsec negotiation failures.
|
|
57983
|
+
* * **CreateVcoRouteEntry** 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 [DescribeVpnConnection](~~53046~~) to query the status of the task.
|
|
57984
|
+
* * If the IPsec-VPN connection is in the **updating** state, the destination-based route is being created.
|
|
57985
|
+
* * If the IPsec-VPN connection is in the **attached** state, the destination-based route is created.
|
|
57986
|
+
* * You cannot repeatedly call **CreateVcoRouteEntry** within the specified period of time.
|
|
56116
57987
|
*
|
|
56117
57988
|
* @param request CreateVcoRouteEntryRequest
|
|
56118
57989
|
* @return CreateVcoRouteEntryResponse
|
|
@@ -56123,7 +57994,7 @@ export default class Client extends OpenApi {
|
|
|
56123
57994
|
}
|
|
56124
57995
|
|
|
56125
57996
|
/**
|
|
56126
|
-
*
|
|
57997
|
+
* After you create a VBR, the VBR is in the **active** state.
|
|
56127
57998
|
*
|
|
56128
57999
|
* @param request CreateVirtualBorderRouterRequest
|
|
56129
58000
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -56238,7 +58109,7 @@ export default class Client extends OpenApi {
|
|
|
56238
58109
|
}
|
|
56239
58110
|
|
|
56240
58111
|
/**
|
|
56241
|
-
*
|
|
58112
|
+
* After you create a VBR, the VBR is in the **active** state.
|
|
56242
58113
|
*
|
|
56243
58114
|
* @param request CreateVirtualBorderRouterRequest
|
|
56244
58115
|
* @return CreateVirtualBorderRouterResponse
|
|
@@ -56460,6 +58331,16 @@ export default class Client extends OpenApi {
|
|
|
56460
58331
|
return await this.createVpcWithOptions(request, runtime);
|
|
56461
58332
|
}
|
|
56462
58333
|
|
|
58334
|
+
/**
|
|
58335
|
+
* * **CreateVpcGatewayEndpoint** is an asynchronous operation. After a request is sent, the system returns an **EndpointId** and runs the task in the background. You can call the [ListVpcGatewayEndpoints](~~448682~~) operation to query the status of the task.
|
|
58336
|
+
* * If the gateway endpoint is in the **Creating** state, the gateway endpoint is being created.
|
|
58337
|
+
* * If the gateway endpoint is in the **Created** state, the gateway endpoint is created.
|
|
58338
|
+
* * You cannot repeatedly call the **CreateVpcGatewayEndpoint** operation for the same endpoint service within the specified period of time.
|
|
58339
|
+
*
|
|
58340
|
+
* @param request CreateVpcGatewayEndpointRequest
|
|
58341
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
58342
|
+
* @return CreateVpcGatewayEndpointResponse
|
|
58343
|
+
*/
|
|
56463
58344
|
async createVpcGatewayEndpointWithOptions(request: CreateVpcGatewayEndpointRequest, runtime: $Util.RuntimeOptions): Promise<CreateVpcGatewayEndpointResponse> {
|
|
56464
58345
|
Util.validateModel(request);
|
|
56465
58346
|
let query = { };
|
|
@@ -56536,13 +58417,22 @@ export default class Client extends OpenApi {
|
|
|
56536
58417
|
return $tea.cast<CreateVpcGatewayEndpointResponse>(await this.callApi(params, req, runtime), new CreateVpcGatewayEndpointResponse({}));
|
|
56537
58418
|
}
|
|
56538
58419
|
|
|
58420
|
+
/**
|
|
58421
|
+
* * **CreateVpcGatewayEndpoint** is an asynchronous operation. After a request is sent, the system returns an **EndpointId** and runs the task in the background. You can call the [ListVpcGatewayEndpoints](~~448682~~) operation to query the status of the task.
|
|
58422
|
+
* * If the gateway endpoint is in the **Creating** state, the gateway endpoint is being created.
|
|
58423
|
+
* * If the gateway endpoint is in the **Created** state, the gateway endpoint is created.
|
|
58424
|
+
* * You cannot repeatedly call the **CreateVpcGatewayEndpoint** operation for the same endpoint service within the specified period of time.
|
|
58425
|
+
*
|
|
58426
|
+
* @param request CreateVpcGatewayEndpointRequest
|
|
58427
|
+
* @return CreateVpcGatewayEndpointResponse
|
|
58428
|
+
*/
|
|
56539
58429
|
async createVpcGatewayEndpoint(request: CreateVpcGatewayEndpointRequest): Promise<CreateVpcGatewayEndpointResponse> {
|
|
56540
58430
|
let runtime = new $Util.RuntimeOptions({ });
|
|
56541
58431
|
return await this.createVpcGatewayEndpointWithOptions(request, runtime);
|
|
56542
58432
|
}
|
|
56543
58433
|
|
|
56544
58434
|
/**
|
|
56545
|
-
* You cannot repeatedly call the **CreateVpcPrefixList** operation
|
|
58435
|
+
* You cannot repeatedly call the **CreateVpcPrefixList** operation within the specified period of time.
|
|
56546
58436
|
*
|
|
56547
58437
|
* @param request CreateVpcPrefixListRequest
|
|
56548
58438
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -56625,7 +58515,7 @@ export default class Client extends OpenApi {
|
|
|
56625
58515
|
}
|
|
56626
58516
|
|
|
56627
58517
|
/**
|
|
56628
|
-
* You cannot repeatedly call the **CreateVpcPrefixList** operation
|
|
58518
|
+
* You cannot repeatedly call the **CreateVpcPrefixList** operation within the specified period of time.
|
|
56629
58519
|
*
|
|
56630
58520
|
* @param request CreateVpcPrefixListRequest
|
|
56631
58521
|
* @return CreateVpcPrefixListResponse
|
|
@@ -57572,7 +59462,194 @@ export default class Client extends OpenApi {
|
|
|
57572
59462
|
query: OpenApiUtil.query(query),
|
|
57573
59463
|
});
|
|
57574
59464
|
let params = new $OpenApi.Params({
|
|
57575
|
-
action: "DeleteBgpPeer",
|
|
59465
|
+
action: "DeleteBgpPeer",
|
|
59466
|
+
version: "2016-04-28",
|
|
59467
|
+
protocol: "HTTPS",
|
|
59468
|
+
pathname: "/",
|
|
59469
|
+
method: "POST",
|
|
59470
|
+
authType: "AK",
|
|
59471
|
+
style: "RPC",
|
|
59472
|
+
reqBodyType: "formData",
|
|
59473
|
+
bodyType: "json",
|
|
59474
|
+
});
|
|
59475
|
+
return $tea.cast<DeleteBgpPeerResponse>(await this.callApi(params, req, runtime), new DeleteBgpPeerResponse({}));
|
|
59476
|
+
}
|
|
59477
|
+
|
|
59478
|
+
async deleteBgpPeer(request: DeleteBgpPeerRequest): Promise<DeleteBgpPeerResponse> {
|
|
59479
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
59480
|
+
return await this.deleteBgpPeerWithOptions(request, runtime);
|
|
59481
|
+
}
|
|
59482
|
+
|
|
59483
|
+
/**
|
|
59484
|
+
* You cannot repeatedly call the **DeleteCommonBandwidthPackage** operation to delete an Internet Shared Bandwidth instance within the specified period of time.
|
|
59485
|
+
*
|
|
59486
|
+
* @param request DeleteCommonBandwidthPackageRequest
|
|
59487
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
59488
|
+
* @return DeleteCommonBandwidthPackageResponse
|
|
59489
|
+
*/
|
|
59490
|
+
async deleteCommonBandwidthPackageWithOptions(request: DeleteCommonBandwidthPackageRequest, runtime: $Util.RuntimeOptions): Promise<DeleteCommonBandwidthPackageResponse> {
|
|
59491
|
+
Util.validateModel(request);
|
|
59492
|
+
let query = { };
|
|
59493
|
+
if (!Util.isUnset(request.bandwidthPackageId)) {
|
|
59494
|
+
query["BandwidthPackageId"] = request.bandwidthPackageId;
|
|
59495
|
+
}
|
|
59496
|
+
|
|
59497
|
+
if (!Util.isUnset(request.force)) {
|
|
59498
|
+
query["Force"] = request.force;
|
|
59499
|
+
}
|
|
59500
|
+
|
|
59501
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
59502
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
59503
|
+
}
|
|
59504
|
+
|
|
59505
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
59506
|
+
query["OwnerId"] = request.ownerId;
|
|
59507
|
+
}
|
|
59508
|
+
|
|
59509
|
+
if (!Util.isUnset(request.regionId)) {
|
|
59510
|
+
query["RegionId"] = request.regionId;
|
|
59511
|
+
}
|
|
59512
|
+
|
|
59513
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
59514
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
59515
|
+
}
|
|
59516
|
+
|
|
59517
|
+
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
59518
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
59519
|
+
}
|
|
59520
|
+
|
|
59521
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
59522
|
+
query: OpenApiUtil.query(query),
|
|
59523
|
+
});
|
|
59524
|
+
let params = new $OpenApi.Params({
|
|
59525
|
+
action: "DeleteCommonBandwidthPackage",
|
|
59526
|
+
version: "2016-04-28",
|
|
59527
|
+
protocol: "HTTPS",
|
|
59528
|
+
pathname: "/",
|
|
59529
|
+
method: "POST",
|
|
59530
|
+
authType: "AK",
|
|
59531
|
+
style: "RPC",
|
|
59532
|
+
reqBodyType: "formData",
|
|
59533
|
+
bodyType: "json",
|
|
59534
|
+
});
|
|
59535
|
+
return $tea.cast<DeleteCommonBandwidthPackageResponse>(await this.callApi(params, req, runtime), new DeleteCommonBandwidthPackageResponse({}));
|
|
59536
|
+
}
|
|
59537
|
+
|
|
59538
|
+
/**
|
|
59539
|
+
* You cannot repeatedly call the **DeleteCommonBandwidthPackage** operation to delete an Internet Shared Bandwidth instance within the specified period of time.
|
|
59540
|
+
*
|
|
59541
|
+
* @param request DeleteCommonBandwidthPackageRequest
|
|
59542
|
+
* @return DeleteCommonBandwidthPackageResponse
|
|
59543
|
+
*/
|
|
59544
|
+
async deleteCommonBandwidthPackage(request: DeleteCommonBandwidthPackageRequest): Promise<DeleteCommonBandwidthPackageResponse> {
|
|
59545
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
59546
|
+
return await this.deleteCommonBandwidthPackageWithOptions(request, runtime);
|
|
59547
|
+
}
|
|
59548
|
+
|
|
59549
|
+
async deleteCustomerGatewayWithOptions(request: DeleteCustomerGatewayRequest, runtime: $Util.RuntimeOptions): Promise<DeleteCustomerGatewayResponse> {
|
|
59550
|
+
Util.validateModel(request);
|
|
59551
|
+
let query = { };
|
|
59552
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
59553
|
+
query["ClientToken"] = request.clientToken;
|
|
59554
|
+
}
|
|
59555
|
+
|
|
59556
|
+
if (!Util.isUnset(request.customerGatewayId)) {
|
|
59557
|
+
query["CustomerGatewayId"] = request.customerGatewayId;
|
|
59558
|
+
}
|
|
59559
|
+
|
|
59560
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
59561
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
59562
|
+
}
|
|
59563
|
+
|
|
59564
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
59565
|
+
query["OwnerId"] = request.ownerId;
|
|
59566
|
+
}
|
|
59567
|
+
|
|
59568
|
+
if (!Util.isUnset(request.regionId)) {
|
|
59569
|
+
query["RegionId"] = request.regionId;
|
|
59570
|
+
}
|
|
59571
|
+
|
|
59572
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
59573
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
59574
|
+
}
|
|
59575
|
+
|
|
59576
|
+
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
59577
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
59578
|
+
}
|
|
59579
|
+
|
|
59580
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
59581
|
+
query: OpenApiUtil.query(query),
|
|
59582
|
+
});
|
|
59583
|
+
let params = new $OpenApi.Params({
|
|
59584
|
+
action: "DeleteCustomerGateway",
|
|
59585
|
+
version: "2016-04-28",
|
|
59586
|
+
protocol: "HTTPS",
|
|
59587
|
+
pathname: "/",
|
|
59588
|
+
method: "POST",
|
|
59589
|
+
authType: "AK",
|
|
59590
|
+
style: "RPC",
|
|
59591
|
+
reqBodyType: "formData",
|
|
59592
|
+
bodyType: "json",
|
|
59593
|
+
});
|
|
59594
|
+
return $tea.cast<DeleteCustomerGatewayResponse>(await this.callApi(params, req, runtime), new DeleteCustomerGatewayResponse({}));
|
|
59595
|
+
}
|
|
59596
|
+
|
|
59597
|
+
async deleteCustomerGateway(request: DeleteCustomerGatewayRequest): Promise<DeleteCustomerGatewayResponse> {
|
|
59598
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
59599
|
+
return await this.deleteCustomerGatewayWithOptions(request, runtime);
|
|
59600
|
+
}
|
|
59601
|
+
|
|
59602
|
+
/**
|
|
59603
|
+
* ## [](#)Description
|
|
59604
|
+
* * **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.
|
|
59605
|
+
* * If the DHCP options set is in the **Deleting** state, the DHCP options set is being deleted.
|
|
59606
|
+
* * If you cannot query the DHCP options set, the DHCP options set is deleted.
|
|
59607
|
+
* * You cannot repeatedly call the **DeleteDhcpOptionsSet** operation to delete a DHCP options set within the specified period of time.
|
|
59608
|
+
*
|
|
59609
|
+
* @param request DeleteDhcpOptionsSetRequest
|
|
59610
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
59611
|
+
* @return DeleteDhcpOptionsSetResponse
|
|
59612
|
+
*/
|
|
59613
|
+
async deleteDhcpOptionsSetWithOptions(request: DeleteDhcpOptionsSetRequest, runtime: $Util.RuntimeOptions): Promise<DeleteDhcpOptionsSetResponse> {
|
|
59614
|
+
Util.validateModel(request);
|
|
59615
|
+
let query = { };
|
|
59616
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
59617
|
+
query["ClientToken"] = request.clientToken;
|
|
59618
|
+
}
|
|
59619
|
+
|
|
59620
|
+
if (!Util.isUnset(request.dhcpOptionsSetId)) {
|
|
59621
|
+
query["DhcpOptionsSetId"] = request.dhcpOptionsSetId;
|
|
59622
|
+
}
|
|
59623
|
+
|
|
59624
|
+
if (!Util.isUnset(request.dryRun)) {
|
|
59625
|
+
query["DryRun"] = request.dryRun;
|
|
59626
|
+
}
|
|
59627
|
+
|
|
59628
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
59629
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
59630
|
+
}
|
|
59631
|
+
|
|
59632
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
59633
|
+
query["OwnerId"] = request.ownerId;
|
|
59634
|
+
}
|
|
59635
|
+
|
|
59636
|
+
if (!Util.isUnset(request.regionId)) {
|
|
59637
|
+
query["RegionId"] = request.regionId;
|
|
59638
|
+
}
|
|
59639
|
+
|
|
59640
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
59641
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
59642
|
+
}
|
|
59643
|
+
|
|
59644
|
+
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
59645
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
59646
|
+
}
|
|
59647
|
+
|
|
59648
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
59649
|
+
query: OpenApiUtil.query(query),
|
|
59650
|
+
});
|
|
59651
|
+
let params = new $OpenApi.Params({
|
|
59652
|
+
action: "DeleteDhcpOptionsSet",
|
|
57576
59653
|
version: "2016-04-28",
|
|
57577
59654
|
protocol: "HTTPS",
|
|
57578
59655
|
pathname: "/",
|
|
@@ -57582,30 +59659,33 @@ export default class Client extends OpenApi {
|
|
|
57582
59659
|
reqBodyType: "formData",
|
|
57583
59660
|
bodyType: "json",
|
|
57584
59661
|
});
|
|
57585
|
-
return $tea.cast<
|
|
57586
|
-
}
|
|
57587
|
-
|
|
57588
|
-
async deleteBgpPeer(request: DeleteBgpPeerRequest): Promise<DeleteBgpPeerResponse> {
|
|
57589
|
-
let runtime = new $Util.RuntimeOptions({ });
|
|
57590
|
-
return await this.deleteBgpPeerWithOptions(request, runtime);
|
|
59662
|
+
return $tea.cast<DeleteDhcpOptionsSetResponse>(await this.callApi(params, req, runtime), new DeleteDhcpOptionsSetResponse({}));
|
|
57591
59663
|
}
|
|
57592
59664
|
|
|
57593
59665
|
/**
|
|
57594
|
-
*
|
|
59666
|
+
* ## [](#)Description
|
|
59667
|
+
* * **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.
|
|
59668
|
+
* * If the DHCP options set is in the **Deleting** state, the DHCP options set is being deleted.
|
|
59669
|
+
* * If you cannot query the DHCP options set, the DHCP options set is deleted.
|
|
59670
|
+
* * You cannot repeatedly call the **DeleteDhcpOptionsSet** operation to delete a DHCP options set within the specified period of time.
|
|
57595
59671
|
*
|
|
57596
|
-
* @param request
|
|
57597
|
-
* @
|
|
57598
|
-
* @return DeleteCommonBandwidthPackageResponse
|
|
59672
|
+
* @param request DeleteDhcpOptionsSetRequest
|
|
59673
|
+
* @return DeleteDhcpOptionsSetResponse
|
|
57599
59674
|
*/
|
|
57600
|
-
async
|
|
59675
|
+
async deleteDhcpOptionsSet(request: DeleteDhcpOptionsSetRequest): Promise<DeleteDhcpOptionsSetResponse> {
|
|
59676
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
59677
|
+
return await this.deleteDhcpOptionsSetWithOptions(request, runtime);
|
|
59678
|
+
}
|
|
59679
|
+
|
|
59680
|
+
async deleteExpressConnectTrafficQosWithOptions(request: DeleteExpressConnectTrafficQosRequest, runtime: $Util.RuntimeOptions): Promise<DeleteExpressConnectTrafficQosResponse> {
|
|
57601
59681
|
Util.validateModel(request);
|
|
57602
59682
|
let query = { };
|
|
57603
|
-
if (!Util.isUnset(request.
|
|
57604
|
-
query["
|
|
59683
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
59684
|
+
query["ClientToken"] = request.clientToken;
|
|
57605
59685
|
}
|
|
57606
59686
|
|
|
57607
|
-
if (!Util.isUnset(request.
|
|
57608
|
-
query["
|
|
59687
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
59688
|
+
query["ClientToken"] = request.clientToken;
|
|
57609
59689
|
}
|
|
57610
59690
|
|
|
57611
59691
|
if (!Util.isUnset(request.ownerAccount)) {
|
|
@@ -57616,6 +59696,10 @@ export default class Client extends OpenApi {
|
|
|
57616
59696
|
query["OwnerId"] = request.ownerId;
|
|
57617
59697
|
}
|
|
57618
59698
|
|
|
59699
|
+
if (!Util.isUnset(request.qosId)) {
|
|
59700
|
+
query["QosId"] = request.qosId;
|
|
59701
|
+
}
|
|
59702
|
+
|
|
57619
59703
|
if (!Util.isUnset(request.regionId)) {
|
|
57620
59704
|
query["RegionId"] = request.regionId;
|
|
57621
59705
|
}
|
|
@@ -57624,15 +59708,11 @@ export default class Client extends OpenApi {
|
|
|
57624
59708
|
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
57625
59709
|
}
|
|
57626
59710
|
|
|
57627
|
-
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
57628
|
-
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
57629
|
-
}
|
|
57630
|
-
|
|
57631
59711
|
let req = new $OpenApi.OpenApiRequest({
|
|
57632
59712
|
query: OpenApiUtil.query(query),
|
|
57633
59713
|
});
|
|
57634
59714
|
let params = new $OpenApi.Params({
|
|
57635
|
-
action: "
|
|
59715
|
+
action: "DeleteExpressConnectTrafficQos",
|
|
57636
59716
|
version: "2016-04-28",
|
|
57637
59717
|
protocol: "HTTPS",
|
|
57638
59718
|
pathname: "/",
|
|
@@ -57642,29 +59722,23 @@ export default class Client extends OpenApi {
|
|
|
57642
59722
|
reqBodyType: "formData",
|
|
57643
59723
|
bodyType: "json",
|
|
57644
59724
|
});
|
|
57645
|
-
return $tea.cast<
|
|
59725
|
+
return $tea.cast<DeleteExpressConnectTrafficQosResponse>(await this.callApi(params, req, runtime), new DeleteExpressConnectTrafficQosResponse({}));
|
|
57646
59726
|
}
|
|
57647
59727
|
|
|
57648
|
-
|
|
57649
|
-
* You cannot repeatedly call the **DeleteCommonBandwidthPackage** operation to delete an Internet Shared Bandwidth instance within the specified period of time.
|
|
57650
|
-
*
|
|
57651
|
-
* @param request DeleteCommonBandwidthPackageRequest
|
|
57652
|
-
* @return DeleteCommonBandwidthPackageResponse
|
|
57653
|
-
*/
|
|
57654
|
-
async deleteCommonBandwidthPackage(request: DeleteCommonBandwidthPackageRequest): Promise<DeleteCommonBandwidthPackageResponse> {
|
|
59728
|
+
async deleteExpressConnectTrafficQos(request: DeleteExpressConnectTrafficQosRequest): Promise<DeleteExpressConnectTrafficQosResponse> {
|
|
57655
59729
|
let runtime = new $Util.RuntimeOptions({ });
|
|
57656
|
-
return await this.
|
|
59730
|
+
return await this.deleteExpressConnectTrafficQosWithOptions(request, runtime);
|
|
57657
59731
|
}
|
|
57658
59732
|
|
|
57659
|
-
async
|
|
59733
|
+
async deleteExpressConnectTrafficQosQueueWithOptions(request: DeleteExpressConnectTrafficQosQueueRequest, runtime: $Util.RuntimeOptions): Promise<DeleteExpressConnectTrafficQosQueueResponse> {
|
|
57660
59734
|
Util.validateModel(request);
|
|
57661
59735
|
let query = { };
|
|
57662
59736
|
if (!Util.isUnset(request.clientToken)) {
|
|
57663
59737
|
query["ClientToken"] = request.clientToken;
|
|
57664
59738
|
}
|
|
57665
59739
|
|
|
57666
|
-
if (!Util.isUnset(request.
|
|
57667
|
-
query["
|
|
59740
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
59741
|
+
query["ClientToken"] = request.clientToken;
|
|
57668
59742
|
}
|
|
57669
59743
|
|
|
57670
59744
|
if (!Util.isUnset(request.ownerAccount)) {
|
|
@@ -57675,6 +59749,14 @@ export default class Client extends OpenApi {
|
|
|
57675
59749
|
query["OwnerId"] = request.ownerId;
|
|
57676
59750
|
}
|
|
57677
59751
|
|
|
59752
|
+
if (!Util.isUnset(request.qosId)) {
|
|
59753
|
+
query["QosId"] = request.qosId;
|
|
59754
|
+
}
|
|
59755
|
+
|
|
59756
|
+
if (!Util.isUnset(request.queueId)) {
|
|
59757
|
+
query["QueueId"] = request.queueId;
|
|
59758
|
+
}
|
|
59759
|
+
|
|
57678
59760
|
if (!Util.isUnset(request.regionId)) {
|
|
57679
59761
|
query["RegionId"] = request.regionId;
|
|
57680
59762
|
}
|
|
@@ -57683,15 +59765,11 @@ export default class Client extends OpenApi {
|
|
|
57683
59765
|
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
57684
59766
|
}
|
|
57685
59767
|
|
|
57686
|
-
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
57687
|
-
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
57688
|
-
}
|
|
57689
|
-
|
|
57690
59768
|
let req = new $OpenApi.OpenApiRequest({
|
|
57691
59769
|
query: OpenApiUtil.query(query),
|
|
57692
59770
|
});
|
|
57693
59771
|
let params = new $OpenApi.Params({
|
|
57694
|
-
action: "
|
|
59772
|
+
action: "DeleteExpressConnectTrafficQosQueue",
|
|
57695
59773
|
version: "2016-04-28",
|
|
57696
59774
|
protocol: "HTTPS",
|
|
57697
59775
|
pathname: "/",
|
|
@@ -57701,38 +59779,23 @@ export default class Client extends OpenApi {
|
|
|
57701
59779
|
reqBodyType: "formData",
|
|
57702
59780
|
bodyType: "json",
|
|
57703
59781
|
});
|
|
57704
|
-
return $tea.cast<
|
|
59782
|
+
return $tea.cast<DeleteExpressConnectTrafficQosQueueResponse>(await this.callApi(params, req, runtime), new DeleteExpressConnectTrafficQosQueueResponse({}));
|
|
57705
59783
|
}
|
|
57706
59784
|
|
|
57707
|
-
async
|
|
59785
|
+
async deleteExpressConnectTrafficQosQueue(request: DeleteExpressConnectTrafficQosQueueRequest): Promise<DeleteExpressConnectTrafficQosQueueResponse> {
|
|
57708
59786
|
let runtime = new $Util.RuntimeOptions({ });
|
|
57709
|
-
return await this.
|
|
59787
|
+
return await this.deleteExpressConnectTrafficQosQueueWithOptions(request, runtime);
|
|
57710
59788
|
}
|
|
57711
59789
|
|
|
57712
|
-
|
|
57713
|
-
* ## [](#)Description
|
|
57714
|
-
* * **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.
|
|
57715
|
-
* * If the DHCP options set is in the **Deleting** state, the DHCP options set is being deleted.
|
|
57716
|
-
* * If you cannot query the DHCP options set, the DHCP options set is deleted.
|
|
57717
|
-
* * You cannot repeatedly call the **DeleteDhcpOptionsSet** operation to delete a DHCP options set within the specified period of time.
|
|
57718
|
-
*
|
|
57719
|
-
* @param request DeleteDhcpOptionsSetRequest
|
|
57720
|
-
* @param runtime runtime options for this request RuntimeOptions
|
|
57721
|
-
* @return DeleteDhcpOptionsSetResponse
|
|
57722
|
-
*/
|
|
57723
|
-
async deleteDhcpOptionsSetWithOptions(request: DeleteDhcpOptionsSetRequest, runtime: $Util.RuntimeOptions): Promise<DeleteDhcpOptionsSetResponse> {
|
|
59790
|
+
async deleteExpressConnectTrafficQosRuleWithOptions(request: DeleteExpressConnectTrafficQosRuleRequest, runtime: $Util.RuntimeOptions): Promise<DeleteExpressConnectTrafficQosRuleResponse> {
|
|
57724
59791
|
Util.validateModel(request);
|
|
57725
59792
|
let query = { };
|
|
57726
59793
|
if (!Util.isUnset(request.clientToken)) {
|
|
57727
59794
|
query["ClientToken"] = request.clientToken;
|
|
57728
59795
|
}
|
|
57729
59796
|
|
|
57730
|
-
if (!Util.isUnset(request.
|
|
57731
|
-
query["
|
|
57732
|
-
}
|
|
57733
|
-
|
|
57734
|
-
if (!Util.isUnset(request.dryRun)) {
|
|
57735
|
-
query["DryRun"] = request.dryRun;
|
|
59797
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
59798
|
+
query["ClientToken"] = request.clientToken;
|
|
57736
59799
|
}
|
|
57737
59800
|
|
|
57738
59801
|
if (!Util.isUnset(request.ownerAccount)) {
|
|
@@ -57743,6 +59806,14 @@ export default class Client extends OpenApi {
|
|
|
57743
59806
|
query["OwnerId"] = request.ownerId;
|
|
57744
59807
|
}
|
|
57745
59808
|
|
|
59809
|
+
if (!Util.isUnset(request.qosId)) {
|
|
59810
|
+
query["QosId"] = request.qosId;
|
|
59811
|
+
}
|
|
59812
|
+
|
|
59813
|
+
if (!Util.isUnset(request.queueId)) {
|
|
59814
|
+
query["QueueId"] = request.queueId;
|
|
59815
|
+
}
|
|
59816
|
+
|
|
57746
59817
|
if (!Util.isUnset(request.regionId)) {
|
|
57747
59818
|
query["RegionId"] = request.regionId;
|
|
57748
59819
|
}
|
|
@@ -57751,15 +59822,15 @@ export default class Client extends OpenApi {
|
|
|
57751
59822
|
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
57752
59823
|
}
|
|
57753
59824
|
|
|
57754
|
-
if (!Util.isUnset(request.
|
|
57755
|
-
query["
|
|
59825
|
+
if (!Util.isUnset(request.ruleId)) {
|
|
59826
|
+
query["RuleId"] = request.ruleId;
|
|
57756
59827
|
}
|
|
57757
59828
|
|
|
57758
59829
|
let req = new $OpenApi.OpenApiRequest({
|
|
57759
59830
|
query: OpenApiUtil.query(query),
|
|
57760
59831
|
});
|
|
57761
59832
|
let params = new $OpenApi.Params({
|
|
57762
|
-
action: "
|
|
59833
|
+
action: "DeleteExpressConnectTrafficQosRule",
|
|
57763
59834
|
version: "2016-04-28",
|
|
57764
59835
|
protocol: "HTTPS",
|
|
57765
59836
|
pathname: "/",
|
|
@@ -57769,22 +59840,12 @@ export default class Client extends OpenApi {
|
|
|
57769
59840
|
reqBodyType: "formData",
|
|
57770
59841
|
bodyType: "json",
|
|
57771
59842
|
});
|
|
57772
|
-
return $tea.cast<
|
|
59843
|
+
return $tea.cast<DeleteExpressConnectTrafficQosRuleResponse>(await this.callApi(params, req, runtime), new DeleteExpressConnectTrafficQosRuleResponse({}));
|
|
57773
59844
|
}
|
|
57774
59845
|
|
|
57775
|
-
|
|
57776
|
-
* ## [](#)Description
|
|
57777
|
-
* * **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.
|
|
57778
|
-
* * If the DHCP options set is in the **Deleting** state, the DHCP options set is being deleted.
|
|
57779
|
-
* * If you cannot query the DHCP options set, the DHCP options set is deleted.
|
|
57780
|
-
* * You cannot repeatedly call the **DeleteDhcpOptionsSet** operation to delete a DHCP options set within the specified period of time.
|
|
57781
|
-
*
|
|
57782
|
-
* @param request DeleteDhcpOptionsSetRequest
|
|
57783
|
-
* @return DeleteDhcpOptionsSetResponse
|
|
57784
|
-
*/
|
|
57785
|
-
async deleteDhcpOptionsSet(request: DeleteDhcpOptionsSetRequest): Promise<DeleteDhcpOptionsSetResponse> {
|
|
59846
|
+
async deleteExpressConnectTrafficQosRule(request: DeleteExpressConnectTrafficQosRuleRequest): Promise<DeleteExpressConnectTrafficQosRuleResponse> {
|
|
57786
59847
|
let runtime = new $Util.RuntimeOptions({ });
|
|
57787
|
-
return await this.
|
|
59848
|
+
return await this.deleteExpressConnectTrafficQosRuleWithOptions(request, runtime);
|
|
57788
59849
|
}
|
|
57789
59850
|
|
|
57790
59851
|
async deleteFailoverTestJobWithOptions(request: DeleteFailoverTestJobRequest, runtime: $Util.RuntimeOptions): Promise<DeleteFailoverTestJobResponse> {
|
|
@@ -60372,7 +62433,7 @@ export default class Client extends OpenApi {
|
|
|
60372
62433
|
* Before you call this operation, take note of the following limits:
|
|
60373
62434
|
* * Before you delete a VBR, you must delete all router interfaces of the VBR.
|
|
60374
62435
|
* * You can delete only a VBR in the **unconfirmed**, **active**, or **terminated** state.
|
|
60375
|
-
* *
|
|
62436
|
+
* * The owner of an Express Connect circuit can delete a VBR that belongs to another account only if the VBR is in the **unconfirmed** state.
|
|
60376
62437
|
*
|
|
60377
62438
|
* @param request DeleteVirtualBorderRouterRequest
|
|
60378
62439
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -60430,7 +62491,7 @@ export default class Client extends OpenApi {
|
|
|
60430
62491
|
* Before you call this operation, take note of the following limits:
|
|
60431
62492
|
* * Before you delete a VBR, you must delete all router interfaces of the VBR.
|
|
60432
62493
|
* * You can delete only a VBR in the **unconfirmed**, **active**, or **terminated** state.
|
|
60433
|
-
* *
|
|
62494
|
+
* * The owner of an Express Connect circuit can delete a VBR that belongs to another account only if the VBR is in the **unconfirmed** state.
|
|
60434
62495
|
*
|
|
60435
62496
|
* @param request DeleteVirtualBorderRouterRequest
|
|
60436
62497
|
* @return DeleteVirtualBorderRouterResponse
|
|
@@ -60650,8 +62711,8 @@ export default class Client extends OpenApi {
|
|
|
60650
62711
|
}
|
|
60651
62712
|
|
|
60652
62713
|
/**
|
|
60653
|
-
* * If
|
|
60654
|
-
* * If
|
|
62714
|
+
* * If an IPsec-VPN connection is associated with a transit router, you must disassociate the transit router from the IPsec-VPN connection before you delete the IPsec-VPN connection. For more information, see [DeleteTransitRouterVpnAttachment](~~468251~~).
|
|
62715
|
+
* * If an IPsec-VPN connection is not associated with a resource, you can call `DeleteVpnAttachment` to directly delete the IPsec-VPN connection.
|
|
60655
62716
|
*
|
|
60656
62717
|
* @param request DeleteVpnAttachmentRequest
|
|
60657
62718
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -60702,8 +62763,8 @@ export default class Client extends OpenApi {
|
|
|
60702
62763
|
}
|
|
60703
62764
|
|
|
60704
62765
|
/**
|
|
60705
|
-
* * If
|
|
60706
|
-
* * If
|
|
62766
|
+
* * If an IPsec-VPN connection is associated with a transit router, you must disassociate the transit router from the IPsec-VPN connection before you delete the IPsec-VPN connection. For more information, see [DeleteTransitRouterVpnAttachment](~~468251~~).
|
|
62767
|
+
* * If an IPsec-VPN connection is not associated with a resource, you can call `DeleteVpnAttachment` to directly delete the IPsec-VPN connection.
|
|
60707
62768
|
*
|
|
60708
62769
|
* @param request DeleteVpnAttachmentRequest
|
|
60709
62770
|
* @return DeleteVpnAttachmentResponse
|
|
@@ -61111,6 +63172,63 @@ export default class Client extends OpenApi {
|
|
|
61111
63172
|
return await this.deletionProtectionWithOptions(request, runtime);
|
|
61112
63173
|
}
|
|
61113
63174
|
|
|
63175
|
+
async describe95TrafficWithOptions(request: Describe95TrafficRequest, runtime: $Util.RuntimeOptions): Promise<Describe95TrafficResponse> {
|
|
63176
|
+
Util.validateModel(request);
|
|
63177
|
+
let query = { };
|
|
63178
|
+
if (!Util.isUnset(request.day)) {
|
|
63179
|
+
query["Day"] = request.day;
|
|
63180
|
+
}
|
|
63181
|
+
|
|
63182
|
+
if (!Util.isUnset(request.instanceId)) {
|
|
63183
|
+
query["InstanceId"] = request.instanceId;
|
|
63184
|
+
}
|
|
63185
|
+
|
|
63186
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
63187
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
63188
|
+
}
|
|
63189
|
+
|
|
63190
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
63191
|
+
query["OwnerId"] = request.ownerId;
|
|
63192
|
+
}
|
|
63193
|
+
|
|
63194
|
+
if (!Util.isUnset(request.regionId)) {
|
|
63195
|
+
query["RegionId"] = request.regionId;
|
|
63196
|
+
}
|
|
63197
|
+
|
|
63198
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
63199
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
63200
|
+
}
|
|
63201
|
+
|
|
63202
|
+
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
63203
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
63204
|
+
}
|
|
63205
|
+
|
|
63206
|
+
if (!Util.isUnset(request.resourceType)) {
|
|
63207
|
+
query["ResourceType"] = request.resourceType;
|
|
63208
|
+
}
|
|
63209
|
+
|
|
63210
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
63211
|
+
query: OpenApiUtil.query(query),
|
|
63212
|
+
});
|
|
63213
|
+
let params = new $OpenApi.Params({
|
|
63214
|
+
action: "Describe95Traffic",
|
|
63215
|
+
version: "2016-04-28",
|
|
63216
|
+
protocol: "HTTPS",
|
|
63217
|
+
pathname: "/",
|
|
63218
|
+
method: "POST",
|
|
63219
|
+
authType: "AK",
|
|
63220
|
+
style: "RPC",
|
|
63221
|
+
reqBodyType: "formData",
|
|
63222
|
+
bodyType: "json",
|
|
63223
|
+
});
|
|
63224
|
+
return $tea.cast<Describe95TrafficResponse>(await this.callApi(params, req, runtime), new Describe95TrafficResponse({}));
|
|
63225
|
+
}
|
|
63226
|
+
|
|
63227
|
+
async describe95Traffic(request: Describe95TrafficRequest): Promise<Describe95TrafficResponse> {
|
|
63228
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
63229
|
+
return await this.describe95TrafficWithOptions(request, runtime);
|
|
63230
|
+
}
|
|
63231
|
+
|
|
61114
63232
|
async describeAccessPointsWithOptions(request: DescribeAccessPointsRequest, runtime: $Util.RuntimeOptions): Promise<DescribeAccessPointsResponse> {
|
|
61115
63233
|
Util.validateModel(request);
|
|
61116
63234
|
let query = { };
|
|
@@ -61689,6 +63807,10 @@ export default class Client extends OpenApi {
|
|
|
61689
63807
|
query["SegmentInstanceId"] = request.segmentInstanceId;
|
|
61690
63808
|
}
|
|
61691
63809
|
|
|
63810
|
+
if (!Util.isUnset(request.serviceManaged)) {
|
|
63811
|
+
query["ServiceManaged"] = request.serviceManaged;
|
|
63812
|
+
}
|
|
63813
|
+
|
|
61692
63814
|
if (!Util.isUnset(request.status)) {
|
|
61693
63815
|
query["Status"] = request.status;
|
|
61694
63816
|
}
|
|
@@ -61930,6 +64052,197 @@ export default class Client extends OpenApi {
|
|
|
61930
64052
|
return await this.describeEipSegmentWithOptions(request, runtime);
|
|
61931
64053
|
}
|
|
61932
64054
|
|
|
64055
|
+
async describeExpressConnectTrafficQosWithOptions(request: DescribeExpressConnectTrafficQosRequest, runtime: $Util.RuntimeOptions): Promise<DescribeExpressConnectTrafficQosResponse> {
|
|
64056
|
+
Util.validateModel(request);
|
|
64057
|
+
let query = { };
|
|
64058
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
64059
|
+
query["ClientToken"] = request.clientToken;
|
|
64060
|
+
}
|
|
64061
|
+
|
|
64062
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
64063
|
+
query["ClientToken"] = request.clientToken;
|
|
64064
|
+
}
|
|
64065
|
+
|
|
64066
|
+
if (!Util.isUnset(request.maxResults)) {
|
|
64067
|
+
query["MaxResults"] = request.maxResults;
|
|
64068
|
+
}
|
|
64069
|
+
|
|
64070
|
+
if (!Util.isUnset(request.nextToken)) {
|
|
64071
|
+
query["NextToken"] = request.nextToken;
|
|
64072
|
+
}
|
|
64073
|
+
|
|
64074
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
64075
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
64076
|
+
}
|
|
64077
|
+
|
|
64078
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
64079
|
+
query["OwnerId"] = request.ownerId;
|
|
64080
|
+
}
|
|
64081
|
+
|
|
64082
|
+
if (!Util.isUnset(request.qosIdList)) {
|
|
64083
|
+
query["QosIdList"] = request.qosIdList;
|
|
64084
|
+
}
|
|
64085
|
+
|
|
64086
|
+
if (!Util.isUnset(request.qosNameList)) {
|
|
64087
|
+
query["QosNameList"] = request.qosNameList;
|
|
64088
|
+
}
|
|
64089
|
+
|
|
64090
|
+
if (!Util.isUnset(request.regionId)) {
|
|
64091
|
+
query["RegionId"] = request.regionId;
|
|
64092
|
+
}
|
|
64093
|
+
|
|
64094
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
64095
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
64096
|
+
}
|
|
64097
|
+
|
|
64098
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
64099
|
+
query: OpenApiUtil.query(query),
|
|
64100
|
+
});
|
|
64101
|
+
let params = new $OpenApi.Params({
|
|
64102
|
+
action: "DescribeExpressConnectTrafficQos",
|
|
64103
|
+
version: "2016-04-28",
|
|
64104
|
+
protocol: "HTTPS",
|
|
64105
|
+
pathname: "/",
|
|
64106
|
+
method: "POST",
|
|
64107
|
+
authType: "AK",
|
|
64108
|
+
style: "RPC",
|
|
64109
|
+
reqBodyType: "formData",
|
|
64110
|
+
bodyType: "json",
|
|
64111
|
+
});
|
|
64112
|
+
return $tea.cast<DescribeExpressConnectTrafficQosResponse>(await this.callApi(params, req, runtime), new DescribeExpressConnectTrafficQosResponse({}));
|
|
64113
|
+
}
|
|
64114
|
+
|
|
64115
|
+
async describeExpressConnectTrafficQos(request: DescribeExpressConnectTrafficQosRequest): Promise<DescribeExpressConnectTrafficQosResponse> {
|
|
64116
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
64117
|
+
return await this.describeExpressConnectTrafficQosWithOptions(request, runtime);
|
|
64118
|
+
}
|
|
64119
|
+
|
|
64120
|
+
async describeExpressConnectTrafficQosQueueWithOptions(request: DescribeExpressConnectTrafficQosQueueRequest, runtime: $Util.RuntimeOptions): Promise<DescribeExpressConnectTrafficQosQueueResponse> {
|
|
64121
|
+
Util.validateModel(request);
|
|
64122
|
+
let query = { };
|
|
64123
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
64124
|
+
query["ClientToken"] = request.clientToken;
|
|
64125
|
+
}
|
|
64126
|
+
|
|
64127
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
64128
|
+
query["ClientToken"] = request.clientToken;
|
|
64129
|
+
}
|
|
64130
|
+
|
|
64131
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
64132
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
64133
|
+
}
|
|
64134
|
+
|
|
64135
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
64136
|
+
query["OwnerId"] = request.ownerId;
|
|
64137
|
+
}
|
|
64138
|
+
|
|
64139
|
+
if (!Util.isUnset(request.qosId)) {
|
|
64140
|
+
query["QosId"] = request.qosId;
|
|
64141
|
+
}
|
|
64142
|
+
|
|
64143
|
+
if (!Util.isUnset(request.queueIdList)) {
|
|
64144
|
+
query["QueueIdList"] = request.queueIdList;
|
|
64145
|
+
}
|
|
64146
|
+
|
|
64147
|
+
if (!Util.isUnset(request.queueNameList)) {
|
|
64148
|
+
query["QueueNameList"] = request.queueNameList;
|
|
64149
|
+
}
|
|
64150
|
+
|
|
64151
|
+
if (!Util.isUnset(request.regionId)) {
|
|
64152
|
+
query["RegionId"] = request.regionId;
|
|
64153
|
+
}
|
|
64154
|
+
|
|
64155
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
64156
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
64157
|
+
}
|
|
64158
|
+
|
|
64159
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
64160
|
+
query: OpenApiUtil.query(query),
|
|
64161
|
+
});
|
|
64162
|
+
let params = new $OpenApi.Params({
|
|
64163
|
+
action: "DescribeExpressConnectTrafficQosQueue",
|
|
64164
|
+
version: "2016-04-28",
|
|
64165
|
+
protocol: "HTTPS",
|
|
64166
|
+
pathname: "/",
|
|
64167
|
+
method: "POST",
|
|
64168
|
+
authType: "AK",
|
|
64169
|
+
style: "RPC",
|
|
64170
|
+
reqBodyType: "formData",
|
|
64171
|
+
bodyType: "json",
|
|
64172
|
+
});
|
|
64173
|
+
return $tea.cast<DescribeExpressConnectTrafficQosQueueResponse>(await this.callApi(params, req, runtime), new DescribeExpressConnectTrafficQosQueueResponse({}));
|
|
64174
|
+
}
|
|
64175
|
+
|
|
64176
|
+
async describeExpressConnectTrafficQosQueue(request: DescribeExpressConnectTrafficQosQueueRequest): Promise<DescribeExpressConnectTrafficQosQueueResponse> {
|
|
64177
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
64178
|
+
return await this.describeExpressConnectTrafficQosQueueWithOptions(request, runtime);
|
|
64179
|
+
}
|
|
64180
|
+
|
|
64181
|
+
async describeExpressConnectTrafficQosRuleWithOptions(request: DescribeExpressConnectTrafficQosRuleRequest, runtime: $Util.RuntimeOptions): Promise<DescribeExpressConnectTrafficQosRuleResponse> {
|
|
64182
|
+
Util.validateModel(request);
|
|
64183
|
+
let query = { };
|
|
64184
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
64185
|
+
query["ClientToken"] = request.clientToken;
|
|
64186
|
+
}
|
|
64187
|
+
|
|
64188
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
64189
|
+
query["ClientToken"] = request.clientToken;
|
|
64190
|
+
}
|
|
64191
|
+
|
|
64192
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
64193
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
64194
|
+
}
|
|
64195
|
+
|
|
64196
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
64197
|
+
query["OwnerId"] = request.ownerId;
|
|
64198
|
+
}
|
|
64199
|
+
|
|
64200
|
+
if (!Util.isUnset(request.qosId)) {
|
|
64201
|
+
query["QosId"] = request.qosId;
|
|
64202
|
+
}
|
|
64203
|
+
|
|
64204
|
+
if (!Util.isUnset(request.queueId)) {
|
|
64205
|
+
query["QueueId"] = request.queueId;
|
|
64206
|
+
}
|
|
64207
|
+
|
|
64208
|
+
if (!Util.isUnset(request.regionId)) {
|
|
64209
|
+
query["RegionId"] = request.regionId;
|
|
64210
|
+
}
|
|
64211
|
+
|
|
64212
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
64213
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
64214
|
+
}
|
|
64215
|
+
|
|
64216
|
+
if (!Util.isUnset(request.ruleIdList)) {
|
|
64217
|
+
query["RuleIdList"] = request.ruleIdList;
|
|
64218
|
+
}
|
|
64219
|
+
|
|
64220
|
+
if (!Util.isUnset(request.ruleNameList)) {
|
|
64221
|
+
query["RuleNameList"] = request.ruleNameList;
|
|
64222
|
+
}
|
|
64223
|
+
|
|
64224
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
64225
|
+
query: OpenApiUtil.query(query),
|
|
64226
|
+
});
|
|
64227
|
+
let params = new $OpenApi.Params({
|
|
64228
|
+
action: "DescribeExpressConnectTrafficQosRule",
|
|
64229
|
+
version: "2016-04-28",
|
|
64230
|
+
protocol: "HTTPS",
|
|
64231
|
+
pathname: "/",
|
|
64232
|
+
method: "POST",
|
|
64233
|
+
authType: "AK",
|
|
64234
|
+
style: "RPC",
|
|
64235
|
+
reqBodyType: "formData",
|
|
64236
|
+
bodyType: "json",
|
|
64237
|
+
});
|
|
64238
|
+
return $tea.cast<DescribeExpressConnectTrafficQosRuleResponse>(await this.callApi(params, req, runtime), new DescribeExpressConnectTrafficQosRuleResponse({}));
|
|
64239
|
+
}
|
|
64240
|
+
|
|
64241
|
+
async describeExpressConnectTrafficQosRule(request: DescribeExpressConnectTrafficQosRuleRequest): Promise<DescribeExpressConnectTrafficQosRuleResponse> {
|
|
64242
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
64243
|
+
return await this.describeExpressConnectTrafficQosRuleWithOptions(request, runtime);
|
|
64244
|
+
}
|
|
64245
|
+
|
|
61933
64246
|
async describeFailoverTestJobWithOptions(request: DescribeFailoverTestJobRequest, runtime: $Util.RuntimeOptions): Promise<DescribeFailoverTestJobResponse> {
|
|
61934
64247
|
Util.validateModel(request);
|
|
61935
64248
|
let query = { };
|
|
@@ -62926,6 +65239,10 @@ export default class Client extends OpenApi {
|
|
|
62926
65239
|
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
62927
65240
|
}
|
|
62928
65241
|
|
|
65242
|
+
if (!Util.isUnset(request.serviceManaged)) {
|
|
65243
|
+
query["ServiceManaged"] = request.serviceManaged;
|
|
65244
|
+
}
|
|
65245
|
+
|
|
62929
65246
|
if (!Util.isUnset(request.tag)) {
|
|
62930
65247
|
query["Tag"] = request.tag;
|
|
62931
65248
|
}
|
|
@@ -63682,7 +65999,6 @@ export default class Client extends OpenApi {
|
|
|
63682
65999
|
}
|
|
63683
66000
|
|
|
63684
66001
|
/**
|
|
63685
|
-
* ## [](#)References
|
|
63686
66002
|
* 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.
|
|
63687
66003
|
*
|
|
63688
66004
|
* @param request DescribeRouteEntryListRequest
|
|
@@ -63782,7 +66098,6 @@ export default class Client extends OpenApi {
|
|
|
63782
66098
|
}
|
|
63783
66099
|
|
|
63784
66100
|
/**
|
|
63785
|
-
* ## [](#)References
|
|
63786
66101
|
* 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.
|
|
63787
66102
|
*
|
|
63788
66103
|
* @param request DescribeRouteEntryListRequest
|
|
@@ -69401,7 +71716,308 @@ export default class Client extends OpenApi {
|
|
|
69401
71716
|
query: OpenApiUtil.query(query),
|
|
69402
71717
|
});
|
|
69403
71718
|
let params = new $OpenApi.Params({
|
|
69404
|
-
action: "ModifyCommonBandwidthPackageAttribute",
|
|
71719
|
+
action: "ModifyCommonBandwidthPackageAttribute",
|
|
71720
|
+
version: "2016-04-28",
|
|
71721
|
+
protocol: "HTTPS",
|
|
71722
|
+
pathname: "/",
|
|
71723
|
+
method: "POST",
|
|
71724
|
+
authType: "AK",
|
|
71725
|
+
style: "RPC",
|
|
71726
|
+
reqBodyType: "formData",
|
|
71727
|
+
bodyType: "json",
|
|
71728
|
+
});
|
|
71729
|
+
return $tea.cast<ModifyCommonBandwidthPackageAttributeResponse>(await this.callApi(params, req, runtime), new ModifyCommonBandwidthPackageAttributeResponse({}));
|
|
71730
|
+
}
|
|
71731
|
+
|
|
71732
|
+
async modifyCommonBandwidthPackageAttribute(request: ModifyCommonBandwidthPackageAttributeRequest): Promise<ModifyCommonBandwidthPackageAttributeResponse> {
|
|
71733
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
71734
|
+
return await this.modifyCommonBandwidthPackageAttributeWithOptions(request, runtime);
|
|
71735
|
+
}
|
|
71736
|
+
|
|
71737
|
+
/**
|
|
71738
|
+
* You can call the **ModifyCommonBandwidthPackageIpBandwidth** operation to set the maximum bandwidth of an EIP that is associated with an Internet Shared Bandwidth instance. This prevents an EIP from exhausting the bandwidth resources of an Internet Shared Bandwidth instance.
|
|
71739
|
+
* For example, two EIPs are associated with an Internet Shared Bandwidth instance whose maximum bandwidth is 800 Mbit/s. In this case, you can set the maximum bandwidth of one EIP to 500 Mbit/s and that of the other EIP to 400 Mbit/s. After you set the maximum bandwidth values, the first EIP cannot consume bandwidth higher than 500 Mbit/s. The second EIP cannot consume bandwidth higher than 400 Mbit/s.
|
|
71740
|
+
* When you call this operation, take note of the following items:
|
|
71741
|
+
* * This operation is valid only for EIPs that are associated with Elastic Compute Service (ECS) instances. This operation is invalid for EIPs that are associated with Server Load Balancer (SLB) instances, NAT gateways, secondary elastic network interfaces (ENIs), or high-availability virtual IP addresses (HAVIPs).
|
|
71742
|
+
* * This operation is in public preview. You can call this operation to set the maximum bandwidth of EIPs only if the EIPs are associated with an Internet Shared Bandwidth instance. The feature is not supported in the console.
|
|
71743
|
+
* * You cannot repeatedly call this operation to set the maximum bandwidth of an EIP within the specified period of time.
|
|
71744
|
+
*
|
|
71745
|
+
* @param request ModifyCommonBandwidthPackageIpBandwidthRequest
|
|
71746
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
71747
|
+
* @return ModifyCommonBandwidthPackageIpBandwidthResponse
|
|
71748
|
+
*/
|
|
71749
|
+
async modifyCommonBandwidthPackageIpBandwidthWithOptions(request: ModifyCommonBandwidthPackageIpBandwidthRequest, runtime: $Util.RuntimeOptions): Promise<ModifyCommonBandwidthPackageIpBandwidthResponse> {
|
|
71750
|
+
Util.validateModel(request);
|
|
71751
|
+
let query = { };
|
|
71752
|
+
if (!Util.isUnset(request.bandwidth)) {
|
|
71753
|
+
query["Bandwidth"] = request.bandwidth;
|
|
71754
|
+
}
|
|
71755
|
+
|
|
71756
|
+
if (!Util.isUnset(request.bandwidthPackageId)) {
|
|
71757
|
+
query["BandwidthPackageId"] = request.bandwidthPackageId;
|
|
71758
|
+
}
|
|
71759
|
+
|
|
71760
|
+
if (!Util.isUnset(request.eipId)) {
|
|
71761
|
+
query["EipId"] = request.eipId;
|
|
71762
|
+
}
|
|
71763
|
+
|
|
71764
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
71765
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
71766
|
+
}
|
|
71767
|
+
|
|
71768
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
71769
|
+
query["OwnerId"] = request.ownerId;
|
|
71770
|
+
}
|
|
71771
|
+
|
|
71772
|
+
if (!Util.isUnset(request.regionId)) {
|
|
71773
|
+
query["RegionId"] = request.regionId;
|
|
71774
|
+
}
|
|
71775
|
+
|
|
71776
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
71777
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
71778
|
+
}
|
|
71779
|
+
|
|
71780
|
+
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
71781
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
71782
|
+
}
|
|
71783
|
+
|
|
71784
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
71785
|
+
query: OpenApiUtil.query(query),
|
|
71786
|
+
});
|
|
71787
|
+
let params = new $OpenApi.Params({
|
|
71788
|
+
action: "ModifyCommonBandwidthPackageIpBandwidth",
|
|
71789
|
+
version: "2016-04-28",
|
|
71790
|
+
protocol: "HTTPS",
|
|
71791
|
+
pathname: "/",
|
|
71792
|
+
method: "POST",
|
|
71793
|
+
authType: "AK",
|
|
71794
|
+
style: "RPC",
|
|
71795
|
+
reqBodyType: "formData",
|
|
71796
|
+
bodyType: "json",
|
|
71797
|
+
});
|
|
71798
|
+
return $tea.cast<ModifyCommonBandwidthPackageIpBandwidthResponse>(await this.callApi(params, req, runtime), new ModifyCommonBandwidthPackageIpBandwidthResponse({}));
|
|
71799
|
+
}
|
|
71800
|
+
|
|
71801
|
+
/**
|
|
71802
|
+
* You can call the **ModifyCommonBandwidthPackageIpBandwidth** operation to set the maximum bandwidth of an EIP that is associated with an Internet Shared Bandwidth instance. This prevents an EIP from exhausting the bandwidth resources of an Internet Shared Bandwidth instance.
|
|
71803
|
+
* For example, two EIPs are associated with an Internet Shared Bandwidth instance whose maximum bandwidth is 800 Mbit/s. In this case, you can set the maximum bandwidth of one EIP to 500 Mbit/s and that of the other EIP to 400 Mbit/s. After you set the maximum bandwidth values, the first EIP cannot consume bandwidth higher than 500 Mbit/s. The second EIP cannot consume bandwidth higher than 400 Mbit/s.
|
|
71804
|
+
* When you call this operation, take note of the following items:
|
|
71805
|
+
* * This operation is valid only for EIPs that are associated with Elastic Compute Service (ECS) instances. This operation is invalid for EIPs that are associated with Server Load Balancer (SLB) instances, NAT gateways, secondary elastic network interfaces (ENIs), or high-availability virtual IP addresses (HAVIPs).
|
|
71806
|
+
* * This operation is in public preview. You can call this operation to set the maximum bandwidth of EIPs only if the EIPs are associated with an Internet Shared Bandwidth instance. The feature is not supported in the console.
|
|
71807
|
+
* * You cannot repeatedly call this operation to set the maximum bandwidth of an EIP within the specified period of time.
|
|
71808
|
+
*
|
|
71809
|
+
* @param request ModifyCommonBandwidthPackageIpBandwidthRequest
|
|
71810
|
+
* @return ModifyCommonBandwidthPackageIpBandwidthResponse
|
|
71811
|
+
*/
|
|
71812
|
+
async modifyCommonBandwidthPackageIpBandwidth(request: ModifyCommonBandwidthPackageIpBandwidthRequest): Promise<ModifyCommonBandwidthPackageIpBandwidthResponse> {
|
|
71813
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
71814
|
+
return await this.modifyCommonBandwidthPackageIpBandwidthWithOptions(request, runtime);
|
|
71815
|
+
}
|
|
71816
|
+
|
|
71817
|
+
/**
|
|
71818
|
+
* Before you call this operation, take note of the following items:
|
|
71819
|
+
* * **ModifyCommonBandwidthPackageSpec** 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 [DescribeCommonBandwidthPackages](~~120309~~) operation to query the status of the task.
|
|
71820
|
+
* * If the Internet Shared Bandwidth instance is in the **Modifying** state, the maximum bandwidth of the Internet Shared Bandwidth instance is being modified. In this state, you can only query the Internet Shared Bandwidth instance and cannot perform other operations.
|
|
71821
|
+
* * If the Internet Shared Bandwidth instance is in the **Available** state, the maximum bandwidth of the Internet Shared Bandwidth instance is modified.
|
|
71822
|
+
* * You cannot repeatedly call the **ModifyCommonBandwidthPackageSpec** operation to modify the maximum bandwidth of an Internet Shared Bandwidth instance within the specified period of time.
|
|
71823
|
+
*
|
|
71824
|
+
* @param request ModifyCommonBandwidthPackageSpecRequest
|
|
71825
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
71826
|
+
* @return ModifyCommonBandwidthPackageSpecResponse
|
|
71827
|
+
*/
|
|
71828
|
+
async modifyCommonBandwidthPackageSpecWithOptions(request: ModifyCommonBandwidthPackageSpecRequest, runtime: $Util.RuntimeOptions): Promise<ModifyCommonBandwidthPackageSpecResponse> {
|
|
71829
|
+
Util.validateModel(request);
|
|
71830
|
+
let query = { };
|
|
71831
|
+
if (!Util.isUnset(request.bandwidth)) {
|
|
71832
|
+
query["Bandwidth"] = request.bandwidth;
|
|
71833
|
+
}
|
|
71834
|
+
|
|
71835
|
+
if (!Util.isUnset(request.bandwidthPackageId)) {
|
|
71836
|
+
query["BandwidthPackageId"] = request.bandwidthPackageId;
|
|
71837
|
+
}
|
|
71838
|
+
|
|
71839
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
71840
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
71841
|
+
}
|
|
71842
|
+
|
|
71843
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
71844
|
+
query["OwnerId"] = request.ownerId;
|
|
71845
|
+
}
|
|
71846
|
+
|
|
71847
|
+
if (!Util.isUnset(request.regionId)) {
|
|
71848
|
+
query["RegionId"] = request.regionId;
|
|
71849
|
+
}
|
|
71850
|
+
|
|
71851
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
71852
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
71853
|
+
}
|
|
71854
|
+
|
|
71855
|
+
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
71856
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
71857
|
+
}
|
|
71858
|
+
|
|
71859
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
71860
|
+
query: OpenApiUtil.query(query),
|
|
71861
|
+
});
|
|
71862
|
+
let params = new $OpenApi.Params({
|
|
71863
|
+
action: "ModifyCommonBandwidthPackageSpec",
|
|
71864
|
+
version: "2016-04-28",
|
|
71865
|
+
protocol: "HTTPS",
|
|
71866
|
+
pathname: "/",
|
|
71867
|
+
method: "POST",
|
|
71868
|
+
authType: "AK",
|
|
71869
|
+
style: "RPC",
|
|
71870
|
+
reqBodyType: "formData",
|
|
71871
|
+
bodyType: "json",
|
|
71872
|
+
});
|
|
71873
|
+
return $tea.cast<ModifyCommonBandwidthPackageSpecResponse>(await this.callApi(params, req, runtime), new ModifyCommonBandwidthPackageSpecResponse({}));
|
|
71874
|
+
}
|
|
71875
|
+
|
|
71876
|
+
/**
|
|
71877
|
+
* Before you call this operation, take note of the following items:
|
|
71878
|
+
* * **ModifyCommonBandwidthPackageSpec** 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 [DescribeCommonBandwidthPackages](~~120309~~) operation to query the status of the task.
|
|
71879
|
+
* * If the Internet Shared Bandwidth instance is in the **Modifying** state, the maximum bandwidth of the Internet Shared Bandwidth instance is being modified. In this state, you can only query the Internet Shared Bandwidth instance and cannot perform other operations.
|
|
71880
|
+
* * If the Internet Shared Bandwidth instance is in the **Available** state, the maximum bandwidth of the Internet Shared Bandwidth instance is modified.
|
|
71881
|
+
* * You cannot repeatedly call the **ModifyCommonBandwidthPackageSpec** operation to modify the maximum bandwidth of an Internet Shared Bandwidth instance within the specified period of time.
|
|
71882
|
+
*
|
|
71883
|
+
* @param request ModifyCommonBandwidthPackageSpecRequest
|
|
71884
|
+
* @return ModifyCommonBandwidthPackageSpecResponse
|
|
71885
|
+
*/
|
|
71886
|
+
async modifyCommonBandwidthPackageSpec(request: ModifyCommonBandwidthPackageSpecRequest): Promise<ModifyCommonBandwidthPackageSpecResponse> {
|
|
71887
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
71888
|
+
return await this.modifyCommonBandwidthPackageSpecWithOptions(request, runtime);
|
|
71889
|
+
}
|
|
71890
|
+
|
|
71891
|
+
/**
|
|
71892
|
+
* * When you call **ModifyCustomerGatewayAttribute**, if a value is assigned to **AuthKey**, the operation is asynchronous. 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.
|
|
71893
|
+
* * If a VPN gateway is in the **updating** state, the configurations are being modified.
|
|
71894
|
+
* * If a VPN gateway is in the **active** state, the configurations are modified.
|
|
71895
|
+
* * When you call **ModifyCustomerGatewayAttribute**, if no value is assigned to **AuthKey**, the operation is synchronous.
|
|
71896
|
+
* * You cannot repeatedly call **ModifyCustomerGatewayAttribute** to modify the configurations of a customer gateway within the specified period of time.
|
|
71897
|
+
*
|
|
71898
|
+
* @param request ModifyCustomerGatewayAttributeRequest
|
|
71899
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
71900
|
+
* @return ModifyCustomerGatewayAttributeResponse
|
|
71901
|
+
*/
|
|
71902
|
+
async modifyCustomerGatewayAttributeWithOptions(request: ModifyCustomerGatewayAttributeRequest, runtime: $Util.RuntimeOptions): Promise<ModifyCustomerGatewayAttributeResponse> {
|
|
71903
|
+
Util.validateModel(request);
|
|
71904
|
+
let query = { };
|
|
71905
|
+
if (!Util.isUnset(request.authKey)) {
|
|
71906
|
+
query["AuthKey"] = request.authKey;
|
|
71907
|
+
}
|
|
71908
|
+
|
|
71909
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
71910
|
+
query["ClientToken"] = request.clientToken;
|
|
71911
|
+
}
|
|
71912
|
+
|
|
71913
|
+
if (!Util.isUnset(request.customerGatewayId)) {
|
|
71914
|
+
query["CustomerGatewayId"] = request.customerGatewayId;
|
|
71915
|
+
}
|
|
71916
|
+
|
|
71917
|
+
if (!Util.isUnset(request.description)) {
|
|
71918
|
+
query["Description"] = request.description;
|
|
71919
|
+
}
|
|
71920
|
+
|
|
71921
|
+
if (!Util.isUnset(request.name)) {
|
|
71922
|
+
query["Name"] = request.name;
|
|
71923
|
+
}
|
|
71924
|
+
|
|
71925
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
71926
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
71927
|
+
}
|
|
71928
|
+
|
|
71929
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
71930
|
+
query["OwnerId"] = request.ownerId;
|
|
71931
|
+
}
|
|
71932
|
+
|
|
71933
|
+
if (!Util.isUnset(request.regionId)) {
|
|
71934
|
+
query["RegionId"] = request.regionId;
|
|
71935
|
+
}
|
|
71936
|
+
|
|
71937
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
71938
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
71939
|
+
}
|
|
71940
|
+
|
|
71941
|
+
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
71942
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
71943
|
+
}
|
|
71944
|
+
|
|
71945
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
71946
|
+
query: OpenApiUtil.query(query),
|
|
71947
|
+
});
|
|
71948
|
+
let params = new $OpenApi.Params({
|
|
71949
|
+
action: "ModifyCustomerGatewayAttribute",
|
|
71950
|
+
version: "2016-04-28",
|
|
71951
|
+
protocol: "HTTPS",
|
|
71952
|
+
pathname: "/",
|
|
71953
|
+
method: "POST",
|
|
71954
|
+
authType: "AK",
|
|
71955
|
+
style: "RPC",
|
|
71956
|
+
reqBodyType: "formData",
|
|
71957
|
+
bodyType: "json",
|
|
71958
|
+
});
|
|
71959
|
+
return $tea.cast<ModifyCustomerGatewayAttributeResponse>(await this.callApi(params, req, runtime), new ModifyCustomerGatewayAttributeResponse({}));
|
|
71960
|
+
}
|
|
71961
|
+
|
|
71962
|
+
/**
|
|
71963
|
+
* * When you call **ModifyCustomerGatewayAttribute**, if a value is assigned to **AuthKey**, the operation is asynchronous. 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.
|
|
71964
|
+
* * If a VPN gateway is in the **updating** state, the configurations are being modified.
|
|
71965
|
+
* * If a VPN gateway is in the **active** state, the configurations are modified.
|
|
71966
|
+
* * When you call **ModifyCustomerGatewayAttribute**, if no value is assigned to **AuthKey**, the operation is synchronous.
|
|
71967
|
+
* * You cannot repeatedly call **ModifyCustomerGatewayAttribute** to modify the configurations of a customer gateway within the specified period of time.
|
|
71968
|
+
*
|
|
71969
|
+
* @param request ModifyCustomerGatewayAttributeRequest
|
|
71970
|
+
* @return ModifyCustomerGatewayAttributeResponse
|
|
71971
|
+
*/
|
|
71972
|
+
async modifyCustomerGatewayAttribute(request: ModifyCustomerGatewayAttributeRequest): Promise<ModifyCustomerGatewayAttributeResponse> {
|
|
71973
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
71974
|
+
return await this.modifyCustomerGatewayAttributeWithOptions(request, runtime);
|
|
71975
|
+
}
|
|
71976
|
+
|
|
71977
|
+
async modifyEipAddressAttributeWithOptions(request: ModifyEipAddressAttributeRequest, runtime: $Util.RuntimeOptions): Promise<ModifyEipAddressAttributeResponse> {
|
|
71978
|
+
Util.validateModel(request);
|
|
71979
|
+
let query = { };
|
|
71980
|
+
if (!Util.isUnset(request.allocationId)) {
|
|
71981
|
+
query["AllocationId"] = request.allocationId;
|
|
71982
|
+
}
|
|
71983
|
+
|
|
71984
|
+
if (!Util.isUnset(request.bandwidth)) {
|
|
71985
|
+
query["Bandwidth"] = request.bandwidth;
|
|
71986
|
+
}
|
|
71987
|
+
|
|
71988
|
+
if (!Util.isUnset(request.description)) {
|
|
71989
|
+
query["Description"] = request.description;
|
|
71990
|
+
}
|
|
71991
|
+
|
|
71992
|
+
if (!Util.isUnset(request.name)) {
|
|
71993
|
+
query["Name"] = request.name;
|
|
71994
|
+
}
|
|
71995
|
+
|
|
71996
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
71997
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
71998
|
+
}
|
|
71999
|
+
|
|
72000
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
72001
|
+
query["OwnerId"] = request.ownerId;
|
|
72002
|
+
}
|
|
72003
|
+
|
|
72004
|
+
if (!Util.isUnset(request.regionId)) {
|
|
72005
|
+
query["RegionId"] = request.regionId;
|
|
72006
|
+
}
|
|
72007
|
+
|
|
72008
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
72009
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
72010
|
+
}
|
|
72011
|
+
|
|
72012
|
+
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
72013
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
72014
|
+
}
|
|
72015
|
+
|
|
72016
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
72017
|
+
query: OpenApiUtil.query(query),
|
|
72018
|
+
});
|
|
72019
|
+
let params = new $OpenApi.Params({
|
|
72020
|
+
action: "ModifyEipAddressAttribute",
|
|
69405
72021
|
version: "2016-04-28",
|
|
69406
72022
|
protocol: "HTTPS",
|
|
69407
72023
|
pathname: "/",
|
|
@@ -69411,39 +72027,35 @@ export default class Client extends OpenApi {
|
|
|
69411
72027
|
reqBodyType: "formData",
|
|
69412
72028
|
bodyType: "json",
|
|
69413
72029
|
});
|
|
69414
|
-
return $tea.cast<
|
|
72030
|
+
return $tea.cast<ModifyEipAddressAttributeResponse>(await this.callApi(params, req, runtime), new ModifyEipAddressAttributeResponse({}));
|
|
69415
72031
|
}
|
|
69416
72032
|
|
|
69417
|
-
async
|
|
72033
|
+
async modifyEipAddressAttribute(request: ModifyEipAddressAttributeRequest): Promise<ModifyEipAddressAttributeResponse> {
|
|
69418
72034
|
let runtime = new $Util.RuntimeOptions({ });
|
|
69419
|
-
return await this.
|
|
72035
|
+
return await this.modifyEipAddressAttributeWithOptions(request, runtime);
|
|
69420
72036
|
}
|
|
69421
72037
|
|
|
69422
|
-
|
|
69423
|
-
* You can call the **ModifyCommonBandwidthPackageIpBandwidth** operation to set the maximum bandwidth of an EIP that is associated with an Internet Shared Bandwidth instance. This prevents an EIP from exhausting the bandwidth resources of an Internet Shared Bandwidth instance.
|
|
69424
|
-
* For example, two EIPs are associated with an Internet Shared Bandwidth instance whose maximum bandwidth is 800 Mbit/s. In this case, you can set the maximum bandwidth of one EIP to 500 Mbit/s and that of the other EIP to 400 Mbit/s. After you set the maximum bandwidth values, the first EIP cannot consume bandwidth higher than 500 Mbit/s. The second EIP cannot consume bandwidth higher than 400 Mbit/s.
|
|
69425
|
-
* When you call this operation, take note of the following items:
|
|
69426
|
-
* * This operation is valid only for EIPs that are associated with Elastic Compute Service (ECS) instances. This operation is invalid for EIPs that are associated with Server Load Balancer (SLB) instances, NAT gateways, secondary elastic network interfaces (ENIs), or high-availability virtual IP addresses (HAVIPs).
|
|
69427
|
-
* * This operation is in public preview. You can call this operation to set the maximum bandwidth of EIPs only if the EIPs are associated with an Internet Shared Bandwidth instance. The feature is not supported in the console.
|
|
69428
|
-
* * You cannot repeatedly call this operation to set the maximum bandwidth of an EIP within the specified period of time.
|
|
69429
|
-
*
|
|
69430
|
-
* @param request ModifyCommonBandwidthPackageIpBandwidthRequest
|
|
69431
|
-
* @param runtime runtime options for this request RuntimeOptions
|
|
69432
|
-
* @return ModifyCommonBandwidthPackageIpBandwidthResponse
|
|
69433
|
-
*/
|
|
69434
|
-
async modifyCommonBandwidthPackageIpBandwidthWithOptions(request: ModifyCommonBandwidthPackageIpBandwidthRequest, runtime: $Util.RuntimeOptions): Promise<ModifyCommonBandwidthPackageIpBandwidthResponse> {
|
|
72038
|
+
async modifyExpressCloudConnectionAttributeWithOptions(request: ModifyExpressCloudConnectionAttributeRequest, runtime: $Util.RuntimeOptions): Promise<ModifyExpressCloudConnectionAttributeResponse> {
|
|
69435
72039
|
Util.validateModel(request);
|
|
69436
72040
|
let query = { };
|
|
69437
|
-
if (!Util.isUnset(request.
|
|
69438
|
-
query["
|
|
72041
|
+
if (!Util.isUnset(request.bgpAs)) {
|
|
72042
|
+
query["BgpAs"] = request.bgpAs;
|
|
69439
72043
|
}
|
|
69440
72044
|
|
|
69441
|
-
if (!Util.isUnset(request.
|
|
69442
|
-
query["
|
|
72045
|
+
if (!Util.isUnset(request.ceIp)) {
|
|
72046
|
+
query["CeIp"] = request.ceIp;
|
|
69443
72047
|
}
|
|
69444
72048
|
|
|
69445
|
-
if (!Util.isUnset(request.
|
|
69446
|
-
query["
|
|
72049
|
+
if (!Util.isUnset(request.description)) {
|
|
72050
|
+
query["Description"] = request.description;
|
|
72051
|
+
}
|
|
72052
|
+
|
|
72053
|
+
if (!Util.isUnset(request.eccId)) {
|
|
72054
|
+
query["EccId"] = request.eccId;
|
|
72055
|
+
}
|
|
72056
|
+
|
|
72057
|
+
if (!Util.isUnset(request.name)) {
|
|
72058
|
+
query["Name"] = request.name;
|
|
69447
72059
|
}
|
|
69448
72060
|
|
|
69449
72061
|
if (!Util.isUnset(request.ownerAccount)) {
|
|
@@ -69454,6 +72066,10 @@ export default class Client extends OpenApi {
|
|
|
69454
72066
|
query["OwnerId"] = request.ownerId;
|
|
69455
72067
|
}
|
|
69456
72068
|
|
|
72069
|
+
if (!Util.isUnset(request.peIp)) {
|
|
72070
|
+
query["PeIp"] = request.peIp;
|
|
72071
|
+
}
|
|
72072
|
+
|
|
69457
72073
|
if (!Util.isUnset(request.regionId)) {
|
|
69458
72074
|
query["RegionId"] = request.regionId;
|
|
69459
72075
|
}
|
|
@@ -69470,7 +72086,7 @@ export default class Client extends OpenApi {
|
|
|
69470
72086
|
query: OpenApiUtil.query(query),
|
|
69471
72087
|
});
|
|
69472
72088
|
let params = new $OpenApi.Params({
|
|
69473
|
-
action: "
|
|
72089
|
+
action: "ModifyExpressCloudConnectionAttribute",
|
|
69474
72090
|
version: "2016-04-28",
|
|
69475
72091
|
protocol: "HTTPS",
|
|
69476
72092
|
pathname: "/",
|
|
@@ -69480,45 +72096,23 @@ export default class Client extends OpenApi {
|
|
|
69480
72096
|
reqBodyType: "formData",
|
|
69481
72097
|
bodyType: "json",
|
|
69482
72098
|
});
|
|
69483
|
-
return $tea.cast<
|
|
72099
|
+
return $tea.cast<ModifyExpressCloudConnectionAttributeResponse>(await this.callApi(params, req, runtime), new ModifyExpressCloudConnectionAttributeResponse({}));
|
|
69484
72100
|
}
|
|
69485
72101
|
|
|
69486
|
-
|
|
69487
|
-
* You can call the **ModifyCommonBandwidthPackageIpBandwidth** operation to set the maximum bandwidth of an EIP that is associated with an Internet Shared Bandwidth instance. This prevents an EIP from exhausting the bandwidth resources of an Internet Shared Bandwidth instance.
|
|
69488
|
-
* For example, two EIPs are associated with an Internet Shared Bandwidth instance whose maximum bandwidth is 800 Mbit/s. In this case, you can set the maximum bandwidth of one EIP to 500 Mbit/s and that of the other EIP to 400 Mbit/s. After you set the maximum bandwidth values, the first EIP cannot consume bandwidth higher than 500 Mbit/s. The second EIP cannot consume bandwidth higher than 400 Mbit/s.
|
|
69489
|
-
* When you call this operation, take note of the following items:
|
|
69490
|
-
* * This operation is valid only for EIPs that are associated with Elastic Compute Service (ECS) instances. This operation is invalid for EIPs that are associated with Server Load Balancer (SLB) instances, NAT gateways, secondary elastic network interfaces (ENIs), or high-availability virtual IP addresses (HAVIPs).
|
|
69491
|
-
* * This operation is in public preview. You can call this operation to set the maximum bandwidth of EIPs only if the EIPs are associated with an Internet Shared Bandwidth instance. The feature is not supported in the console.
|
|
69492
|
-
* * You cannot repeatedly call this operation to set the maximum bandwidth of an EIP within the specified period of time.
|
|
69493
|
-
*
|
|
69494
|
-
* @param request ModifyCommonBandwidthPackageIpBandwidthRequest
|
|
69495
|
-
* @return ModifyCommonBandwidthPackageIpBandwidthResponse
|
|
69496
|
-
*/
|
|
69497
|
-
async modifyCommonBandwidthPackageIpBandwidth(request: ModifyCommonBandwidthPackageIpBandwidthRequest): Promise<ModifyCommonBandwidthPackageIpBandwidthResponse> {
|
|
72102
|
+
async modifyExpressCloudConnectionAttribute(request: ModifyExpressCloudConnectionAttributeRequest): Promise<ModifyExpressCloudConnectionAttributeResponse> {
|
|
69498
72103
|
let runtime = new $Util.RuntimeOptions({ });
|
|
69499
|
-
return await this.
|
|
72104
|
+
return await this.modifyExpressCloudConnectionAttributeWithOptions(request, runtime);
|
|
69500
72105
|
}
|
|
69501
72106
|
|
|
69502
|
-
|
|
69503
|
-
* Before you call this operation, take note of the following items:
|
|
69504
|
-
* * **ModifyCommonBandwidthPackageSpec** 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 [DescribeCommonBandwidthPackages](~~120309~~) operation to query the status of the task.
|
|
69505
|
-
* * If the Internet Shared Bandwidth instance is in the **Modifying** state, the maximum bandwidth of the Internet Shared Bandwidth instance is being modified. In this state, you can only query the Internet Shared Bandwidth instance and cannot perform other operations.
|
|
69506
|
-
* * If the Internet Shared Bandwidth instance is in the **Available** state, the maximum bandwidth of the Internet Shared Bandwidth instance is modified.
|
|
69507
|
-
* * You cannot repeatedly call the **ModifyCommonBandwidthPackageSpec** operation to modify the maximum bandwidth of an Internet Shared Bandwidth instance within the specified period of time.
|
|
69508
|
-
*
|
|
69509
|
-
* @param request ModifyCommonBandwidthPackageSpecRequest
|
|
69510
|
-
* @param runtime runtime options for this request RuntimeOptions
|
|
69511
|
-
* @return ModifyCommonBandwidthPackageSpecResponse
|
|
69512
|
-
*/
|
|
69513
|
-
async modifyCommonBandwidthPackageSpecWithOptions(request: ModifyCommonBandwidthPackageSpecRequest, runtime: $Util.RuntimeOptions): Promise<ModifyCommonBandwidthPackageSpecResponse> {
|
|
72107
|
+
async modifyExpressCloudConnectionBandwidthWithOptions(request: ModifyExpressCloudConnectionBandwidthRequest, runtime: $Util.RuntimeOptions): Promise<ModifyExpressCloudConnectionBandwidthResponse> {
|
|
69514
72108
|
Util.validateModel(request);
|
|
69515
72109
|
let query = { };
|
|
69516
72110
|
if (!Util.isUnset(request.bandwidth)) {
|
|
69517
72111
|
query["Bandwidth"] = request.bandwidth;
|
|
69518
72112
|
}
|
|
69519
72113
|
|
|
69520
|
-
if (!Util.isUnset(request.
|
|
69521
|
-
query["
|
|
72114
|
+
if (!Util.isUnset(request.eccId)) {
|
|
72115
|
+
query["EccId"] = request.eccId;
|
|
69522
72116
|
}
|
|
69523
72117
|
|
|
69524
72118
|
if (!Util.isUnset(request.ownerAccount)) {
|
|
@@ -69545,7 +72139,7 @@ export default class Client extends OpenApi {
|
|
|
69545
72139
|
query: OpenApiUtil.query(query),
|
|
69546
72140
|
});
|
|
69547
72141
|
let params = new $OpenApi.Params({
|
|
69548
|
-
action: "
|
|
72142
|
+
action: "ModifyExpressCloudConnectionBandwidth",
|
|
69549
72143
|
version: "2016-04-28",
|
|
69550
72144
|
protocol: "HTTPS",
|
|
69551
72145
|
pathname: "/",
|
|
@@ -69555,56 +72149,27 @@ export default class Client extends OpenApi {
|
|
|
69555
72149
|
reqBodyType: "formData",
|
|
69556
72150
|
bodyType: "json",
|
|
69557
72151
|
});
|
|
69558
|
-
return $tea.cast<
|
|
72152
|
+
return $tea.cast<ModifyExpressCloudConnectionBandwidthResponse>(await this.callApi(params, req, runtime), new ModifyExpressCloudConnectionBandwidthResponse({}));
|
|
69559
72153
|
}
|
|
69560
72154
|
|
|
69561
|
-
|
|
69562
|
-
* Before you call this operation, take note of the following items:
|
|
69563
|
-
* * **ModifyCommonBandwidthPackageSpec** 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 [DescribeCommonBandwidthPackages](~~120309~~) operation to query the status of the task.
|
|
69564
|
-
* * If the Internet Shared Bandwidth instance is in the **Modifying** state, the maximum bandwidth of the Internet Shared Bandwidth instance is being modified. In this state, you can only query the Internet Shared Bandwidth instance and cannot perform other operations.
|
|
69565
|
-
* * If the Internet Shared Bandwidth instance is in the **Available** state, the maximum bandwidth of the Internet Shared Bandwidth instance is modified.
|
|
69566
|
-
* * You cannot repeatedly call the **ModifyCommonBandwidthPackageSpec** operation to modify the maximum bandwidth of an Internet Shared Bandwidth instance within the specified period of time.
|
|
69567
|
-
*
|
|
69568
|
-
* @param request ModifyCommonBandwidthPackageSpecRequest
|
|
69569
|
-
* @return ModifyCommonBandwidthPackageSpecResponse
|
|
69570
|
-
*/
|
|
69571
|
-
async modifyCommonBandwidthPackageSpec(request: ModifyCommonBandwidthPackageSpecRequest): Promise<ModifyCommonBandwidthPackageSpecResponse> {
|
|
72155
|
+
async modifyExpressCloudConnectionBandwidth(request: ModifyExpressCloudConnectionBandwidthRequest): Promise<ModifyExpressCloudConnectionBandwidthResponse> {
|
|
69572
72156
|
let runtime = new $Util.RuntimeOptions({ });
|
|
69573
|
-
return await this.
|
|
72157
|
+
return await this.modifyExpressCloudConnectionBandwidthWithOptions(request, runtime);
|
|
69574
72158
|
}
|
|
69575
72159
|
|
|
69576
|
-
|
|
69577
|
-
* * When you call **ModifyCustomerGatewayAttribute**, if a value is assigned to **AuthKey**, the operation is asynchronous. 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.
|
|
69578
|
-
* * If a VPN gateway is in the **updating** state, the configurations are being modified.
|
|
69579
|
-
* * If a VPN gateway is in the **active** state, the configurations are modified.
|
|
69580
|
-
* * When you call **ModifyCustomerGatewayAttribute**, if no value is assigned to **AuthKey**, the operation is synchronous.
|
|
69581
|
-
* * You cannot repeatedly call **ModifyCustomerGatewayAttribute** to modify the configurations of a customer gateway within the specified period of time.
|
|
69582
|
-
*
|
|
69583
|
-
* @param request ModifyCustomerGatewayAttributeRequest
|
|
69584
|
-
* @param runtime runtime options for this request RuntimeOptions
|
|
69585
|
-
* @return ModifyCustomerGatewayAttributeResponse
|
|
69586
|
-
*/
|
|
69587
|
-
async modifyCustomerGatewayAttributeWithOptions(request: ModifyCustomerGatewayAttributeRequest, runtime: $Util.RuntimeOptions): Promise<ModifyCustomerGatewayAttributeResponse> {
|
|
72160
|
+
async modifyExpressConnectTrafficQosWithOptions(request: ModifyExpressConnectTrafficQosRequest, runtime: $Util.RuntimeOptions): Promise<ModifyExpressConnectTrafficQosResponse> {
|
|
69588
72161
|
Util.validateModel(request);
|
|
69589
72162
|
let query = { };
|
|
69590
|
-
if (!Util.isUnset(request.
|
|
69591
|
-
query["
|
|
72163
|
+
if (!Util.isUnset(request.addInstanceList)) {
|
|
72164
|
+
query["AddInstanceList"] = request.addInstanceList;
|
|
69592
72165
|
}
|
|
69593
72166
|
|
|
69594
72167
|
if (!Util.isUnset(request.clientToken)) {
|
|
69595
72168
|
query["ClientToken"] = request.clientToken;
|
|
69596
72169
|
}
|
|
69597
72170
|
|
|
69598
|
-
if (!Util.isUnset(request.
|
|
69599
|
-
query["
|
|
69600
|
-
}
|
|
69601
|
-
|
|
69602
|
-
if (!Util.isUnset(request.description)) {
|
|
69603
|
-
query["Description"] = request.description;
|
|
69604
|
-
}
|
|
69605
|
-
|
|
69606
|
-
if (!Util.isUnset(request.name)) {
|
|
69607
|
-
query["Name"] = request.name;
|
|
72171
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
72172
|
+
query["ClientToken"] = request.clientToken;
|
|
69608
72173
|
}
|
|
69609
72174
|
|
|
69610
72175
|
if (!Util.isUnset(request.ownerAccount)) {
|
|
@@ -69615,23 +72180,35 @@ export default class Client extends OpenApi {
|
|
|
69615
72180
|
query["OwnerId"] = request.ownerId;
|
|
69616
72181
|
}
|
|
69617
72182
|
|
|
72183
|
+
if (!Util.isUnset(request.qosDescription)) {
|
|
72184
|
+
query["QosDescription"] = request.qosDescription;
|
|
72185
|
+
}
|
|
72186
|
+
|
|
72187
|
+
if (!Util.isUnset(request.qosId)) {
|
|
72188
|
+
query["QosId"] = request.qosId;
|
|
72189
|
+
}
|
|
72190
|
+
|
|
72191
|
+
if (!Util.isUnset(request.qosName)) {
|
|
72192
|
+
query["QosName"] = request.qosName;
|
|
72193
|
+
}
|
|
72194
|
+
|
|
69618
72195
|
if (!Util.isUnset(request.regionId)) {
|
|
69619
72196
|
query["RegionId"] = request.regionId;
|
|
69620
72197
|
}
|
|
69621
72198
|
|
|
69622
|
-
if (!Util.isUnset(request.
|
|
69623
|
-
query["
|
|
72199
|
+
if (!Util.isUnset(request.removeInstanceList)) {
|
|
72200
|
+
query["RemoveInstanceList"] = request.removeInstanceList;
|
|
69624
72201
|
}
|
|
69625
72202
|
|
|
69626
|
-
if (!Util.isUnset(request.
|
|
69627
|
-
query["
|
|
72203
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
72204
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
69628
72205
|
}
|
|
69629
72206
|
|
|
69630
72207
|
let req = new $OpenApi.OpenApiRequest({
|
|
69631
72208
|
query: OpenApiUtil.query(query),
|
|
69632
72209
|
});
|
|
69633
72210
|
let params = new $OpenApi.Params({
|
|
69634
|
-
action: "
|
|
72211
|
+
action: "ModifyExpressConnectTrafficQos",
|
|
69635
72212
|
version: "2016-04-28",
|
|
69636
72213
|
protocol: "HTTPS",
|
|
69637
72214
|
pathname: "/",
|
|
@@ -69641,41 +72218,27 @@ export default class Client extends OpenApi {
|
|
|
69641
72218
|
reqBodyType: "formData",
|
|
69642
72219
|
bodyType: "json",
|
|
69643
72220
|
});
|
|
69644
|
-
return $tea.cast<
|
|
72221
|
+
return $tea.cast<ModifyExpressConnectTrafficQosResponse>(await this.callApi(params, req, runtime), new ModifyExpressConnectTrafficQosResponse({}));
|
|
69645
72222
|
}
|
|
69646
72223
|
|
|
69647
|
-
|
|
69648
|
-
* * When you call **ModifyCustomerGatewayAttribute**, if a value is assigned to **AuthKey**, the operation is asynchronous. 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.
|
|
69649
|
-
* * If a VPN gateway is in the **updating** state, the configurations are being modified.
|
|
69650
|
-
* * If a VPN gateway is in the **active** state, the configurations are modified.
|
|
69651
|
-
* * When you call **ModifyCustomerGatewayAttribute**, if no value is assigned to **AuthKey**, the operation is synchronous.
|
|
69652
|
-
* * You cannot repeatedly call **ModifyCustomerGatewayAttribute** to modify the configurations of a customer gateway within the specified period of time.
|
|
69653
|
-
*
|
|
69654
|
-
* @param request ModifyCustomerGatewayAttributeRequest
|
|
69655
|
-
* @return ModifyCustomerGatewayAttributeResponse
|
|
69656
|
-
*/
|
|
69657
|
-
async modifyCustomerGatewayAttribute(request: ModifyCustomerGatewayAttributeRequest): Promise<ModifyCustomerGatewayAttributeResponse> {
|
|
72224
|
+
async modifyExpressConnectTrafficQos(request: ModifyExpressConnectTrafficQosRequest): Promise<ModifyExpressConnectTrafficQosResponse> {
|
|
69658
72225
|
let runtime = new $Util.RuntimeOptions({ });
|
|
69659
|
-
return await this.
|
|
72226
|
+
return await this.modifyExpressConnectTrafficQosWithOptions(request, runtime);
|
|
69660
72227
|
}
|
|
69661
72228
|
|
|
69662
|
-
async
|
|
72229
|
+
async modifyExpressConnectTrafficQosQueueWithOptions(request: ModifyExpressConnectTrafficQosQueueRequest, runtime: $Util.RuntimeOptions): Promise<ModifyExpressConnectTrafficQosQueueResponse> {
|
|
69663
72230
|
Util.validateModel(request);
|
|
69664
72231
|
let query = { };
|
|
69665
|
-
if (!Util.isUnset(request.
|
|
69666
|
-
query["
|
|
69667
|
-
}
|
|
69668
|
-
|
|
69669
|
-
if (!Util.isUnset(request.bandwidth)) {
|
|
69670
|
-
query["Bandwidth"] = request.bandwidth;
|
|
72232
|
+
if (!Util.isUnset(request.bandwidthPercent)) {
|
|
72233
|
+
query["BandwidthPercent"] = request.bandwidthPercent;
|
|
69671
72234
|
}
|
|
69672
72235
|
|
|
69673
|
-
if (!Util.isUnset(request.
|
|
69674
|
-
query["
|
|
72236
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
72237
|
+
query["ClientToken"] = request.clientToken;
|
|
69675
72238
|
}
|
|
69676
72239
|
|
|
69677
|
-
if (!Util.isUnset(request.
|
|
69678
|
-
query["
|
|
72240
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
72241
|
+
query["ClientToken"] = request.clientToken;
|
|
69679
72242
|
}
|
|
69680
72243
|
|
|
69681
72244
|
if (!Util.isUnset(request.ownerAccount)) {
|
|
@@ -69686,6 +72249,22 @@ export default class Client extends OpenApi {
|
|
|
69686
72249
|
query["OwnerId"] = request.ownerId;
|
|
69687
72250
|
}
|
|
69688
72251
|
|
|
72252
|
+
if (!Util.isUnset(request.qosId)) {
|
|
72253
|
+
query["QosId"] = request.qosId;
|
|
72254
|
+
}
|
|
72255
|
+
|
|
72256
|
+
if (!Util.isUnset(request.queueDescription)) {
|
|
72257
|
+
query["QueueDescription"] = request.queueDescription;
|
|
72258
|
+
}
|
|
72259
|
+
|
|
72260
|
+
if (!Util.isUnset(request.queueId)) {
|
|
72261
|
+
query["QueueId"] = request.queueId;
|
|
72262
|
+
}
|
|
72263
|
+
|
|
72264
|
+
if (!Util.isUnset(request.queueName)) {
|
|
72265
|
+
query["QueueName"] = request.queueName;
|
|
72266
|
+
}
|
|
72267
|
+
|
|
69689
72268
|
if (!Util.isUnset(request.regionId)) {
|
|
69690
72269
|
query["RegionId"] = request.regionId;
|
|
69691
72270
|
}
|
|
@@ -69694,15 +72273,11 @@ export default class Client extends OpenApi {
|
|
|
69694
72273
|
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
69695
72274
|
}
|
|
69696
72275
|
|
|
69697
|
-
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
69698
|
-
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
69699
|
-
}
|
|
69700
|
-
|
|
69701
72276
|
let req = new $OpenApi.OpenApiRequest({
|
|
69702
72277
|
query: OpenApiUtil.query(query),
|
|
69703
72278
|
});
|
|
69704
72279
|
let params = new $OpenApi.Params({
|
|
69705
|
-
action: "
|
|
72280
|
+
action: "ModifyExpressConnectTrafficQosQueue",
|
|
69706
72281
|
version: "2016-04-28",
|
|
69707
72282
|
protocol: "HTTPS",
|
|
69708
72283
|
pathname: "/",
|
|
@@ -69712,35 +72287,39 @@ export default class Client extends OpenApi {
|
|
|
69712
72287
|
reqBodyType: "formData",
|
|
69713
72288
|
bodyType: "json",
|
|
69714
72289
|
});
|
|
69715
|
-
return $tea.cast<
|
|
72290
|
+
return $tea.cast<ModifyExpressConnectTrafficQosQueueResponse>(await this.callApi(params, req, runtime), new ModifyExpressConnectTrafficQosQueueResponse({}));
|
|
69716
72291
|
}
|
|
69717
72292
|
|
|
69718
|
-
async
|
|
72293
|
+
async modifyExpressConnectTrafficQosQueue(request: ModifyExpressConnectTrafficQosQueueRequest): Promise<ModifyExpressConnectTrafficQosQueueResponse> {
|
|
69719
72294
|
let runtime = new $Util.RuntimeOptions({ });
|
|
69720
|
-
return await this.
|
|
72295
|
+
return await this.modifyExpressConnectTrafficQosQueueWithOptions(request, runtime);
|
|
69721
72296
|
}
|
|
69722
72297
|
|
|
69723
|
-
async
|
|
72298
|
+
async modifyExpressConnectTrafficQosRuleWithOptions(request: ModifyExpressConnectTrafficQosRuleRequest, runtime: $Util.RuntimeOptions): Promise<ModifyExpressConnectTrafficQosRuleResponse> {
|
|
69724
72299
|
Util.validateModel(request);
|
|
69725
72300
|
let query = { };
|
|
69726
|
-
if (!Util.isUnset(request.
|
|
69727
|
-
query["
|
|
72301
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
72302
|
+
query["ClientToken"] = request.clientToken;
|
|
69728
72303
|
}
|
|
69729
72304
|
|
|
69730
|
-
if (!Util.isUnset(request.
|
|
69731
|
-
query["
|
|
72305
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
72306
|
+
query["ClientToken"] = request.clientToken;
|
|
69732
72307
|
}
|
|
69733
72308
|
|
|
69734
|
-
if (!Util.isUnset(request.
|
|
69735
|
-
query["
|
|
72309
|
+
if (!Util.isUnset(request.dstCidr)) {
|
|
72310
|
+
query["DstCidr"] = request.dstCidr;
|
|
69736
72311
|
}
|
|
69737
72312
|
|
|
69738
|
-
if (!Util.isUnset(request.
|
|
69739
|
-
query["
|
|
72313
|
+
if (!Util.isUnset(request.dstIPv6Cidr)) {
|
|
72314
|
+
query["DstIPv6Cidr"] = request.dstIPv6Cidr;
|
|
69740
72315
|
}
|
|
69741
72316
|
|
|
69742
|
-
if (!Util.isUnset(request.
|
|
69743
|
-
query["
|
|
72317
|
+
if (!Util.isUnset(request.dstPortRange)) {
|
|
72318
|
+
query["DstPortRange"] = request.dstPortRange;
|
|
72319
|
+
}
|
|
72320
|
+
|
|
72321
|
+
if (!Util.isUnset(request.matchDscp)) {
|
|
72322
|
+
query["MatchDscp"] = request.matchDscp;
|
|
69744
72323
|
}
|
|
69745
72324
|
|
|
69746
72325
|
if (!Util.isUnset(request.ownerAccount)) {
|
|
@@ -69751,80 +72330,63 @@ export default class Client extends OpenApi {
|
|
|
69751
72330
|
query["OwnerId"] = request.ownerId;
|
|
69752
72331
|
}
|
|
69753
72332
|
|
|
69754
|
-
if (!Util.isUnset(request.
|
|
69755
|
-
query["
|
|
72333
|
+
if (!Util.isUnset(request.priority)) {
|
|
72334
|
+
query["Priority"] = request.priority;
|
|
69756
72335
|
}
|
|
69757
72336
|
|
|
69758
|
-
if (!Util.isUnset(request.
|
|
69759
|
-
query["
|
|
72337
|
+
if (!Util.isUnset(request.protocol)) {
|
|
72338
|
+
query["Protocol"] = request.protocol;
|
|
69760
72339
|
}
|
|
69761
72340
|
|
|
69762
|
-
if (!Util.isUnset(request.
|
|
69763
|
-
query["
|
|
72341
|
+
if (!Util.isUnset(request.qosId)) {
|
|
72342
|
+
query["QosId"] = request.qosId;
|
|
69764
72343
|
}
|
|
69765
72344
|
|
|
69766
|
-
if (!Util.isUnset(request.
|
|
69767
|
-
query["
|
|
72345
|
+
if (!Util.isUnset(request.queueId)) {
|
|
72346
|
+
query["QueueId"] = request.queueId;
|
|
69768
72347
|
}
|
|
69769
72348
|
|
|
69770
|
-
|
|
69771
|
-
query
|
|
69772
|
-
}
|
|
69773
|
-
let params = new $OpenApi.Params({
|
|
69774
|
-
action: "ModifyExpressCloudConnectionAttribute",
|
|
69775
|
-
version: "2016-04-28",
|
|
69776
|
-
protocol: "HTTPS",
|
|
69777
|
-
pathname: "/",
|
|
69778
|
-
method: "POST",
|
|
69779
|
-
authType: "AK",
|
|
69780
|
-
style: "RPC",
|
|
69781
|
-
reqBodyType: "formData",
|
|
69782
|
-
bodyType: "json",
|
|
69783
|
-
});
|
|
69784
|
-
return $tea.cast<ModifyExpressCloudConnectionAttributeResponse>(await this.callApi(params, req, runtime), new ModifyExpressCloudConnectionAttributeResponse({}));
|
|
69785
|
-
}
|
|
72349
|
+
if (!Util.isUnset(request.regionId)) {
|
|
72350
|
+
query["RegionId"] = request.regionId;
|
|
72351
|
+
}
|
|
69786
72352
|
|
|
69787
|
-
|
|
69788
|
-
|
|
69789
|
-
|
|
69790
|
-
}
|
|
72353
|
+
if (!Util.isUnset(request.remarkingDscp)) {
|
|
72354
|
+
query["RemarkingDscp"] = request.remarkingDscp;
|
|
72355
|
+
}
|
|
69791
72356
|
|
|
69792
|
-
|
|
69793
|
-
|
|
69794
|
-
let query = { };
|
|
69795
|
-
if (!Util.isUnset(request.bandwidth)) {
|
|
69796
|
-
query["Bandwidth"] = request.bandwidth;
|
|
72357
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
72358
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
69797
72359
|
}
|
|
69798
72360
|
|
|
69799
|
-
if (!Util.isUnset(request.
|
|
69800
|
-
query["
|
|
72361
|
+
if (!Util.isUnset(request.ruleDescription)) {
|
|
72362
|
+
query["RuleDescription"] = request.ruleDescription;
|
|
69801
72363
|
}
|
|
69802
72364
|
|
|
69803
|
-
if (!Util.isUnset(request.
|
|
69804
|
-
query["
|
|
72365
|
+
if (!Util.isUnset(request.ruleId)) {
|
|
72366
|
+
query["RuleId"] = request.ruleId;
|
|
69805
72367
|
}
|
|
69806
72368
|
|
|
69807
|
-
if (!Util.isUnset(request.
|
|
69808
|
-
query["
|
|
72369
|
+
if (!Util.isUnset(request.ruleName)) {
|
|
72370
|
+
query["RuleName"] = request.ruleName;
|
|
69809
72371
|
}
|
|
69810
72372
|
|
|
69811
|
-
if (!Util.isUnset(request.
|
|
69812
|
-
query["
|
|
72373
|
+
if (!Util.isUnset(request.srcCidr)) {
|
|
72374
|
+
query["SrcCidr"] = request.srcCidr;
|
|
69813
72375
|
}
|
|
69814
72376
|
|
|
69815
|
-
if (!Util.isUnset(request.
|
|
69816
|
-
query["
|
|
72377
|
+
if (!Util.isUnset(request.srcIPv6Cidr)) {
|
|
72378
|
+
query["SrcIPv6Cidr"] = request.srcIPv6Cidr;
|
|
69817
72379
|
}
|
|
69818
72380
|
|
|
69819
|
-
if (!Util.isUnset(request.
|
|
69820
|
-
query["
|
|
72381
|
+
if (!Util.isUnset(request.srcPortRange)) {
|
|
72382
|
+
query["SrcPortRange"] = request.srcPortRange;
|
|
69821
72383
|
}
|
|
69822
72384
|
|
|
69823
72385
|
let req = new $OpenApi.OpenApiRequest({
|
|
69824
72386
|
query: OpenApiUtil.query(query),
|
|
69825
72387
|
});
|
|
69826
72388
|
let params = new $OpenApi.Params({
|
|
69827
|
-
action: "
|
|
72389
|
+
action: "ModifyExpressConnectTrafficQosRule",
|
|
69828
72390
|
version: "2016-04-28",
|
|
69829
72391
|
protocol: "HTTPS",
|
|
69830
72392
|
pathname: "/",
|
|
@@ -69834,12 +72396,12 @@ export default class Client extends OpenApi {
|
|
|
69834
72396
|
reqBodyType: "formData",
|
|
69835
72397
|
bodyType: "json",
|
|
69836
72398
|
});
|
|
69837
|
-
return $tea.cast<
|
|
72399
|
+
return $tea.cast<ModifyExpressConnectTrafficQosRuleResponse>(await this.callApi(params, req, runtime), new ModifyExpressConnectTrafficQosRuleResponse({}));
|
|
69838
72400
|
}
|
|
69839
72401
|
|
|
69840
|
-
async
|
|
72402
|
+
async modifyExpressConnectTrafficQosRule(request: ModifyExpressConnectTrafficQosRuleRequest): Promise<ModifyExpressConnectTrafficQosRuleResponse> {
|
|
69841
72403
|
let runtime = new $Util.RuntimeOptions({ });
|
|
69842
|
-
return await this.
|
|
72404
|
+
return await this.modifyExpressConnectTrafficQosRuleWithOptions(request, runtime);
|
|
69843
72405
|
}
|
|
69844
72406
|
|
|
69845
72407
|
/**
|
|
@@ -71640,7 +74202,6 @@ export default class Client extends OpenApi {
|
|
|
71640
74202
|
}
|
|
71641
74203
|
|
|
71642
74204
|
/**
|
|
71643
|
-
* ## [](#)Description
|
|
71644
74205
|
* 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.
|
|
71645
74206
|
* > You cannot modify the specification of a router interface that has overdue payments.
|
|
71646
74207
|
*
|
|
@@ -71701,7 +74262,6 @@ export default class Client extends OpenApi {
|
|
|
71701
74262
|
}
|
|
71702
74263
|
|
|
71703
74264
|
/**
|
|
71704
|
-
* ## [](#)Description
|
|
71705
74265
|
* 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.
|
|
71706
74266
|
* > You cannot modify the specification of a router interface that has overdue payments.
|
|
71707
74267
|
*
|
|
@@ -72586,10 +75146,10 @@ export default class Client extends OpenApi {
|
|
|
72586
75146
|
}
|
|
72587
75147
|
|
|
72588
75148
|
/**
|
|
72589
|
-
* *
|
|
75149
|
+
* * **ModifyVpcPrefixList** 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 [ListPrefixLists](~~311535~~) to query the status of the task.
|
|
72590
75150
|
* * If the prefix list is in the **Modifying** state, the configuration of the prefix list is being modified.
|
|
72591
75151
|
* * If the prefix list is in the **Created** state, the configuration of the prefix list is modified.
|
|
72592
|
-
* * After the configuration of the prefix list is modified, you can call the [GetVpcPrefixListAssociations](~~445478~~) operation to query information about the network instances that are associated with the prefix list and determine whether the associated network instances use the new CIDR blocks. If the association **status** of the prefix list is **Created**, the new CIDR blocks are used by the network instances that are associated with the prefix list.
|
|
75152
|
+
* * After the configuration of the prefix list is modified, you can call the [GetVpcPrefixListAssociations](~~445478~~) operation to query the information about the network instances that are associated with the prefix list and determine whether the associated network instances use the new CIDR blocks. If the association **status** of the prefix list is **Created**, the new CIDR blocks are used by the network instances that are associated with the prefix list.
|
|
72593
75153
|
* * You cannot repeatedly call **ModifyVpcPrefixList** to modify the configuration of a prefix list within the specified period of time.
|
|
72594
75154
|
*
|
|
72595
75155
|
* @param request ModifyVpcPrefixListRequest
|
|
@@ -72669,10 +75229,10 @@ export default class Client extends OpenApi {
|
|
|
72669
75229
|
}
|
|
72670
75230
|
|
|
72671
75231
|
/**
|
|
72672
|
-
* *
|
|
75232
|
+
* * **ModifyVpcPrefixList** 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 [ListPrefixLists](~~311535~~) to query the status of the task.
|
|
72673
75233
|
* * If the prefix list is in the **Modifying** state, the configuration of the prefix list is being modified.
|
|
72674
75234
|
* * If the prefix list is in the **Created** state, the configuration of the prefix list is modified.
|
|
72675
|
-
* * After the configuration of the prefix list is modified, you can call the [GetVpcPrefixListAssociations](~~445478~~) operation to query information about the network instances that are associated with the prefix list and determine whether the associated network instances use the new CIDR blocks. If the association **status** of the prefix list is **Created**, the new CIDR blocks are used by the network instances that are associated with the prefix list.
|
|
75235
|
+
* * After the configuration of the prefix list is modified, you can call the [GetVpcPrefixListAssociations](~~445478~~) operation to query the information about the network instances that are associated with the prefix list and determine whether the associated network instances use the new CIDR blocks. If the association **status** of the prefix list is **Created**, the new CIDR blocks are used by the network instances that are associated with the prefix list.
|
|
72676
75236
|
* * You cannot repeatedly call **ModifyVpcPrefixList** to modify the configuration of a prefix list within the specified period of time.
|
|
72677
75237
|
*
|
|
72678
75238
|
* @param request ModifyVpcPrefixListRequest
|
|
@@ -73857,7 +76417,7 @@ export default class Client extends OpenApi {
|
|
|
73857
76417
|
}
|
|
73858
76418
|
|
|
73859
76419
|
/**
|
|
73860
|
-
* After
|
|
76420
|
+
* After you call this operation, the VBR changes from the **terminated** state to the **recovering** state. After the operation is performed, the VBR enters the **active** state.
|
|
73861
76421
|
* When you call this operation, take note of the following items:
|
|
73862
76422
|
* * Only the owner of the Express Connect circuit can call this operation.
|
|
73863
76423
|
* * The Express Connect circuit to which the VBR connects must be in the **Enabled** state.
|
|
@@ -73915,7 +76475,7 @@ export default class Client extends OpenApi {
|
|
|
73915
76475
|
}
|
|
73916
76476
|
|
|
73917
76477
|
/**
|
|
73918
|
-
* After
|
|
76478
|
+
* After you call this operation, the VBR changes from the **terminated** state to the **recovering** state. After the operation is performed, the VBR enters the **active** state.
|
|
73919
76479
|
* When you call this operation, take note of the following items:
|
|
73920
76480
|
* * Only the owner of the Express Connect circuit can call this operation.
|
|
73921
76481
|
* * The Express Connect circuit to which the VBR connects must be in the **Enabled** state.
|
|
@@ -75193,7 +77753,7 @@ export default class Client extends OpenApi {
|
|
|
75193
77753
|
}
|
|
75194
77754
|
|
|
75195
77755
|
/**
|
|
75196
|
-
* After
|
|
77756
|
+
* After you call this operation, the VBR enters the **terminating** state from the **active** state. After the VBR is terminated, the VBR enters the **terminated** state.
|
|
75197
77757
|
* > Only the owner of an Express Connect circuit can call this operation.
|
|
75198
77758
|
*
|
|
75199
77759
|
* @param request TerminateVirtualBorderRouterRequest
|
|
@@ -75249,7 +77809,7 @@ export default class Client extends OpenApi {
|
|
|
75249
77809
|
}
|
|
75250
77810
|
|
|
75251
77811
|
/**
|
|
75252
|
-
* After
|
|
77812
|
+
* After you call this operation, the VBR enters the **terminating** state from the **active** state. After the VBR is terminated, the VBR enters the **terminated** state.
|
|
75253
77813
|
* > Only the owner of an Express Connect circuit can call this operation.
|
|
75254
77814
|
*
|
|
75255
77815
|
* @param request TerminateVirtualBorderRouterRequest
|