@alicloud/vpc20160428 6.3.2 → 6.4.0
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 +1004 -104
- package/dist/client.js +6805 -4748
- package/dist/client.js.map +1 -1
- package/package.json +5 -5
- package/src/client.ts +2861 -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',
|
|
@@ -43787,6 +45371,7 @@ export class DescribeVpcsResponseBodyVpcsVpc extends $tea.Model {
|
|
|
43787
45371
|
description?: string;
|
|
43788
45372
|
dhcpOptionsSetId?: string;
|
|
43789
45373
|
dhcpOptionsSetStatus?: string;
|
|
45374
|
+
enabledIpv6?: boolean;
|
|
43790
45375
|
ipv6CidrBlock?: string;
|
|
43791
45376
|
ipv6CidrBlocks?: DescribeVpcsResponseBodyVpcsVpcIpv6CidrBlocks;
|
|
43792
45377
|
isDefault?: boolean;
|
|
@@ -43811,6 +45396,7 @@ export class DescribeVpcsResponseBodyVpcsVpc extends $tea.Model {
|
|
|
43811
45396
|
description: 'Description',
|
|
43812
45397
|
dhcpOptionsSetId: 'DhcpOptionsSetId',
|
|
43813
45398
|
dhcpOptionsSetStatus: 'DhcpOptionsSetStatus',
|
|
45399
|
+
enabledIpv6: 'EnabledIpv6',
|
|
43814
45400
|
ipv6CidrBlock: 'Ipv6CidrBlock',
|
|
43815
45401
|
ipv6CidrBlocks: 'Ipv6CidrBlocks',
|
|
43816
45402
|
isDefault: 'IsDefault',
|
|
@@ -43838,6 +45424,7 @@ export class DescribeVpcsResponseBodyVpcsVpc extends $tea.Model {
|
|
|
43838
45424
|
description: 'string',
|
|
43839
45425
|
dhcpOptionsSetId: 'string',
|
|
43840
45426
|
dhcpOptionsSetStatus: 'string',
|
|
45427
|
+
enabledIpv6: 'boolean',
|
|
43841
45428
|
ipv6CidrBlock: 'string',
|
|
43842
45429
|
ipv6CidrBlocks: DescribeVpcsResponseBodyVpcsVpcIpv6CidrBlocks,
|
|
43843
45430
|
isDefault: 'boolean',
|
|
@@ -47797,6 +49384,50 @@ export class ListVpnCertificateAssociationsResponseBodyVpnCertificateRelations e
|
|
|
47797
49384
|
}
|
|
47798
49385
|
}
|
|
47799
49386
|
|
|
49387
|
+
export class ModifyExpressConnectTrafficQosRequestAddInstanceList extends $tea.Model {
|
|
49388
|
+
instanceId?: string;
|
|
49389
|
+
instanceType?: string;
|
|
49390
|
+
static names(): { [key: string]: string } {
|
|
49391
|
+
return {
|
|
49392
|
+
instanceId: 'InstanceId',
|
|
49393
|
+
instanceType: 'InstanceType',
|
|
49394
|
+
};
|
|
49395
|
+
}
|
|
49396
|
+
|
|
49397
|
+
static types(): { [key: string]: any } {
|
|
49398
|
+
return {
|
|
49399
|
+
instanceId: 'string',
|
|
49400
|
+
instanceType: 'string',
|
|
49401
|
+
};
|
|
49402
|
+
}
|
|
49403
|
+
|
|
49404
|
+
constructor(map?: { [key: string]: any }) {
|
|
49405
|
+
super(map);
|
|
49406
|
+
}
|
|
49407
|
+
}
|
|
49408
|
+
|
|
49409
|
+
export class ModifyExpressConnectTrafficQosRequestRemoveInstanceList extends $tea.Model {
|
|
49410
|
+
instanceId?: string;
|
|
49411
|
+
instanceType?: string;
|
|
49412
|
+
static names(): { [key: string]: string } {
|
|
49413
|
+
return {
|
|
49414
|
+
instanceId: 'InstanceId',
|
|
49415
|
+
instanceType: 'InstanceType',
|
|
49416
|
+
};
|
|
49417
|
+
}
|
|
49418
|
+
|
|
49419
|
+
static types(): { [key: string]: any } {
|
|
49420
|
+
return {
|
|
49421
|
+
instanceId: 'string',
|
|
49422
|
+
instanceType: 'string',
|
|
49423
|
+
};
|
|
49424
|
+
}
|
|
49425
|
+
|
|
49426
|
+
constructor(map?: { [key: string]: any }) {
|
|
49427
|
+
super(map);
|
|
49428
|
+
}
|
|
49429
|
+
}
|
|
49430
|
+
|
|
47800
49431
|
export class ModifyTunnelAttributeRequestTunnelOptionsSpecificationTunnelBgpConfig extends $tea.Model {
|
|
47801
49432
|
localAsn?: number;
|
|
47802
49433
|
localBgpIp?: string;
|
|
@@ -52594,6 +54225,237 @@ export default class Client extends OpenApi {
|
|
|
52594
54225
|
return await this.createExpressCloudConnectionWithOptions(request, runtime);
|
|
52595
54226
|
}
|
|
52596
54227
|
|
|
54228
|
+
async createExpressConnectTrafficQosWithOptions(request: CreateExpressConnectTrafficQosRequest, runtime: $Util.RuntimeOptions): Promise<CreateExpressConnectTrafficQosResponse> {
|
|
54229
|
+
Util.validateModel(request);
|
|
54230
|
+
let query = { };
|
|
54231
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
54232
|
+
query["ClientToken"] = request.clientToken;
|
|
54233
|
+
}
|
|
54234
|
+
|
|
54235
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
54236
|
+
query["ClientToken"] = request.clientToken;
|
|
54237
|
+
}
|
|
54238
|
+
|
|
54239
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
54240
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
54241
|
+
}
|
|
54242
|
+
|
|
54243
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
54244
|
+
query["OwnerId"] = request.ownerId;
|
|
54245
|
+
}
|
|
54246
|
+
|
|
54247
|
+
if (!Util.isUnset(request.qosDescription)) {
|
|
54248
|
+
query["QosDescription"] = request.qosDescription;
|
|
54249
|
+
}
|
|
54250
|
+
|
|
54251
|
+
if (!Util.isUnset(request.qosName)) {
|
|
54252
|
+
query["QosName"] = request.qosName;
|
|
54253
|
+
}
|
|
54254
|
+
|
|
54255
|
+
if (!Util.isUnset(request.regionId)) {
|
|
54256
|
+
query["RegionId"] = request.regionId;
|
|
54257
|
+
}
|
|
54258
|
+
|
|
54259
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
54260
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
54261
|
+
}
|
|
54262
|
+
|
|
54263
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
54264
|
+
query: OpenApiUtil.query(query),
|
|
54265
|
+
});
|
|
54266
|
+
let params = new $OpenApi.Params({
|
|
54267
|
+
action: "CreateExpressConnectTrafficQos",
|
|
54268
|
+
version: "2016-04-28",
|
|
54269
|
+
protocol: "HTTPS",
|
|
54270
|
+
pathname: "/",
|
|
54271
|
+
method: "POST",
|
|
54272
|
+
authType: "AK",
|
|
54273
|
+
style: "RPC",
|
|
54274
|
+
reqBodyType: "formData",
|
|
54275
|
+
bodyType: "json",
|
|
54276
|
+
});
|
|
54277
|
+
return $tea.cast<CreateExpressConnectTrafficQosResponse>(await this.callApi(params, req, runtime), new CreateExpressConnectTrafficQosResponse({}));
|
|
54278
|
+
}
|
|
54279
|
+
|
|
54280
|
+
async createExpressConnectTrafficQos(request: CreateExpressConnectTrafficQosRequest): Promise<CreateExpressConnectTrafficQosResponse> {
|
|
54281
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
54282
|
+
return await this.createExpressConnectTrafficQosWithOptions(request, runtime);
|
|
54283
|
+
}
|
|
54284
|
+
|
|
54285
|
+
async createExpressConnectTrafficQosQueueWithOptions(request: CreateExpressConnectTrafficQosQueueRequest, runtime: $Util.RuntimeOptions): Promise<CreateExpressConnectTrafficQosQueueResponse> {
|
|
54286
|
+
Util.validateModel(request);
|
|
54287
|
+
let query = { };
|
|
54288
|
+
if (!Util.isUnset(request.bandwidthPercent)) {
|
|
54289
|
+
query["BandwidthPercent"] = request.bandwidthPercent;
|
|
54290
|
+
}
|
|
54291
|
+
|
|
54292
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
54293
|
+
query["ClientToken"] = request.clientToken;
|
|
54294
|
+
}
|
|
54295
|
+
|
|
54296
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
54297
|
+
query["ClientToken"] = request.clientToken;
|
|
54298
|
+
}
|
|
54299
|
+
|
|
54300
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
54301
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
54302
|
+
}
|
|
54303
|
+
|
|
54304
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
54305
|
+
query["OwnerId"] = request.ownerId;
|
|
54306
|
+
}
|
|
54307
|
+
|
|
54308
|
+
if (!Util.isUnset(request.qosId)) {
|
|
54309
|
+
query["QosId"] = request.qosId;
|
|
54310
|
+
}
|
|
54311
|
+
|
|
54312
|
+
if (!Util.isUnset(request.queueDescription)) {
|
|
54313
|
+
query["QueueDescription"] = request.queueDescription;
|
|
54314
|
+
}
|
|
54315
|
+
|
|
54316
|
+
if (!Util.isUnset(request.queueName)) {
|
|
54317
|
+
query["QueueName"] = request.queueName;
|
|
54318
|
+
}
|
|
54319
|
+
|
|
54320
|
+
if (!Util.isUnset(request.queueType)) {
|
|
54321
|
+
query["QueueType"] = request.queueType;
|
|
54322
|
+
}
|
|
54323
|
+
|
|
54324
|
+
if (!Util.isUnset(request.regionId)) {
|
|
54325
|
+
query["RegionId"] = request.regionId;
|
|
54326
|
+
}
|
|
54327
|
+
|
|
54328
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
54329
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
54330
|
+
}
|
|
54331
|
+
|
|
54332
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
54333
|
+
query: OpenApiUtil.query(query),
|
|
54334
|
+
});
|
|
54335
|
+
let params = new $OpenApi.Params({
|
|
54336
|
+
action: "CreateExpressConnectTrafficQosQueue",
|
|
54337
|
+
version: "2016-04-28",
|
|
54338
|
+
protocol: "HTTPS",
|
|
54339
|
+
pathname: "/",
|
|
54340
|
+
method: "POST",
|
|
54341
|
+
authType: "AK",
|
|
54342
|
+
style: "RPC",
|
|
54343
|
+
reqBodyType: "formData",
|
|
54344
|
+
bodyType: "json",
|
|
54345
|
+
});
|
|
54346
|
+
return $tea.cast<CreateExpressConnectTrafficQosQueueResponse>(await this.callApi(params, req, runtime), new CreateExpressConnectTrafficQosQueueResponse({}));
|
|
54347
|
+
}
|
|
54348
|
+
|
|
54349
|
+
async createExpressConnectTrafficQosQueue(request: CreateExpressConnectTrafficQosQueueRequest): Promise<CreateExpressConnectTrafficQosQueueResponse> {
|
|
54350
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
54351
|
+
return await this.createExpressConnectTrafficQosQueueWithOptions(request, runtime);
|
|
54352
|
+
}
|
|
54353
|
+
|
|
54354
|
+
async createExpressConnectTrafficQosRuleWithOptions(request: CreateExpressConnectTrafficQosRuleRequest, runtime: $Util.RuntimeOptions): Promise<CreateExpressConnectTrafficQosRuleResponse> {
|
|
54355
|
+
Util.validateModel(request);
|
|
54356
|
+
let query = { };
|
|
54357
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
54358
|
+
query["ClientToken"] = request.clientToken;
|
|
54359
|
+
}
|
|
54360
|
+
|
|
54361
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
54362
|
+
query["ClientToken"] = request.clientToken;
|
|
54363
|
+
}
|
|
54364
|
+
|
|
54365
|
+
if (!Util.isUnset(request.dstCidr)) {
|
|
54366
|
+
query["DstCidr"] = request.dstCidr;
|
|
54367
|
+
}
|
|
54368
|
+
|
|
54369
|
+
if (!Util.isUnset(request.dstIPv6Cidr)) {
|
|
54370
|
+
query["DstIPv6Cidr"] = request.dstIPv6Cidr;
|
|
54371
|
+
}
|
|
54372
|
+
|
|
54373
|
+
if (!Util.isUnset(request.dstPortRange)) {
|
|
54374
|
+
query["DstPortRange"] = request.dstPortRange;
|
|
54375
|
+
}
|
|
54376
|
+
|
|
54377
|
+
if (!Util.isUnset(request.matchDscp)) {
|
|
54378
|
+
query["MatchDscp"] = request.matchDscp;
|
|
54379
|
+
}
|
|
54380
|
+
|
|
54381
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
54382
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
54383
|
+
}
|
|
54384
|
+
|
|
54385
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
54386
|
+
query["OwnerId"] = request.ownerId;
|
|
54387
|
+
}
|
|
54388
|
+
|
|
54389
|
+
if (!Util.isUnset(request.priority)) {
|
|
54390
|
+
query["Priority"] = request.priority;
|
|
54391
|
+
}
|
|
54392
|
+
|
|
54393
|
+
if (!Util.isUnset(request.protocol)) {
|
|
54394
|
+
query["Protocol"] = request.protocol;
|
|
54395
|
+
}
|
|
54396
|
+
|
|
54397
|
+
if (!Util.isUnset(request.qosId)) {
|
|
54398
|
+
query["QosId"] = request.qosId;
|
|
54399
|
+
}
|
|
54400
|
+
|
|
54401
|
+
if (!Util.isUnset(request.queueId)) {
|
|
54402
|
+
query["QueueId"] = request.queueId;
|
|
54403
|
+
}
|
|
54404
|
+
|
|
54405
|
+
if (!Util.isUnset(request.regionId)) {
|
|
54406
|
+
query["RegionId"] = request.regionId;
|
|
54407
|
+
}
|
|
54408
|
+
|
|
54409
|
+
if (!Util.isUnset(request.remarkingDscp)) {
|
|
54410
|
+
query["RemarkingDscp"] = request.remarkingDscp;
|
|
54411
|
+
}
|
|
54412
|
+
|
|
54413
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
54414
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
54415
|
+
}
|
|
54416
|
+
|
|
54417
|
+
if (!Util.isUnset(request.ruleDescription)) {
|
|
54418
|
+
query["RuleDescription"] = request.ruleDescription;
|
|
54419
|
+
}
|
|
54420
|
+
|
|
54421
|
+
if (!Util.isUnset(request.ruleName)) {
|
|
54422
|
+
query["RuleName"] = request.ruleName;
|
|
54423
|
+
}
|
|
54424
|
+
|
|
54425
|
+
if (!Util.isUnset(request.srcCidr)) {
|
|
54426
|
+
query["SrcCidr"] = request.srcCidr;
|
|
54427
|
+
}
|
|
54428
|
+
|
|
54429
|
+
if (!Util.isUnset(request.srcIPv6Cidr)) {
|
|
54430
|
+
query["SrcIPv6Cidr"] = request.srcIPv6Cidr;
|
|
54431
|
+
}
|
|
54432
|
+
|
|
54433
|
+
if (!Util.isUnset(request.srcPortRange)) {
|
|
54434
|
+
query["SrcPortRange"] = request.srcPortRange;
|
|
54435
|
+
}
|
|
54436
|
+
|
|
54437
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
54438
|
+
query: OpenApiUtil.query(query),
|
|
54439
|
+
});
|
|
54440
|
+
let params = new $OpenApi.Params({
|
|
54441
|
+
action: "CreateExpressConnectTrafficQosRule",
|
|
54442
|
+
version: "2016-04-28",
|
|
54443
|
+
protocol: "HTTPS",
|
|
54444
|
+
pathname: "/",
|
|
54445
|
+
method: "POST",
|
|
54446
|
+
authType: "AK",
|
|
54447
|
+
style: "RPC",
|
|
54448
|
+
reqBodyType: "formData",
|
|
54449
|
+
bodyType: "json",
|
|
54450
|
+
});
|
|
54451
|
+
return $tea.cast<CreateExpressConnectTrafficQosRuleResponse>(await this.callApi(params, req, runtime), new CreateExpressConnectTrafficQosRuleResponse({}));
|
|
54452
|
+
}
|
|
54453
|
+
|
|
54454
|
+
async createExpressConnectTrafficQosRule(request: CreateExpressConnectTrafficQosRuleRequest): Promise<CreateExpressConnectTrafficQosRuleResponse> {
|
|
54455
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
54456
|
+
return await this.createExpressConnectTrafficQosRuleWithOptions(request, runtime);
|
|
54457
|
+
}
|
|
54458
|
+
|
|
52597
54459
|
async createFailoverTestJobWithOptions(request: CreateFailoverTestJobRequest, runtime: $Util.RuntimeOptions): Promise<CreateFailoverTestJobResponse> {
|
|
52598
54460
|
Util.validateModel(request);
|
|
52599
54461
|
let query = { };
|
|
@@ -52668,7 +54530,7 @@ export default class Client extends OpenApi {
|
|
|
52668
54530
|
}
|
|
52669
54531
|
|
|
52670
54532
|
/**
|
|
52671
|
-
* **CreateFlowLog** is an asynchronous operation. After
|
|
54533
|
+
* **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
54534
|
* * If the flow log is in the **Activating** state, the flow log is being created.
|
|
52673
54535
|
* * If the flow log is in the **Active** state, the flow log is created and started.
|
|
52674
54536
|
*
|
|
@@ -52761,7 +54623,7 @@ export default class Client extends OpenApi {
|
|
|
52761
54623
|
}
|
|
52762
54624
|
|
|
52763
54625
|
/**
|
|
52764
|
-
* **CreateFlowLog** is an asynchronous operation. After
|
|
54626
|
+
* **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
54627
|
* * If the flow log is in the **Activating** state, the flow log is being created.
|
|
52766
54628
|
* * If the flow log is in the **Active** state, the flow log is created and started.
|
|
52767
54629
|
*
|
|
@@ -53526,10 +55388,11 @@ export default class Client extends OpenApi {
|
|
|
53526
55388
|
|
|
53527
55389
|
/**
|
|
53528
55390
|
* * 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
|
-
* *
|
|
55391
|
+
* * Before you create an IPsec server, make sure that no IPsec-VPN connection exists on the VPN gateway. For more information, see [DeleteVpnConnection](~~2526948~~).
|
|
55392
|
+
* * **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
55393
|
* * If the VPN gateway is in the **updating** state, the IPsec server is being created.
|
|
53531
55394
|
* * If the VPN gateway is in the **active** state, the IPsec server is created.
|
|
53532
|
-
* * You cannot repeatedly call
|
|
55395
|
+
* * You cannot repeatedly call **CreateIpsecServer** within the specified period of time.
|
|
53533
55396
|
*
|
|
53534
55397
|
* @param request CreateIpsecServerRequest
|
|
53535
55398
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -53605,10 +55468,11 @@ export default class Client extends OpenApi {
|
|
|
53605
55468
|
|
|
53606
55469
|
/**
|
|
53607
55470
|
* * 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
|
-
* *
|
|
55471
|
+
* * Before you create an IPsec server, make sure that no IPsec-VPN connection exists on the VPN gateway. For more information, see [DeleteVpnConnection](~~2526948~~).
|
|
55472
|
+
* * **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
55473
|
* * If the VPN gateway is in the **updating** state, the IPsec server is being created.
|
|
53610
55474
|
* * If the VPN gateway is in the **active** state, the IPsec server is created.
|
|
53611
|
-
* * You cannot repeatedly call
|
|
55475
|
+
* * You cannot repeatedly call **CreateIpsecServer** within the specified period of time.
|
|
53612
55476
|
*
|
|
53613
55477
|
* @param request CreateIpsecServerRequest
|
|
53614
55478
|
* @return CreateIpsecServerResponse
|
|
@@ -54995,7 +56859,6 @@ export default class Client extends OpenApi {
|
|
|
54995
56859
|
}
|
|
54996
56860
|
|
|
54997
56861
|
/**
|
|
54998
|
-
* ## [](#)
|
|
54999
56862
|
* When you call this operation, take note of the following limits:
|
|
55000
56863
|
* * You can create only one pair of interfaces to be connected between two routers.
|
|
55001
56864
|
* * You can create a maximum of five router interfaces for a router.
|
|
@@ -55149,7 +57012,6 @@ export default class Client extends OpenApi {
|
|
|
55149
57012
|
}
|
|
55150
57013
|
|
|
55151
57014
|
/**
|
|
55152
|
-
* ## [](#)
|
|
55153
57015
|
* When you call this operation, take note of the following limits:
|
|
55154
57016
|
* * You can create only one pair of interfaces to be connected between two routers.
|
|
55155
57017
|
* * You can create a maximum of five router interfaces for a router.
|
|
@@ -55329,7 +57191,9 @@ export default class Client extends OpenApi {
|
|
|
55329
57191
|
* * **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
57192
|
* * If the VPN gateway is in the **updating** state, the SSL server is being created.
|
|
55331
57193
|
* * If the VPN gateway is in the **active** state, the SSL server is created.
|
|
55332
|
-
* * You cannot
|
|
57194
|
+
* * You cannot call the **CreateSslVpnServer** operation to create multiple SSL servers at a time for the same VPN gateway.
|
|
57195
|
+
* ### [](#)Prerequisites
|
|
57196
|
+
* A VPN gateway is created, and the SSL-VPN feature is enabled for the VPN gateway. For more information, see [CreateVpnGateway](~~2526913~~).
|
|
55333
57197
|
*
|
|
55334
57198
|
* @param request CreateSslVpnServerRequest
|
|
55335
57199
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -55427,7 +57291,9 @@ export default class Client extends OpenApi {
|
|
|
55427
57291
|
* * **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
57292
|
* * If the VPN gateway is in the **updating** state, the SSL server is being created.
|
|
55429
57293
|
* * If the VPN gateway is in the **active** state, the SSL server is created.
|
|
55430
|
-
* * You cannot
|
|
57294
|
+
* * You cannot call the **CreateSslVpnServer** operation to create multiple SSL servers at a time for the same VPN gateway.
|
|
57295
|
+
* ### [](#)Prerequisites
|
|
57296
|
+
* A VPN gateway is created, and the SSL-VPN feature is enabled for the VPN gateway. For more information, see [CreateVpnGateway](~~2526913~~).
|
|
55431
57297
|
*
|
|
55432
57298
|
* @param request CreateSslVpnServerRequest
|
|
55433
57299
|
* @return CreateSslVpnServerResponse
|
|
@@ -56031,12 +57897,13 @@ export default class Client extends OpenApi {
|
|
|
56031
57897
|
}
|
|
56032
57898
|
|
|
56033
57899
|
/**
|
|
57900
|
+
* * The IPsec-VPN connection must be associated with a transit router. For more information, see [CreateTransitRouterVpnAttachment](~~468249~~).
|
|
56034
57901
|
* * 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**
|
|
57902
|
+
* * 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.
|
|
57903
|
+
* * **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.
|
|
57904
|
+
* * If the IPsec-VPN connection is in the **updating** state, the destination-based route is being created.
|
|
57905
|
+
* * If the IPsec-VPN connection is in the **attached** state, the destination-based route is created.
|
|
57906
|
+
* * You cannot repeatedly call **CreateVcoRouteEntry** within the specified period of time.
|
|
56040
57907
|
*
|
|
56041
57908
|
* @param request CreateVcoRouteEntryRequest
|
|
56042
57909
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -56107,12 +57974,13 @@ export default class Client extends OpenApi {
|
|
|
56107
57974
|
}
|
|
56108
57975
|
|
|
56109
57976
|
/**
|
|
57977
|
+
* * The IPsec-VPN connection must be associated with a transit router. For more information, see [CreateTransitRouterVpnAttachment](~~468249~~).
|
|
56110
57978
|
* * 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**
|
|
57979
|
+
* * 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.
|
|
57980
|
+
* * **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.
|
|
57981
|
+
* * If the IPsec-VPN connection is in the **updating** state, the destination-based route is being created.
|
|
57982
|
+
* * If the IPsec-VPN connection is in the **attached** state, the destination-based route is created.
|
|
57983
|
+
* * You cannot repeatedly call **CreateVcoRouteEntry** within the specified period of time.
|
|
56116
57984
|
*
|
|
56117
57985
|
* @param request CreateVcoRouteEntryRequest
|
|
56118
57986
|
* @return CreateVcoRouteEntryResponse
|
|
@@ -56123,7 +57991,7 @@ export default class Client extends OpenApi {
|
|
|
56123
57991
|
}
|
|
56124
57992
|
|
|
56125
57993
|
/**
|
|
56126
|
-
*
|
|
57994
|
+
* After you create a VBR, the VBR is in the **active** state.
|
|
56127
57995
|
*
|
|
56128
57996
|
* @param request CreateVirtualBorderRouterRequest
|
|
56129
57997
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -56238,7 +58106,7 @@ export default class Client extends OpenApi {
|
|
|
56238
58106
|
}
|
|
56239
58107
|
|
|
56240
58108
|
/**
|
|
56241
|
-
*
|
|
58109
|
+
* After you create a VBR, the VBR is in the **active** state.
|
|
56242
58110
|
*
|
|
56243
58111
|
* @param request CreateVirtualBorderRouterRequest
|
|
56244
58112
|
* @return CreateVirtualBorderRouterResponse
|
|
@@ -56460,6 +58328,16 @@ export default class Client extends OpenApi {
|
|
|
56460
58328
|
return await this.createVpcWithOptions(request, runtime);
|
|
56461
58329
|
}
|
|
56462
58330
|
|
|
58331
|
+
/**
|
|
58332
|
+
* * **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.
|
|
58333
|
+
* * If the gateway endpoint is in the **Creating** state, the gateway endpoint is being created.
|
|
58334
|
+
* * If the gateway endpoint is in the **Created** state, the gateway endpoint is created.
|
|
58335
|
+
* * You cannot repeatedly call the **CreateVpcGatewayEndpoint** operation for the same endpoint service within the specified period of time.
|
|
58336
|
+
*
|
|
58337
|
+
* @param request CreateVpcGatewayEndpointRequest
|
|
58338
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
58339
|
+
* @return CreateVpcGatewayEndpointResponse
|
|
58340
|
+
*/
|
|
56463
58341
|
async createVpcGatewayEndpointWithOptions(request: CreateVpcGatewayEndpointRequest, runtime: $Util.RuntimeOptions): Promise<CreateVpcGatewayEndpointResponse> {
|
|
56464
58342
|
Util.validateModel(request);
|
|
56465
58343
|
let query = { };
|
|
@@ -56536,13 +58414,22 @@ export default class Client extends OpenApi {
|
|
|
56536
58414
|
return $tea.cast<CreateVpcGatewayEndpointResponse>(await this.callApi(params, req, runtime), new CreateVpcGatewayEndpointResponse({}));
|
|
56537
58415
|
}
|
|
56538
58416
|
|
|
58417
|
+
/**
|
|
58418
|
+
* * **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.
|
|
58419
|
+
* * If the gateway endpoint is in the **Creating** state, the gateway endpoint is being created.
|
|
58420
|
+
* * If the gateway endpoint is in the **Created** state, the gateway endpoint is created.
|
|
58421
|
+
* * You cannot repeatedly call the **CreateVpcGatewayEndpoint** operation for the same endpoint service within the specified period of time.
|
|
58422
|
+
*
|
|
58423
|
+
* @param request CreateVpcGatewayEndpointRequest
|
|
58424
|
+
* @return CreateVpcGatewayEndpointResponse
|
|
58425
|
+
*/
|
|
56539
58426
|
async createVpcGatewayEndpoint(request: CreateVpcGatewayEndpointRequest): Promise<CreateVpcGatewayEndpointResponse> {
|
|
56540
58427
|
let runtime = new $Util.RuntimeOptions({ });
|
|
56541
58428
|
return await this.createVpcGatewayEndpointWithOptions(request, runtime);
|
|
56542
58429
|
}
|
|
56543
58430
|
|
|
56544
58431
|
/**
|
|
56545
|
-
* You cannot repeatedly call the **CreateVpcPrefixList** operation
|
|
58432
|
+
* You cannot repeatedly call the **CreateVpcPrefixList** operation within the specified period of time.
|
|
56546
58433
|
*
|
|
56547
58434
|
* @param request CreateVpcPrefixListRequest
|
|
56548
58435
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -56625,7 +58512,7 @@ export default class Client extends OpenApi {
|
|
|
56625
58512
|
}
|
|
56626
58513
|
|
|
56627
58514
|
/**
|
|
56628
|
-
* You cannot repeatedly call the **CreateVpcPrefixList** operation
|
|
58515
|
+
* You cannot repeatedly call the **CreateVpcPrefixList** operation within the specified period of time.
|
|
56629
58516
|
*
|
|
56630
58517
|
* @param request CreateVpcPrefixListRequest
|
|
56631
58518
|
* @return CreateVpcPrefixListResponse
|
|
@@ -57572,7 +59459,194 @@ export default class Client extends OpenApi {
|
|
|
57572
59459
|
query: OpenApiUtil.query(query),
|
|
57573
59460
|
});
|
|
57574
59461
|
let params = new $OpenApi.Params({
|
|
57575
|
-
action: "DeleteBgpPeer",
|
|
59462
|
+
action: "DeleteBgpPeer",
|
|
59463
|
+
version: "2016-04-28",
|
|
59464
|
+
protocol: "HTTPS",
|
|
59465
|
+
pathname: "/",
|
|
59466
|
+
method: "POST",
|
|
59467
|
+
authType: "AK",
|
|
59468
|
+
style: "RPC",
|
|
59469
|
+
reqBodyType: "formData",
|
|
59470
|
+
bodyType: "json",
|
|
59471
|
+
});
|
|
59472
|
+
return $tea.cast<DeleteBgpPeerResponse>(await this.callApi(params, req, runtime), new DeleteBgpPeerResponse({}));
|
|
59473
|
+
}
|
|
59474
|
+
|
|
59475
|
+
async deleteBgpPeer(request: DeleteBgpPeerRequest): Promise<DeleteBgpPeerResponse> {
|
|
59476
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
59477
|
+
return await this.deleteBgpPeerWithOptions(request, runtime);
|
|
59478
|
+
}
|
|
59479
|
+
|
|
59480
|
+
/**
|
|
59481
|
+
* You cannot repeatedly call the **DeleteCommonBandwidthPackage** operation to delete an Internet Shared Bandwidth instance within the specified period of time.
|
|
59482
|
+
*
|
|
59483
|
+
* @param request DeleteCommonBandwidthPackageRequest
|
|
59484
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
59485
|
+
* @return DeleteCommonBandwidthPackageResponse
|
|
59486
|
+
*/
|
|
59487
|
+
async deleteCommonBandwidthPackageWithOptions(request: DeleteCommonBandwidthPackageRequest, runtime: $Util.RuntimeOptions): Promise<DeleteCommonBandwidthPackageResponse> {
|
|
59488
|
+
Util.validateModel(request);
|
|
59489
|
+
let query = { };
|
|
59490
|
+
if (!Util.isUnset(request.bandwidthPackageId)) {
|
|
59491
|
+
query["BandwidthPackageId"] = request.bandwidthPackageId;
|
|
59492
|
+
}
|
|
59493
|
+
|
|
59494
|
+
if (!Util.isUnset(request.force)) {
|
|
59495
|
+
query["Force"] = request.force;
|
|
59496
|
+
}
|
|
59497
|
+
|
|
59498
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
59499
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
59500
|
+
}
|
|
59501
|
+
|
|
59502
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
59503
|
+
query["OwnerId"] = request.ownerId;
|
|
59504
|
+
}
|
|
59505
|
+
|
|
59506
|
+
if (!Util.isUnset(request.regionId)) {
|
|
59507
|
+
query["RegionId"] = request.regionId;
|
|
59508
|
+
}
|
|
59509
|
+
|
|
59510
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
59511
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
59512
|
+
}
|
|
59513
|
+
|
|
59514
|
+
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
59515
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
59516
|
+
}
|
|
59517
|
+
|
|
59518
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
59519
|
+
query: OpenApiUtil.query(query),
|
|
59520
|
+
});
|
|
59521
|
+
let params = new $OpenApi.Params({
|
|
59522
|
+
action: "DeleteCommonBandwidthPackage",
|
|
59523
|
+
version: "2016-04-28",
|
|
59524
|
+
protocol: "HTTPS",
|
|
59525
|
+
pathname: "/",
|
|
59526
|
+
method: "POST",
|
|
59527
|
+
authType: "AK",
|
|
59528
|
+
style: "RPC",
|
|
59529
|
+
reqBodyType: "formData",
|
|
59530
|
+
bodyType: "json",
|
|
59531
|
+
});
|
|
59532
|
+
return $tea.cast<DeleteCommonBandwidthPackageResponse>(await this.callApi(params, req, runtime), new DeleteCommonBandwidthPackageResponse({}));
|
|
59533
|
+
}
|
|
59534
|
+
|
|
59535
|
+
/**
|
|
59536
|
+
* You cannot repeatedly call the **DeleteCommonBandwidthPackage** operation to delete an Internet Shared Bandwidth instance within the specified period of time.
|
|
59537
|
+
*
|
|
59538
|
+
* @param request DeleteCommonBandwidthPackageRequest
|
|
59539
|
+
* @return DeleteCommonBandwidthPackageResponse
|
|
59540
|
+
*/
|
|
59541
|
+
async deleteCommonBandwidthPackage(request: DeleteCommonBandwidthPackageRequest): Promise<DeleteCommonBandwidthPackageResponse> {
|
|
59542
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
59543
|
+
return await this.deleteCommonBandwidthPackageWithOptions(request, runtime);
|
|
59544
|
+
}
|
|
59545
|
+
|
|
59546
|
+
async deleteCustomerGatewayWithOptions(request: DeleteCustomerGatewayRequest, runtime: $Util.RuntimeOptions): Promise<DeleteCustomerGatewayResponse> {
|
|
59547
|
+
Util.validateModel(request);
|
|
59548
|
+
let query = { };
|
|
59549
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
59550
|
+
query["ClientToken"] = request.clientToken;
|
|
59551
|
+
}
|
|
59552
|
+
|
|
59553
|
+
if (!Util.isUnset(request.customerGatewayId)) {
|
|
59554
|
+
query["CustomerGatewayId"] = request.customerGatewayId;
|
|
59555
|
+
}
|
|
59556
|
+
|
|
59557
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
59558
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
59559
|
+
}
|
|
59560
|
+
|
|
59561
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
59562
|
+
query["OwnerId"] = request.ownerId;
|
|
59563
|
+
}
|
|
59564
|
+
|
|
59565
|
+
if (!Util.isUnset(request.regionId)) {
|
|
59566
|
+
query["RegionId"] = request.regionId;
|
|
59567
|
+
}
|
|
59568
|
+
|
|
59569
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
59570
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
59571
|
+
}
|
|
59572
|
+
|
|
59573
|
+
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
59574
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
59575
|
+
}
|
|
59576
|
+
|
|
59577
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
59578
|
+
query: OpenApiUtil.query(query),
|
|
59579
|
+
});
|
|
59580
|
+
let params = new $OpenApi.Params({
|
|
59581
|
+
action: "DeleteCustomerGateway",
|
|
59582
|
+
version: "2016-04-28",
|
|
59583
|
+
protocol: "HTTPS",
|
|
59584
|
+
pathname: "/",
|
|
59585
|
+
method: "POST",
|
|
59586
|
+
authType: "AK",
|
|
59587
|
+
style: "RPC",
|
|
59588
|
+
reqBodyType: "formData",
|
|
59589
|
+
bodyType: "json",
|
|
59590
|
+
});
|
|
59591
|
+
return $tea.cast<DeleteCustomerGatewayResponse>(await this.callApi(params, req, runtime), new DeleteCustomerGatewayResponse({}));
|
|
59592
|
+
}
|
|
59593
|
+
|
|
59594
|
+
async deleteCustomerGateway(request: DeleteCustomerGatewayRequest): Promise<DeleteCustomerGatewayResponse> {
|
|
59595
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
59596
|
+
return await this.deleteCustomerGatewayWithOptions(request, runtime);
|
|
59597
|
+
}
|
|
59598
|
+
|
|
59599
|
+
/**
|
|
59600
|
+
* ## [](#)Description
|
|
59601
|
+
* * **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.
|
|
59602
|
+
* * If the DHCP options set is in the **Deleting** state, the DHCP options set is being deleted.
|
|
59603
|
+
* * If you cannot query the DHCP options set, the DHCP options set is deleted.
|
|
59604
|
+
* * You cannot repeatedly call the **DeleteDhcpOptionsSet** operation to delete a DHCP options set within the specified period of time.
|
|
59605
|
+
*
|
|
59606
|
+
* @param request DeleteDhcpOptionsSetRequest
|
|
59607
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
59608
|
+
* @return DeleteDhcpOptionsSetResponse
|
|
59609
|
+
*/
|
|
59610
|
+
async deleteDhcpOptionsSetWithOptions(request: DeleteDhcpOptionsSetRequest, runtime: $Util.RuntimeOptions): Promise<DeleteDhcpOptionsSetResponse> {
|
|
59611
|
+
Util.validateModel(request);
|
|
59612
|
+
let query = { };
|
|
59613
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
59614
|
+
query["ClientToken"] = request.clientToken;
|
|
59615
|
+
}
|
|
59616
|
+
|
|
59617
|
+
if (!Util.isUnset(request.dhcpOptionsSetId)) {
|
|
59618
|
+
query["DhcpOptionsSetId"] = request.dhcpOptionsSetId;
|
|
59619
|
+
}
|
|
59620
|
+
|
|
59621
|
+
if (!Util.isUnset(request.dryRun)) {
|
|
59622
|
+
query["DryRun"] = request.dryRun;
|
|
59623
|
+
}
|
|
59624
|
+
|
|
59625
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
59626
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
59627
|
+
}
|
|
59628
|
+
|
|
59629
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
59630
|
+
query["OwnerId"] = request.ownerId;
|
|
59631
|
+
}
|
|
59632
|
+
|
|
59633
|
+
if (!Util.isUnset(request.regionId)) {
|
|
59634
|
+
query["RegionId"] = request.regionId;
|
|
59635
|
+
}
|
|
59636
|
+
|
|
59637
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
59638
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
59639
|
+
}
|
|
59640
|
+
|
|
59641
|
+
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
59642
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
59643
|
+
}
|
|
59644
|
+
|
|
59645
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
59646
|
+
query: OpenApiUtil.query(query),
|
|
59647
|
+
});
|
|
59648
|
+
let params = new $OpenApi.Params({
|
|
59649
|
+
action: "DeleteDhcpOptionsSet",
|
|
57576
59650
|
version: "2016-04-28",
|
|
57577
59651
|
protocol: "HTTPS",
|
|
57578
59652
|
pathname: "/",
|
|
@@ -57582,30 +59656,33 @@ export default class Client extends OpenApi {
|
|
|
57582
59656
|
reqBodyType: "formData",
|
|
57583
59657
|
bodyType: "json",
|
|
57584
59658
|
});
|
|
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);
|
|
59659
|
+
return $tea.cast<DeleteDhcpOptionsSetResponse>(await this.callApi(params, req, runtime), new DeleteDhcpOptionsSetResponse({}));
|
|
57591
59660
|
}
|
|
57592
59661
|
|
|
57593
59662
|
/**
|
|
57594
|
-
*
|
|
59663
|
+
* ## [](#)Description
|
|
59664
|
+
* * **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.
|
|
59665
|
+
* * If the DHCP options set is in the **Deleting** state, the DHCP options set is being deleted.
|
|
59666
|
+
* * If you cannot query the DHCP options set, the DHCP options set is deleted.
|
|
59667
|
+
* * You cannot repeatedly call the **DeleteDhcpOptionsSet** operation to delete a DHCP options set within the specified period of time.
|
|
57595
59668
|
*
|
|
57596
|
-
* @param request
|
|
57597
|
-
* @
|
|
57598
|
-
* @return DeleteCommonBandwidthPackageResponse
|
|
59669
|
+
* @param request DeleteDhcpOptionsSetRequest
|
|
59670
|
+
* @return DeleteDhcpOptionsSetResponse
|
|
57599
59671
|
*/
|
|
57600
|
-
async
|
|
59672
|
+
async deleteDhcpOptionsSet(request: DeleteDhcpOptionsSetRequest): Promise<DeleteDhcpOptionsSetResponse> {
|
|
59673
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
59674
|
+
return await this.deleteDhcpOptionsSetWithOptions(request, runtime);
|
|
59675
|
+
}
|
|
59676
|
+
|
|
59677
|
+
async deleteExpressConnectTrafficQosWithOptions(request: DeleteExpressConnectTrafficQosRequest, runtime: $Util.RuntimeOptions): Promise<DeleteExpressConnectTrafficQosResponse> {
|
|
57601
59678
|
Util.validateModel(request);
|
|
57602
59679
|
let query = { };
|
|
57603
|
-
if (!Util.isUnset(request.
|
|
57604
|
-
query["
|
|
59680
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
59681
|
+
query["ClientToken"] = request.clientToken;
|
|
57605
59682
|
}
|
|
57606
59683
|
|
|
57607
|
-
if (!Util.isUnset(request.
|
|
57608
|
-
query["
|
|
59684
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
59685
|
+
query["ClientToken"] = request.clientToken;
|
|
57609
59686
|
}
|
|
57610
59687
|
|
|
57611
59688
|
if (!Util.isUnset(request.ownerAccount)) {
|
|
@@ -57616,6 +59693,10 @@ export default class Client extends OpenApi {
|
|
|
57616
59693
|
query["OwnerId"] = request.ownerId;
|
|
57617
59694
|
}
|
|
57618
59695
|
|
|
59696
|
+
if (!Util.isUnset(request.qosId)) {
|
|
59697
|
+
query["QosId"] = request.qosId;
|
|
59698
|
+
}
|
|
59699
|
+
|
|
57619
59700
|
if (!Util.isUnset(request.regionId)) {
|
|
57620
59701
|
query["RegionId"] = request.regionId;
|
|
57621
59702
|
}
|
|
@@ -57624,15 +59705,11 @@ export default class Client extends OpenApi {
|
|
|
57624
59705
|
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
57625
59706
|
}
|
|
57626
59707
|
|
|
57627
|
-
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
57628
|
-
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
57629
|
-
}
|
|
57630
|
-
|
|
57631
59708
|
let req = new $OpenApi.OpenApiRequest({
|
|
57632
59709
|
query: OpenApiUtil.query(query),
|
|
57633
59710
|
});
|
|
57634
59711
|
let params = new $OpenApi.Params({
|
|
57635
|
-
action: "
|
|
59712
|
+
action: "DeleteExpressConnectTrafficQos",
|
|
57636
59713
|
version: "2016-04-28",
|
|
57637
59714
|
protocol: "HTTPS",
|
|
57638
59715
|
pathname: "/",
|
|
@@ -57642,29 +59719,23 @@ export default class Client extends OpenApi {
|
|
|
57642
59719
|
reqBodyType: "formData",
|
|
57643
59720
|
bodyType: "json",
|
|
57644
59721
|
});
|
|
57645
|
-
return $tea.cast<
|
|
59722
|
+
return $tea.cast<DeleteExpressConnectTrafficQosResponse>(await this.callApi(params, req, runtime), new DeleteExpressConnectTrafficQosResponse({}));
|
|
57646
59723
|
}
|
|
57647
59724
|
|
|
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> {
|
|
59725
|
+
async deleteExpressConnectTrafficQos(request: DeleteExpressConnectTrafficQosRequest): Promise<DeleteExpressConnectTrafficQosResponse> {
|
|
57655
59726
|
let runtime = new $Util.RuntimeOptions({ });
|
|
57656
|
-
return await this.
|
|
59727
|
+
return await this.deleteExpressConnectTrafficQosWithOptions(request, runtime);
|
|
57657
59728
|
}
|
|
57658
59729
|
|
|
57659
|
-
async
|
|
59730
|
+
async deleteExpressConnectTrafficQosQueueWithOptions(request: DeleteExpressConnectTrafficQosQueueRequest, runtime: $Util.RuntimeOptions): Promise<DeleteExpressConnectTrafficQosQueueResponse> {
|
|
57660
59731
|
Util.validateModel(request);
|
|
57661
59732
|
let query = { };
|
|
57662
59733
|
if (!Util.isUnset(request.clientToken)) {
|
|
57663
59734
|
query["ClientToken"] = request.clientToken;
|
|
57664
59735
|
}
|
|
57665
59736
|
|
|
57666
|
-
if (!Util.isUnset(request.
|
|
57667
|
-
query["
|
|
59737
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
59738
|
+
query["ClientToken"] = request.clientToken;
|
|
57668
59739
|
}
|
|
57669
59740
|
|
|
57670
59741
|
if (!Util.isUnset(request.ownerAccount)) {
|
|
@@ -57675,6 +59746,14 @@ export default class Client extends OpenApi {
|
|
|
57675
59746
|
query["OwnerId"] = request.ownerId;
|
|
57676
59747
|
}
|
|
57677
59748
|
|
|
59749
|
+
if (!Util.isUnset(request.qosId)) {
|
|
59750
|
+
query["QosId"] = request.qosId;
|
|
59751
|
+
}
|
|
59752
|
+
|
|
59753
|
+
if (!Util.isUnset(request.queueId)) {
|
|
59754
|
+
query["QueueId"] = request.queueId;
|
|
59755
|
+
}
|
|
59756
|
+
|
|
57678
59757
|
if (!Util.isUnset(request.regionId)) {
|
|
57679
59758
|
query["RegionId"] = request.regionId;
|
|
57680
59759
|
}
|
|
@@ -57683,15 +59762,11 @@ export default class Client extends OpenApi {
|
|
|
57683
59762
|
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
57684
59763
|
}
|
|
57685
59764
|
|
|
57686
|
-
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
57687
|
-
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
57688
|
-
}
|
|
57689
|
-
|
|
57690
59765
|
let req = new $OpenApi.OpenApiRequest({
|
|
57691
59766
|
query: OpenApiUtil.query(query),
|
|
57692
59767
|
});
|
|
57693
59768
|
let params = new $OpenApi.Params({
|
|
57694
|
-
action: "
|
|
59769
|
+
action: "DeleteExpressConnectTrafficQosQueue",
|
|
57695
59770
|
version: "2016-04-28",
|
|
57696
59771
|
protocol: "HTTPS",
|
|
57697
59772
|
pathname: "/",
|
|
@@ -57701,38 +59776,23 @@ export default class Client extends OpenApi {
|
|
|
57701
59776
|
reqBodyType: "formData",
|
|
57702
59777
|
bodyType: "json",
|
|
57703
59778
|
});
|
|
57704
|
-
return $tea.cast<
|
|
59779
|
+
return $tea.cast<DeleteExpressConnectTrafficQosQueueResponse>(await this.callApi(params, req, runtime), new DeleteExpressConnectTrafficQosQueueResponse({}));
|
|
57705
59780
|
}
|
|
57706
59781
|
|
|
57707
|
-
async
|
|
59782
|
+
async deleteExpressConnectTrafficQosQueue(request: DeleteExpressConnectTrafficQosQueueRequest): Promise<DeleteExpressConnectTrafficQosQueueResponse> {
|
|
57708
59783
|
let runtime = new $Util.RuntimeOptions({ });
|
|
57709
|
-
return await this.
|
|
59784
|
+
return await this.deleteExpressConnectTrafficQosQueueWithOptions(request, runtime);
|
|
57710
59785
|
}
|
|
57711
59786
|
|
|
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> {
|
|
59787
|
+
async deleteExpressConnectTrafficQosRuleWithOptions(request: DeleteExpressConnectTrafficQosRuleRequest, runtime: $Util.RuntimeOptions): Promise<DeleteExpressConnectTrafficQosRuleResponse> {
|
|
57724
59788
|
Util.validateModel(request);
|
|
57725
59789
|
let query = { };
|
|
57726
59790
|
if (!Util.isUnset(request.clientToken)) {
|
|
57727
59791
|
query["ClientToken"] = request.clientToken;
|
|
57728
59792
|
}
|
|
57729
59793
|
|
|
57730
|
-
if (!Util.isUnset(request.
|
|
57731
|
-
query["
|
|
57732
|
-
}
|
|
57733
|
-
|
|
57734
|
-
if (!Util.isUnset(request.dryRun)) {
|
|
57735
|
-
query["DryRun"] = request.dryRun;
|
|
59794
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
59795
|
+
query["ClientToken"] = request.clientToken;
|
|
57736
59796
|
}
|
|
57737
59797
|
|
|
57738
59798
|
if (!Util.isUnset(request.ownerAccount)) {
|
|
@@ -57743,6 +59803,14 @@ export default class Client extends OpenApi {
|
|
|
57743
59803
|
query["OwnerId"] = request.ownerId;
|
|
57744
59804
|
}
|
|
57745
59805
|
|
|
59806
|
+
if (!Util.isUnset(request.qosId)) {
|
|
59807
|
+
query["QosId"] = request.qosId;
|
|
59808
|
+
}
|
|
59809
|
+
|
|
59810
|
+
if (!Util.isUnset(request.queueId)) {
|
|
59811
|
+
query["QueueId"] = request.queueId;
|
|
59812
|
+
}
|
|
59813
|
+
|
|
57746
59814
|
if (!Util.isUnset(request.regionId)) {
|
|
57747
59815
|
query["RegionId"] = request.regionId;
|
|
57748
59816
|
}
|
|
@@ -57751,15 +59819,15 @@ export default class Client extends OpenApi {
|
|
|
57751
59819
|
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
57752
59820
|
}
|
|
57753
59821
|
|
|
57754
|
-
if (!Util.isUnset(request.
|
|
57755
|
-
query["
|
|
59822
|
+
if (!Util.isUnset(request.ruleId)) {
|
|
59823
|
+
query["RuleId"] = request.ruleId;
|
|
57756
59824
|
}
|
|
57757
59825
|
|
|
57758
59826
|
let req = new $OpenApi.OpenApiRequest({
|
|
57759
59827
|
query: OpenApiUtil.query(query),
|
|
57760
59828
|
});
|
|
57761
59829
|
let params = new $OpenApi.Params({
|
|
57762
|
-
action: "
|
|
59830
|
+
action: "DeleteExpressConnectTrafficQosRule",
|
|
57763
59831
|
version: "2016-04-28",
|
|
57764
59832
|
protocol: "HTTPS",
|
|
57765
59833
|
pathname: "/",
|
|
@@ -57769,22 +59837,12 @@ export default class Client extends OpenApi {
|
|
|
57769
59837
|
reqBodyType: "formData",
|
|
57770
59838
|
bodyType: "json",
|
|
57771
59839
|
});
|
|
57772
|
-
return $tea.cast<
|
|
59840
|
+
return $tea.cast<DeleteExpressConnectTrafficQosRuleResponse>(await this.callApi(params, req, runtime), new DeleteExpressConnectTrafficQosRuleResponse({}));
|
|
57773
59841
|
}
|
|
57774
59842
|
|
|
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> {
|
|
59843
|
+
async deleteExpressConnectTrafficQosRule(request: DeleteExpressConnectTrafficQosRuleRequest): Promise<DeleteExpressConnectTrafficQosRuleResponse> {
|
|
57786
59844
|
let runtime = new $Util.RuntimeOptions({ });
|
|
57787
|
-
return await this.
|
|
59845
|
+
return await this.deleteExpressConnectTrafficQosRuleWithOptions(request, runtime);
|
|
57788
59846
|
}
|
|
57789
59847
|
|
|
57790
59848
|
async deleteFailoverTestJobWithOptions(request: DeleteFailoverTestJobRequest, runtime: $Util.RuntimeOptions): Promise<DeleteFailoverTestJobResponse> {
|
|
@@ -60372,7 +62430,7 @@ export default class Client extends OpenApi {
|
|
|
60372
62430
|
* Before you call this operation, take note of the following limits:
|
|
60373
62431
|
* * Before you delete a VBR, you must delete all router interfaces of the VBR.
|
|
60374
62432
|
* * You can delete only a VBR in the **unconfirmed**, **active**, or **terminated** state.
|
|
60375
|
-
* *
|
|
62433
|
+
* * 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
62434
|
*
|
|
60377
62435
|
* @param request DeleteVirtualBorderRouterRequest
|
|
60378
62436
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -60430,7 +62488,7 @@ export default class Client extends OpenApi {
|
|
|
60430
62488
|
* Before you call this operation, take note of the following limits:
|
|
60431
62489
|
* * Before you delete a VBR, you must delete all router interfaces of the VBR.
|
|
60432
62490
|
* * You can delete only a VBR in the **unconfirmed**, **active**, or **terminated** state.
|
|
60433
|
-
* *
|
|
62491
|
+
* * 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
62492
|
*
|
|
60435
62493
|
* @param request DeleteVirtualBorderRouterRequest
|
|
60436
62494
|
* @return DeleteVirtualBorderRouterResponse
|
|
@@ -60650,8 +62708,8 @@ export default class Client extends OpenApi {
|
|
|
60650
62708
|
}
|
|
60651
62709
|
|
|
60652
62710
|
/**
|
|
60653
|
-
* * If
|
|
60654
|
-
* * If
|
|
62711
|
+
* * 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~~).
|
|
62712
|
+
* * If an IPsec-VPN connection is not associated with a resource, you can call `DeleteVpnAttachment` to directly delete the IPsec-VPN connection.
|
|
60655
62713
|
*
|
|
60656
62714
|
* @param request DeleteVpnAttachmentRequest
|
|
60657
62715
|
* @param runtime runtime options for this request RuntimeOptions
|
|
@@ -60702,8 +62760,8 @@ export default class Client extends OpenApi {
|
|
|
60702
62760
|
}
|
|
60703
62761
|
|
|
60704
62762
|
/**
|
|
60705
|
-
* * If
|
|
60706
|
-
* * If
|
|
62763
|
+
* * 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~~).
|
|
62764
|
+
* * If an IPsec-VPN connection is not associated with a resource, you can call `DeleteVpnAttachment` to directly delete the IPsec-VPN connection.
|
|
60707
62765
|
*
|
|
60708
62766
|
* @param request DeleteVpnAttachmentRequest
|
|
60709
62767
|
* @return DeleteVpnAttachmentResponse
|
|
@@ -61111,6 +63169,63 @@ export default class Client extends OpenApi {
|
|
|
61111
63169
|
return await this.deletionProtectionWithOptions(request, runtime);
|
|
61112
63170
|
}
|
|
61113
63171
|
|
|
63172
|
+
async describe95TrafficWithOptions(request: Describe95TrafficRequest, runtime: $Util.RuntimeOptions): Promise<Describe95TrafficResponse> {
|
|
63173
|
+
Util.validateModel(request);
|
|
63174
|
+
let query = { };
|
|
63175
|
+
if (!Util.isUnset(request.day)) {
|
|
63176
|
+
query["Day"] = request.day;
|
|
63177
|
+
}
|
|
63178
|
+
|
|
63179
|
+
if (!Util.isUnset(request.instanceId)) {
|
|
63180
|
+
query["InstanceId"] = request.instanceId;
|
|
63181
|
+
}
|
|
63182
|
+
|
|
63183
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
63184
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
63185
|
+
}
|
|
63186
|
+
|
|
63187
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
63188
|
+
query["OwnerId"] = request.ownerId;
|
|
63189
|
+
}
|
|
63190
|
+
|
|
63191
|
+
if (!Util.isUnset(request.regionId)) {
|
|
63192
|
+
query["RegionId"] = request.regionId;
|
|
63193
|
+
}
|
|
63194
|
+
|
|
63195
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
63196
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
63197
|
+
}
|
|
63198
|
+
|
|
63199
|
+
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
63200
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
63201
|
+
}
|
|
63202
|
+
|
|
63203
|
+
if (!Util.isUnset(request.resourceType)) {
|
|
63204
|
+
query["ResourceType"] = request.resourceType;
|
|
63205
|
+
}
|
|
63206
|
+
|
|
63207
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
63208
|
+
query: OpenApiUtil.query(query),
|
|
63209
|
+
});
|
|
63210
|
+
let params = new $OpenApi.Params({
|
|
63211
|
+
action: "Describe95Traffic",
|
|
63212
|
+
version: "2016-04-28",
|
|
63213
|
+
protocol: "HTTPS",
|
|
63214
|
+
pathname: "/",
|
|
63215
|
+
method: "POST",
|
|
63216
|
+
authType: "AK",
|
|
63217
|
+
style: "RPC",
|
|
63218
|
+
reqBodyType: "formData",
|
|
63219
|
+
bodyType: "json",
|
|
63220
|
+
});
|
|
63221
|
+
return $tea.cast<Describe95TrafficResponse>(await this.callApi(params, req, runtime), new Describe95TrafficResponse({}));
|
|
63222
|
+
}
|
|
63223
|
+
|
|
63224
|
+
async describe95Traffic(request: Describe95TrafficRequest): Promise<Describe95TrafficResponse> {
|
|
63225
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
63226
|
+
return await this.describe95TrafficWithOptions(request, runtime);
|
|
63227
|
+
}
|
|
63228
|
+
|
|
61114
63229
|
async describeAccessPointsWithOptions(request: DescribeAccessPointsRequest, runtime: $Util.RuntimeOptions): Promise<DescribeAccessPointsResponse> {
|
|
61115
63230
|
Util.validateModel(request);
|
|
61116
63231
|
let query = { };
|
|
@@ -61689,6 +63804,10 @@ export default class Client extends OpenApi {
|
|
|
61689
63804
|
query["SegmentInstanceId"] = request.segmentInstanceId;
|
|
61690
63805
|
}
|
|
61691
63806
|
|
|
63807
|
+
if (!Util.isUnset(request.serviceManaged)) {
|
|
63808
|
+
query["ServiceManaged"] = request.serviceManaged;
|
|
63809
|
+
}
|
|
63810
|
+
|
|
61692
63811
|
if (!Util.isUnset(request.status)) {
|
|
61693
63812
|
query["Status"] = request.status;
|
|
61694
63813
|
}
|
|
@@ -61930,6 +64049,197 @@ export default class Client extends OpenApi {
|
|
|
61930
64049
|
return await this.describeEipSegmentWithOptions(request, runtime);
|
|
61931
64050
|
}
|
|
61932
64051
|
|
|
64052
|
+
async describeExpressConnectTrafficQosWithOptions(request: DescribeExpressConnectTrafficQosRequest, runtime: $Util.RuntimeOptions): Promise<DescribeExpressConnectTrafficQosResponse> {
|
|
64053
|
+
Util.validateModel(request);
|
|
64054
|
+
let query = { };
|
|
64055
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
64056
|
+
query["ClientToken"] = request.clientToken;
|
|
64057
|
+
}
|
|
64058
|
+
|
|
64059
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
64060
|
+
query["ClientToken"] = request.clientToken;
|
|
64061
|
+
}
|
|
64062
|
+
|
|
64063
|
+
if (!Util.isUnset(request.maxResults)) {
|
|
64064
|
+
query["MaxResults"] = request.maxResults;
|
|
64065
|
+
}
|
|
64066
|
+
|
|
64067
|
+
if (!Util.isUnset(request.nextToken)) {
|
|
64068
|
+
query["NextToken"] = request.nextToken;
|
|
64069
|
+
}
|
|
64070
|
+
|
|
64071
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
64072
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
64073
|
+
}
|
|
64074
|
+
|
|
64075
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
64076
|
+
query["OwnerId"] = request.ownerId;
|
|
64077
|
+
}
|
|
64078
|
+
|
|
64079
|
+
if (!Util.isUnset(request.qosIdList)) {
|
|
64080
|
+
query["QosIdList"] = request.qosIdList;
|
|
64081
|
+
}
|
|
64082
|
+
|
|
64083
|
+
if (!Util.isUnset(request.qosNameList)) {
|
|
64084
|
+
query["QosNameList"] = request.qosNameList;
|
|
64085
|
+
}
|
|
64086
|
+
|
|
64087
|
+
if (!Util.isUnset(request.regionId)) {
|
|
64088
|
+
query["RegionId"] = request.regionId;
|
|
64089
|
+
}
|
|
64090
|
+
|
|
64091
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
64092
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
64093
|
+
}
|
|
64094
|
+
|
|
64095
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
64096
|
+
query: OpenApiUtil.query(query),
|
|
64097
|
+
});
|
|
64098
|
+
let params = new $OpenApi.Params({
|
|
64099
|
+
action: "DescribeExpressConnectTrafficQos",
|
|
64100
|
+
version: "2016-04-28",
|
|
64101
|
+
protocol: "HTTPS",
|
|
64102
|
+
pathname: "/",
|
|
64103
|
+
method: "POST",
|
|
64104
|
+
authType: "AK",
|
|
64105
|
+
style: "RPC",
|
|
64106
|
+
reqBodyType: "formData",
|
|
64107
|
+
bodyType: "json",
|
|
64108
|
+
});
|
|
64109
|
+
return $tea.cast<DescribeExpressConnectTrafficQosResponse>(await this.callApi(params, req, runtime), new DescribeExpressConnectTrafficQosResponse({}));
|
|
64110
|
+
}
|
|
64111
|
+
|
|
64112
|
+
async describeExpressConnectTrafficQos(request: DescribeExpressConnectTrafficQosRequest): Promise<DescribeExpressConnectTrafficQosResponse> {
|
|
64113
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
64114
|
+
return await this.describeExpressConnectTrafficQosWithOptions(request, runtime);
|
|
64115
|
+
}
|
|
64116
|
+
|
|
64117
|
+
async describeExpressConnectTrafficQosQueueWithOptions(request: DescribeExpressConnectTrafficQosQueueRequest, runtime: $Util.RuntimeOptions): Promise<DescribeExpressConnectTrafficQosQueueResponse> {
|
|
64118
|
+
Util.validateModel(request);
|
|
64119
|
+
let query = { };
|
|
64120
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
64121
|
+
query["ClientToken"] = request.clientToken;
|
|
64122
|
+
}
|
|
64123
|
+
|
|
64124
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
64125
|
+
query["ClientToken"] = request.clientToken;
|
|
64126
|
+
}
|
|
64127
|
+
|
|
64128
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
64129
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
64130
|
+
}
|
|
64131
|
+
|
|
64132
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
64133
|
+
query["OwnerId"] = request.ownerId;
|
|
64134
|
+
}
|
|
64135
|
+
|
|
64136
|
+
if (!Util.isUnset(request.qosId)) {
|
|
64137
|
+
query["QosId"] = request.qosId;
|
|
64138
|
+
}
|
|
64139
|
+
|
|
64140
|
+
if (!Util.isUnset(request.queueIdList)) {
|
|
64141
|
+
query["QueueIdList"] = request.queueIdList;
|
|
64142
|
+
}
|
|
64143
|
+
|
|
64144
|
+
if (!Util.isUnset(request.queueNameList)) {
|
|
64145
|
+
query["QueueNameList"] = request.queueNameList;
|
|
64146
|
+
}
|
|
64147
|
+
|
|
64148
|
+
if (!Util.isUnset(request.regionId)) {
|
|
64149
|
+
query["RegionId"] = request.regionId;
|
|
64150
|
+
}
|
|
64151
|
+
|
|
64152
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
64153
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
64154
|
+
}
|
|
64155
|
+
|
|
64156
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
64157
|
+
query: OpenApiUtil.query(query),
|
|
64158
|
+
});
|
|
64159
|
+
let params = new $OpenApi.Params({
|
|
64160
|
+
action: "DescribeExpressConnectTrafficQosQueue",
|
|
64161
|
+
version: "2016-04-28",
|
|
64162
|
+
protocol: "HTTPS",
|
|
64163
|
+
pathname: "/",
|
|
64164
|
+
method: "POST",
|
|
64165
|
+
authType: "AK",
|
|
64166
|
+
style: "RPC",
|
|
64167
|
+
reqBodyType: "formData",
|
|
64168
|
+
bodyType: "json",
|
|
64169
|
+
});
|
|
64170
|
+
return $tea.cast<DescribeExpressConnectTrafficQosQueueResponse>(await this.callApi(params, req, runtime), new DescribeExpressConnectTrafficQosQueueResponse({}));
|
|
64171
|
+
}
|
|
64172
|
+
|
|
64173
|
+
async describeExpressConnectTrafficQosQueue(request: DescribeExpressConnectTrafficQosQueueRequest): Promise<DescribeExpressConnectTrafficQosQueueResponse> {
|
|
64174
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
64175
|
+
return await this.describeExpressConnectTrafficQosQueueWithOptions(request, runtime);
|
|
64176
|
+
}
|
|
64177
|
+
|
|
64178
|
+
async describeExpressConnectTrafficQosRuleWithOptions(request: DescribeExpressConnectTrafficQosRuleRequest, runtime: $Util.RuntimeOptions): Promise<DescribeExpressConnectTrafficQosRuleResponse> {
|
|
64179
|
+
Util.validateModel(request);
|
|
64180
|
+
let query = { };
|
|
64181
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
64182
|
+
query["ClientToken"] = request.clientToken;
|
|
64183
|
+
}
|
|
64184
|
+
|
|
64185
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
64186
|
+
query["ClientToken"] = request.clientToken;
|
|
64187
|
+
}
|
|
64188
|
+
|
|
64189
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
64190
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
64191
|
+
}
|
|
64192
|
+
|
|
64193
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
64194
|
+
query["OwnerId"] = request.ownerId;
|
|
64195
|
+
}
|
|
64196
|
+
|
|
64197
|
+
if (!Util.isUnset(request.qosId)) {
|
|
64198
|
+
query["QosId"] = request.qosId;
|
|
64199
|
+
}
|
|
64200
|
+
|
|
64201
|
+
if (!Util.isUnset(request.queueId)) {
|
|
64202
|
+
query["QueueId"] = request.queueId;
|
|
64203
|
+
}
|
|
64204
|
+
|
|
64205
|
+
if (!Util.isUnset(request.regionId)) {
|
|
64206
|
+
query["RegionId"] = request.regionId;
|
|
64207
|
+
}
|
|
64208
|
+
|
|
64209
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
64210
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
64211
|
+
}
|
|
64212
|
+
|
|
64213
|
+
if (!Util.isUnset(request.ruleIdList)) {
|
|
64214
|
+
query["RuleIdList"] = request.ruleIdList;
|
|
64215
|
+
}
|
|
64216
|
+
|
|
64217
|
+
if (!Util.isUnset(request.ruleNameList)) {
|
|
64218
|
+
query["RuleNameList"] = request.ruleNameList;
|
|
64219
|
+
}
|
|
64220
|
+
|
|
64221
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
64222
|
+
query: OpenApiUtil.query(query),
|
|
64223
|
+
});
|
|
64224
|
+
let params = new $OpenApi.Params({
|
|
64225
|
+
action: "DescribeExpressConnectTrafficQosRule",
|
|
64226
|
+
version: "2016-04-28",
|
|
64227
|
+
protocol: "HTTPS",
|
|
64228
|
+
pathname: "/",
|
|
64229
|
+
method: "POST",
|
|
64230
|
+
authType: "AK",
|
|
64231
|
+
style: "RPC",
|
|
64232
|
+
reqBodyType: "formData",
|
|
64233
|
+
bodyType: "json",
|
|
64234
|
+
});
|
|
64235
|
+
return $tea.cast<DescribeExpressConnectTrafficQosRuleResponse>(await this.callApi(params, req, runtime), new DescribeExpressConnectTrafficQosRuleResponse({}));
|
|
64236
|
+
}
|
|
64237
|
+
|
|
64238
|
+
async describeExpressConnectTrafficQosRule(request: DescribeExpressConnectTrafficQosRuleRequest): Promise<DescribeExpressConnectTrafficQosRuleResponse> {
|
|
64239
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
64240
|
+
return await this.describeExpressConnectTrafficQosRuleWithOptions(request, runtime);
|
|
64241
|
+
}
|
|
64242
|
+
|
|
61933
64243
|
async describeFailoverTestJobWithOptions(request: DescribeFailoverTestJobRequest, runtime: $Util.RuntimeOptions): Promise<DescribeFailoverTestJobResponse> {
|
|
61934
64244
|
Util.validateModel(request);
|
|
61935
64245
|
let query = { };
|
|
@@ -62926,6 +65236,10 @@ export default class Client extends OpenApi {
|
|
|
62926
65236
|
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
62927
65237
|
}
|
|
62928
65238
|
|
|
65239
|
+
if (!Util.isUnset(request.serviceManaged)) {
|
|
65240
|
+
query["ServiceManaged"] = request.serviceManaged;
|
|
65241
|
+
}
|
|
65242
|
+
|
|
62929
65243
|
if (!Util.isUnset(request.tag)) {
|
|
62930
65244
|
query["Tag"] = request.tag;
|
|
62931
65245
|
}
|
|
@@ -63682,7 +65996,6 @@ export default class Client extends OpenApi {
|
|
|
63682
65996
|
}
|
|
63683
65997
|
|
|
63684
65998
|
/**
|
|
63685
|
-
* ## [](#)References
|
|
63686
65999
|
* 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
66000
|
*
|
|
63688
66001
|
* @param request DescribeRouteEntryListRequest
|
|
@@ -63782,7 +66095,6 @@ export default class Client extends OpenApi {
|
|
|
63782
66095
|
}
|
|
63783
66096
|
|
|
63784
66097
|
/**
|
|
63785
|
-
* ## [](#)References
|
|
63786
66098
|
* 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
66099
|
*
|
|
63788
66100
|
* @param request DescribeRouteEntryListRequest
|
|
@@ -69401,7 +71713,308 @@ export default class Client extends OpenApi {
|
|
|
69401
71713
|
query: OpenApiUtil.query(query),
|
|
69402
71714
|
});
|
|
69403
71715
|
let params = new $OpenApi.Params({
|
|
69404
|
-
action: "ModifyCommonBandwidthPackageAttribute",
|
|
71716
|
+
action: "ModifyCommonBandwidthPackageAttribute",
|
|
71717
|
+
version: "2016-04-28",
|
|
71718
|
+
protocol: "HTTPS",
|
|
71719
|
+
pathname: "/",
|
|
71720
|
+
method: "POST",
|
|
71721
|
+
authType: "AK",
|
|
71722
|
+
style: "RPC",
|
|
71723
|
+
reqBodyType: "formData",
|
|
71724
|
+
bodyType: "json",
|
|
71725
|
+
});
|
|
71726
|
+
return $tea.cast<ModifyCommonBandwidthPackageAttributeResponse>(await this.callApi(params, req, runtime), new ModifyCommonBandwidthPackageAttributeResponse({}));
|
|
71727
|
+
}
|
|
71728
|
+
|
|
71729
|
+
async modifyCommonBandwidthPackageAttribute(request: ModifyCommonBandwidthPackageAttributeRequest): Promise<ModifyCommonBandwidthPackageAttributeResponse> {
|
|
71730
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
71731
|
+
return await this.modifyCommonBandwidthPackageAttributeWithOptions(request, runtime);
|
|
71732
|
+
}
|
|
71733
|
+
|
|
71734
|
+
/**
|
|
71735
|
+
* 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.
|
|
71736
|
+
* 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.
|
|
71737
|
+
* When you call this operation, take note of the following items:
|
|
71738
|
+
* * 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).
|
|
71739
|
+
* * 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.
|
|
71740
|
+
* * You cannot repeatedly call this operation to set the maximum bandwidth of an EIP within the specified period of time.
|
|
71741
|
+
*
|
|
71742
|
+
* @param request ModifyCommonBandwidthPackageIpBandwidthRequest
|
|
71743
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
71744
|
+
* @return ModifyCommonBandwidthPackageIpBandwidthResponse
|
|
71745
|
+
*/
|
|
71746
|
+
async modifyCommonBandwidthPackageIpBandwidthWithOptions(request: ModifyCommonBandwidthPackageIpBandwidthRequest, runtime: $Util.RuntimeOptions): Promise<ModifyCommonBandwidthPackageIpBandwidthResponse> {
|
|
71747
|
+
Util.validateModel(request);
|
|
71748
|
+
let query = { };
|
|
71749
|
+
if (!Util.isUnset(request.bandwidth)) {
|
|
71750
|
+
query["Bandwidth"] = request.bandwidth;
|
|
71751
|
+
}
|
|
71752
|
+
|
|
71753
|
+
if (!Util.isUnset(request.bandwidthPackageId)) {
|
|
71754
|
+
query["BandwidthPackageId"] = request.bandwidthPackageId;
|
|
71755
|
+
}
|
|
71756
|
+
|
|
71757
|
+
if (!Util.isUnset(request.eipId)) {
|
|
71758
|
+
query["EipId"] = request.eipId;
|
|
71759
|
+
}
|
|
71760
|
+
|
|
71761
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
71762
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
71763
|
+
}
|
|
71764
|
+
|
|
71765
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
71766
|
+
query["OwnerId"] = request.ownerId;
|
|
71767
|
+
}
|
|
71768
|
+
|
|
71769
|
+
if (!Util.isUnset(request.regionId)) {
|
|
71770
|
+
query["RegionId"] = request.regionId;
|
|
71771
|
+
}
|
|
71772
|
+
|
|
71773
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
71774
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
71775
|
+
}
|
|
71776
|
+
|
|
71777
|
+
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
71778
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
71779
|
+
}
|
|
71780
|
+
|
|
71781
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
71782
|
+
query: OpenApiUtil.query(query),
|
|
71783
|
+
});
|
|
71784
|
+
let params = new $OpenApi.Params({
|
|
71785
|
+
action: "ModifyCommonBandwidthPackageIpBandwidth",
|
|
71786
|
+
version: "2016-04-28",
|
|
71787
|
+
protocol: "HTTPS",
|
|
71788
|
+
pathname: "/",
|
|
71789
|
+
method: "POST",
|
|
71790
|
+
authType: "AK",
|
|
71791
|
+
style: "RPC",
|
|
71792
|
+
reqBodyType: "formData",
|
|
71793
|
+
bodyType: "json",
|
|
71794
|
+
});
|
|
71795
|
+
return $tea.cast<ModifyCommonBandwidthPackageIpBandwidthResponse>(await this.callApi(params, req, runtime), new ModifyCommonBandwidthPackageIpBandwidthResponse({}));
|
|
71796
|
+
}
|
|
71797
|
+
|
|
71798
|
+
/**
|
|
71799
|
+
* 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.
|
|
71800
|
+
* 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.
|
|
71801
|
+
* When you call this operation, take note of the following items:
|
|
71802
|
+
* * 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).
|
|
71803
|
+
* * 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.
|
|
71804
|
+
* * You cannot repeatedly call this operation to set the maximum bandwidth of an EIP within the specified period of time.
|
|
71805
|
+
*
|
|
71806
|
+
* @param request ModifyCommonBandwidthPackageIpBandwidthRequest
|
|
71807
|
+
* @return ModifyCommonBandwidthPackageIpBandwidthResponse
|
|
71808
|
+
*/
|
|
71809
|
+
async modifyCommonBandwidthPackageIpBandwidth(request: ModifyCommonBandwidthPackageIpBandwidthRequest): Promise<ModifyCommonBandwidthPackageIpBandwidthResponse> {
|
|
71810
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
71811
|
+
return await this.modifyCommonBandwidthPackageIpBandwidthWithOptions(request, runtime);
|
|
71812
|
+
}
|
|
71813
|
+
|
|
71814
|
+
/**
|
|
71815
|
+
* Before you call this operation, take note of the following items:
|
|
71816
|
+
* * **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.
|
|
71817
|
+
* * 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.
|
|
71818
|
+
* * If the Internet Shared Bandwidth instance is in the **Available** state, the maximum bandwidth of the Internet Shared Bandwidth instance is modified.
|
|
71819
|
+
* * You cannot repeatedly call the **ModifyCommonBandwidthPackageSpec** operation to modify the maximum bandwidth of an Internet Shared Bandwidth instance within the specified period of time.
|
|
71820
|
+
*
|
|
71821
|
+
* @param request ModifyCommonBandwidthPackageSpecRequest
|
|
71822
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
71823
|
+
* @return ModifyCommonBandwidthPackageSpecResponse
|
|
71824
|
+
*/
|
|
71825
|
+
async modifyCommonBandwidthPackageSpecWithOptions(request: ModifyCommonBandwidthPackageSpecRequest, runtime: $Util.RuntimeOptions): Promise<ModifyCommonBandwidthPackageSpecResponse> {
|
|
71826
|
+
Util.validateModel(request);
|
|
71827
|
+
let query = { };
|
|
71828
|
+
if (!Util.isUnset(request.bandwidth)) {
|
|
71829
|
+
query["Bandwidth"] = request.bandwidth;
|
|
71830
|
+
}
|
|
71831
|
+
|
|
71832
|
+
if (!Util.isUnset(request.bandwidthPackageId)) {
|
|
71833
|
+
query["BandwidthPackageId"] = request.bandwidthPackageId;
|
|
71834
|
+
}
|
|
71835
|
+
|
|
71836
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
71837
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
71838
|
+
}
|
|
71839
|
+
|
|
71840
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
71841
|
+
query["OwnerId"] = request.ownerId;
|
|
71842
|
+
}
|
|
71843
|
+
|
|
71844
|
+
if (!Util.isUnset(request.regionId)) {
|
|
71845
|
+
query["RegionId"] = request.regionId;
|
|
71846
|
+
}
|
|
71847
|
+
|
|
71848
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
71849
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
71850
|
+
}
|
|
71851
|
+
|
|
71852
|
+
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
71853
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
71854
|
+
}
|
|
71855
|
+
|
|
71856
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
71857
|
+
query: OpenApiUtil.query(query),
|
|
71858
|
+
});
|
|
71859
|
+
let params = new $OpenApi.Params({
|
|
71860
|
+
action: "ModifyCommonBandwidthPackageSpec",
|
|
71861
|
+
version: "2016-04-28",
|
|
71862
|
+
protocol: "HTTPS",
|
|
71863
|
+
pathname: "/",
|
|
71864
|
+
method: "POST",
|
|
71865
|
+
authType: "AK",
|
|
71866
|
+
style: "RPC",
|
|
71867
|
+
reqBodyType: "formData",
|
|
71868
|
+
bodyType: "json",
|
|
71869
|
+
});
|
|
71870
|
+
return $tea.cast<ModifyCommonBandwidthPackageSpecResponse>(await this.callApi(params, req, runtime), new ModifyCommonBandwidthPackageSpecResponse({}));
|
|
71871
|
+
}
|
|
71872
|
+
|
|
71873
|
+
/**
|
|
71874
|
+
* Before you call this operation, take note of the following items:
|
|
71875
|
+
* * **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.
|
|
71876
|
+
* * 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.
|
|
71877
|
+
* * If the Internet Shared Bandwidth instance is in the **Available** state, the maximum bandwidth of the Internet Shared Bandwidth instance is modified.
|
|
71878
|
+
* * You cannot repeatedly call the **ModifyCommonBandwidthPackageSpec** operation to modify the maximum bandwidth of an Internet Shared Bandwidth instance within the specified period of time.
|
|
71879
|
+
*
|
|
71880
|
+
* @param request ModifyCommonBandwidthPackageSpecRequest
|
|
71881
|
+
* @return ModifyCommonBandwidthPackageSpecResponse
|
|
71882
|
+
*/
|
|
71883
|
+
async modifyCommonBandwidthPackageSpec(request: ModifyCommonBandwidthPackageSpecRequest): Promise<ModifyCommonBandwidthPackageSpecResponse> {
|
|
71884
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
71885
|
+
return await this.modifyCommonBandwidthPackageSpecWithOptions(request, runtime);
|
|
71886
|
+
}
|
|
71887
|
+
|
|
71888
|
+
/**
|
|
71889
|
+
* * 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.
|
|
71890
|
+
* * If a VPN gateway is in the **updating** state, the configurations are being modified.
|
|
71891
|
+
* * If a VPN gateway is in the **active** state, the configurations are modified.
|
|
71892
|
+
* * When you call **ModifyCustomerGatewayAttribute**, if no value is assigned to **AuthKey**, the operation is synchronous.
|
|
71893
|
+
* * You cannot repeatedly call **ModifyCustomerGatewayAttribute** to modify the configurations of a customer gateway within the specified period of time.
|
|
71894
|
+
*
|
|
71895
|
+
* @param request ModifyCustomerGatewayAttributeRequest
|
|
71896
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
71897
|
+
* @return ModifyCustomerGatewayAttributeResponse
|
|
71898
|
+
*/
|
|
71899
|
+
async modifyCustomerGatewayAttributeWithOptions(request: ModifyCustomerGatewayAttributeRequest, runtime: $Util.RuntimeOptions): Promise<ModifyCustomerGatewayAttributeResponse> {
|
|
71900
|
+
Util.validateModel(request);
|
|
71901
|
+
let query = { };
|
|
71902
|
+
if (!Util.isUnset(request.authKey)) {
|
|
71903
|
+
query["AuthKey"] = request.authKey;
|
|
71904
|
+
}
|
|
71905
|
+
|
|
71906
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
71907
|
+
query["ClientToken"] = request.clientToken;
|
|
71908
|
+
}
|
|
71909
|
+
|
|
71910
|
+
if (!Util.isUnset(request.customerGatewayId)) {
|
|
71911
|
+
query["CustomerGatewayId"] = request.customerGatewayId;
|
|
71912
|
+
}
|
|
71913
|
+
|
|
71914
|
+
if (!Util.isUnset(request.description)) {
|
|
71915
|
+
query["Description"] = request.description;
|
|
71916
|
+
}
|
|
71917
|
+
|
|
71918
|
+
if (!Util.isUnset(request.name)) {
|
|
71919
|
+
query["Name"] = request.name;
|
|
71920
|
+
}
|
|
71921
|
+
|
|
71922
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
71923
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
71924
|
+
}
|
|
71925
|
+
|
|
71926
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
71927
|
+
query["OwnerId"] = request.ownerId;
|
|
71928
|
+
}
|
|
71929
|
+
|
|
71930
|
+
if (!Util.isUnset(request.regionId)) {
|
|
71931
|
+
query["RegionId"] = request.regionId;
|
|
71932
|
+
}
|
|
71933
|
+
|
|
71934
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
71935
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
71936
|
+
}
|
|
71937
|
+
|
|
71938
|
+
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
71939
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
71940
|
+
}
|
|
71941
|
+
|
|
71942
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
71943
|
+
query: OpenApiUtil.query(query),
|
|
71944
|
+
});
|
|
71945
|
+
let params = new $OpenApi.Params({
|
|
71946
|
+
action: "ModifyCustomerGatewayAttribute",
|
|
71947
|
+
version: "2016-04-28",
|
|
71948
|
+
protocol: "HTTPS",
|
|
71949
|
+
pathname: "/",
|
|
71950
|
+
method: "POST",
|
|
71951
|
+
authType: "AK",
|
|
71952
|
+
style: "RPC",
|
|
71953
|
+
reqBodyType: "formData",
|
|
71954
|
+
bodyType: "json",
|
|
71955
|
+
});
|
|
71956
|
+
return $tea.cast<ModifyCustomerGatewayAttributeResponse>(await this.callApi(params, req, runtime), new ModifyCustomerGatewayAttributeResponse({}));
|
|
71957
|
+
}
|
|
71958
|
+
|
|
71959
|
+
/**
|
|
71960
|
+
* * 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.
|
|
71961
|
+
* * If a VPN gateway is in the **updating** state, the configurations are being modified.
|
|
71962
|
+
* * If a VPN gateway is in the **active** state, the configurations are modified.
|
|
71963
|
+
* * When you call **ModifyCustomerGatewayAttribute**, if no value is assigned to **AuthKey**, the operation is synchronous.
|
|
71964
|
+
* * You cannot repeatedly call **ModifyCustomerGatewayAttribute** to modify the configurations of a customer gateway within the specified period of time.
|
|
71965
|
+
*
|
|
71966
|
+
* @param request ModifyCustomerGatewayAttributeRequest
|
|
71967
|
+
* @return ModifyCustomerGatewayAttributeResponse
|
|
71968
|
+
*/
|
|
71969
|
+
async modifyCustomerGatewayAttribute(request: ModifyCustomerGatewayAttributeRequest): Promise<ModifyCustomerGatewayAttributeResponse> {
|
|
71970
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
71971
|
+
return await this.modifyCustomerGatewayAttributeWithOptions(request, runtime);
|
|
71972
|
+
}
|
|
71973
|
+
|
|
71974
|
+
async modifyEipAddressAttributeWithOptions(request: ModifyEipAddressAttributeRequest, runtime: $Util.RuntimeOptions): Promise<ModifyEipAddressAttributeResponse> {
|
|
71975
|
+
Util.validateModel(request);
|
|
71976
|
+
let query = { };
|
|
71977
|
+
if (!Util.isUnset(request.allocationId)) {
|
|
71978
|
+
query["AllocationId"] = request.allocationId;
|
|
71979
|
+
}
|
|
71980
|
+
|
|
71981
|
+
if (!Util.isUnset(request.bandwidth)) {
|
|
71982
|
+
query["Bandwidth"] = request.bandwidth;
|
|
71983
|
+
}
|
|
71984
|
+
|
|
71985
|
+
if (!Util.isUnset(request.description)) {
|
|
71986
|
+
query["Description"] = request.description;
|
|
71987
|
+
}
|
|
71988
|
+
|
|
71989
|
+
if (!Util.isUnset(request.name)) {
|
|
71990
|
+
query["Name"] = request.name;
|
|
71991
|
+
}
|
|
71992
|
+
|
|
71993
|
+
if (!Util.isUnset(request.ownerAccount)) {
|
|
71994
|
+
query["OwnerAccount"] = request.ownerAccount;
|
|
71995
|
+
}
|
|
71996
|
+
|
|
71997
|
+
if (!Util.isUnset(request.ownerId)) {
|
|
71998
|
+
query["OwnerId"] = request.ownerId;
|
|
71999
|
+
}
|
|
72000
|
+
|
|
72001
|
+
if (!Util.isUnset(request.regionId)) {
|
|
72002
|
+
query["RegionId"] = request.regionId;
|
|
72003
|
+
}
|
|
72004
|
+
|
|
72005
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
72006
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
72007
|
+
}
|
|
72008
|
+
|
|
72009
|
+
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
72010
|
+
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
72011
|
+
}
|
|
72012
|
+
|
|
72013
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
72014
|
+
query: OpenApiUtil.query(query),
|
|
72015
|
+
});
|
|
72016
|
+
let params = new $OpenApi.Params({
|
|
72017
|
+
action: "ModifyEipAddressAttribute",
|
|
69405
72018
|
version: "2016-04-28",
|
|
69406
72019
|
protocol: "HTTPS",
|
|
69407
72020
|
pathname: "/",
|
|
@@ -69411,39 +72024,35 @@ export default class Client extends OpenApi {
|
|
|
69411
72024
|
reqBodyType: "formData",
|
|
69412
72025
|
bodyType: "json",
|
|
69413
72026
|
});
|
|
69414
|
-
return $tea.cast<
|
|
72027
|
+
return $tea.cast<ModifyEipAddressAttributeResponse>(await this.callApi(params, req, runtime), new ModifyEipAddressAttributeResponse({}));
|
|
69415
72028
|
}
|
|
69416
72029
|
|
|
69417
|
-
async
|
|
72030
|
+
async modifyEipAddressAttribute(request: ModifyEipAddressAttributeRequest): Promise<ModifyEipAddressAttributeResponse> {
|
|
69418
72031
|
let runtime = new $Util.RuntimeOptions({ });
|
|
69419
|
-
return await this.
|
|
72032
|
+
return await this.modifyEipAddressAttributeWithOptions(request, runtime);
|
|
69420
72033
|
}
|
|
69421
72034
|
|
|
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> {
|
|
72035
|
+
async modifyExpressCloudConnectionAttributeWithOptions(request: ModifyExpressCloudConnectionAttributeRequest, runtime: $Util.RuntimeOptions): Promise<ModifyExpressCloudConnectionAttributeResponse> {
|
|
69435
72036
|
Util.validateModel(request);
|
|
69436
72037
|
let query = { };
|
|
69437
|
-
if (!Util.isUnset(request.
|
|
69438
|
-
query["
|
|
72038
|
+
if (!Util.isUnset(request.bgpAs)) {
|
|
72039
|
+
query["BgpAs"] = request.bgpAs;
|
|
69439
72040
|
}
|
|
69440
72041
|
|
|
69441
|
-
if (!Util.isUnset(request.
|
|
69442
|
-
query["
|
|
72042
|
+
if (!Util.isUnset(request.ceIp)) {
|
|
72043
|
+
query["CeIp"] = request.ceIp;
|
|
69443
72044
|
}
|
|
69444
72045
|
|
|
69445
|
-
if (!Util.isUnset(request.
|
|
69446
|
-
query["
|
|
72046
|
+
if (!Util.isUnset(request.description)) {
|
|
72047
|
+
query["Description"] = request.description;
|
|
72048
|
+
}
|
|
72049
|
+
|
|
72050
|
+
if (!Util.isUnset(request.eccId)) {
|
|
72051
|
+
query["EccId"] = request.eccId;
|
|
72052
|
+
}
|
|
72053
|
+
|
|
72054
|
+
if (!Util.isUnset(request.name)) {
|
|
72055
|
+
query["Name"] = request.name;
|
|
69447
72056
|
}
|
|
69448
72057
|
|
|
69449
72058
|
if (!Util.isUnset(request.ownerAccount)) {
|
|
@@ -69454,6 +72063,10 @@ export default class Client extends OpenApi {
|
|
|
69454
72063
|
query["OwnerId"] = request.ownerId;
|
|
69455
72064
|
}
|
|
69456
72065
|
|
|
72066
|
+
if (!Util.isUnset(request.peIp)) {
|
|
72067
|
+
query["PeIp"] = request.peIp;
|
|
72068
|
+
}
|
|
72069
|
+
|
|
69457
72070
|
if (!Util.isUnset(request.regionId)) {
|
|
69458
72071
|
query["RegionId"] = request.regionId;
|
|
69459
72072
|
}
|
|
@@ -69470,7 +72083,7 @@ export default class Client extends OpenApi {
|
|
|
69470
72083
|
query: OpenApiUtil.query(query),
|
|
69471
72084
|
});
|
|
69472
72085
|
let params = new $OpenApi.Params({
|
|
69473
|
-
action: "
|
|
72086
|
+
action: "ModifyExpressCloudConnectionAttribute",
|
|
69474
72087
|
version: "2016-04-28",
|
|
69475
72088
|
protocol: "HTTPS",
|
|
69476
72089
|
pathname: "/",
|
|
@@ -69480,45 +72093,23 @@ export default class Client extends OpenApi {
|
|
|
69480
72093
|
reqBodyType: "formData",
|
|
69481
72094
|
bodyType: "json",
|
|
69482
72095
|
});
|
|
69483
|
-
return $tea.cast<
|
|
72096
|
+
return $tea.cast<ModifyExpressCloudConnectionAttributeResponse>(await this.callApi(params, req, runtime), new ModifyExpressCloudConnectionAttributeResponse({}));
|
|
69484
72097
|
}
|
|
69485
72098
|
|
|
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> {
|
|
72099
|
+
async modifyExpressCloudConnectionAttribute(request: ModifyExpressCloudConnectionAttributeRequest): Promise<ModifyExpressCloudConnectionAttributeResponse> {
|
|
69498
72100
|
let runtime = new $Util.RuntimeOptions({ });
|
|
69499
|
-
return await this.
|
|
72101
|
+
return await this.modifyExpressCloudConnectionAttributeWithOptions(request, runtime);
|
|
69500
72102
|
}
|
|
69501
72103
|
|
|
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> {
|
|
72104
|
+
async modifyExpressCloudConnectionBandwidthWithOptions(request: ModifyExpressCloudConnectionBandwidthRequest, runtime: $Util.RuntimeOptions): Promise<ModifyExpressCloudConnectionBandwidthResponse> {
|
|
69514
72105
|
Util.validateModel(request);
|
|
69515
72106
|
let query = { };
|
|
69516
72107
|
if (!Util.isUnset(request.bandwidth)) {
|
|
69517
72108
|
query["Bandwidth"] = request.bandwidth;
|
|
69518
72109
|
}
|
|
69519
72110
|
|
|
69520
|
-
if (!Util.isUnset(request.
|
|
69521
|
-
query["
|
|
72111
|
+
if (!Util.isUnset(request.eccId)) {
|
|
72112
|
+
query["EccId"] = request.eccId;
|
|
69522
72113
|
}
|
|
69523
72114
|
|
|
69524
72115
|
if (!Util.isUnset(request.ownerAccount)) {
|
|
@@ -69545,7 +72136,7 @@ export default class Client extends OpenApi {
|
|
|
69545
72136
|
query: OpenApiUtil.query(query),
|
|
69546
72137
|
});
|
|
69547
72138
|
let params = new $OpenApi.Params({
|
|
69548
|
-
action: "
|
|
72139
|
+
action: "ModifyExpressCloudConnectionBandwidth",
|
|
69549
72140
|
version: "2016-04-28",
|
|
69550
72141
|
protocol: "HTTPS",
|
|
69551
72142
|
pathname: "/",
|
|
@@ -69555,56 +72146,27 @@ export default class Client extends OpenApi {
|
|
|
69555
72146
|
reqBodyType: "formData",
|
|
69556
72147
|
bodyType: "json",
|
|
69557
72148
|
});
|
|
69558
|
-
return $tea.cast<
|
|
72149
|
+
return $tea.cast<ModifyExpressCloudConnectionBandwidthResponse>(await this.callApi(params, req, runtime), new ModifyExpressCloudConnectionBandwidthResponse({}));
|
|
69559
72150
|
}
|
|
69560
72151
|
|
|
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> {
|
|
72152
|
+
async modifyExpressCloudConnectionBandwidth(request: ModifyExpressCloudConnectionBandwidthRequest): Promise<ModifyExpressCloudConnectionBandwidthResponse> {
|
|
69572
72153
|
let runtime = new $Util.RuntimeOptions({ });
|
|
69573
|
-
return await this.
|
|
72154
|
+
return await this.modifyExpressCloudConnectionBandwidthWithOptions(request, runtime);
|
|
69574
72155
|
}
|
|
69575
72156
|
|
|
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> {
|
|
72157
|
+
async modifyExpressConnectTrafficQosWithOptions(request: ModifyExpressConnectTrafficQosRequest, runtime: $Util.RuntimeOptions): Promise<ModifyExpressConnectTrafficQosResponse> {
|
|
69588
72158
|
Util.validateModel(request);
|
|
69589
72159
|
let query = { };
|
|
69590
|
-
if (!Util.isUnset(request.
|
|
69591
|
-
query["
|
|
72160
|
+
if (!Util.isUnset(request.addInstanceList)) {
|
|
72161
|
+
query["AddInstanceList"] = request.addInstanceList;
|
|
69592
72162
|
}
|
|
69593
72163
|
|
|
69594
72164
|
if (!Util.isUnset(request.clientToken)) {
|
|
69595
72165
|
query["ClientToken"] = request.clientToken;
|
|
69596
72166
|
}
|
|
69597
72167
|
|
|
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;
|
|
72168
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
72169
|
+
query["ClientToken"] = request.clientToken;
|
|
69608
72170
|
}
|
|
69609
72171
|
|
|
69610
72172
|
if (!Util.isUnset(request.ownerAccount)) {
|
|
@@ -69615,23 +72177,35 @@ export default class Client extends OpenApi {
|
|
|
69615
72177
|
query["OwnerId"] = request.ownerId;
|
|
69616
72178
|
}
|
|
69617
72179
|
|
|
72180
|
+
if (!Util.isUnset(request.qosDescription)) {
|
|
72181
|
+
query["QosDescription"] = request.qosDescription;
|
|
72182
|
+
}
|
|
72183
|
+
|
|
72184
|
+
if (!Util.isUnset(request.qosId)) {
|
|
72185
|
+
query["QosId"] = request.qosId;
|
|
72186
|
+
}
|
|
72187
|
+
|
|
72188
|
+
if (!Util.isUnset(request.qosName)) {
|
|
72189
|
+
query["QosName"] = request.qosName;
|
|
72190
|
+
}
|
|
72191
|
+
|
|
69618
72192
|
if (!Util.isUnset(request.regionId)) {
|
|
69619
72193
|
query["RegionId"] = request.regionId;
|
|
69620
72194
|
}
|
|
69621
72195
|
|
|
69622
|
-
if (!Util.isUnset(request.
|
|
69623
|
-
query["
|
|
72196
|
+
if (!Util.isUnset(request.removeInstanceList)) {
|
|
72197
|
+
query["RemoveInstanceList"] = request.removeInstanceList;
|
|
69624
72198
|
}
|
|
69625
72199
|
|
|
69626
|
-
if (!Util.isUnset(request.
|
|
69627
|
-
query["
|
|
72200
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
72201
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
69628
72202
|
}
|
|
69629
72203
|
|
|
69630
72204
|
let req = new $OpenApi.OpenApiRequest({
|
|
69631
72205
|
query: OpenApiUtil.query(query),
|
|
69632
72206
|
});
|
|
69633
72207
|
let params = new $OpenApi.Params({
|
|
69634
|
-
action: "
|
|
72208
|
+
action: "ModifyExpressConnectTrafficQos",
|
|
69635
72209
|
version: "2016-04-28",
|
|
69636
72210
|
protocol: "HTTPS",
|
|
69637
72211
|
pathname: "/",
|
|
@@ -69641,41 +72215,27 @@ export default class Client extends OpenApi {
|
|
|
69641
72215
|
reqBodyType: "formData",
|
|
69642
72216
|
bodyType: "json",
|
|
69643
72217
|
});
|
|
69644
|
-
return $tea.cast<
|
|
72218
|
+
return $tea.cast<ModifyExpressConnectTrafficQosResponse>(await this.callApi(params, req, runtime), new ModifyExpressConnectTrafficQosResponse({}));
|
|
69645
72219
|
}
|
|
69646
72220
|
|
|
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> {
|
|
72221
|
+
async modifyExpressConnectTrafficQos(request: ModifyExpressConnectTrafficQosRequest): Promise<ModifyExpressConnectTrafficQosResponse> {
|
|
69658
72222
|
let runtime = new $Util.RuntimeOptions({ });
|
|
69659
|
-
return await this.
|
|
72223
|
+
return await this.modifyExpressConnectTrafficQosWithOptions(request, runtime);
|
|
69660
72224
|
}
|
|
69661
72225
|
|
|
69662
|
-
async
|
|
72226
|
+
async modifyExpressConnectTrafficQosQueueWithOptions(request: ModifyExpressConnectTrafficQosQueueRequest, runtime: $Util.RuntimeOptions): Promise<ModifyExpressConnectTrafficQosQueueResponse> {
|
|
69663
72227
|
Util.validateModel(request);
|
|
69664
72228
|
let query = { };
|
|
69665
|
-
if (!Util.isUnset(request.
|
|
69666
|
-
query["
|
|
69667
|
-
}
|
|
69668
|
-
|
|
69669
|
-
if (!Util.isUnset(request.bandwidth)) {
|
|
69670
|
-
query["Bandwidth"] = request.bandwidth;
|
|
72229
|
+
if (!Util.isUnset(request.bandwidthPercent)) {
|
|
72230
|
+
query["BandwidthPercent"] = request.bandwidthPercent;
|
|
69671
72231
|
}
|
|
69672
72232
|
|
|
69673
|
-
if (!Util.isUnset(request.
|
|
69674
|
-
query["
|
|
72233
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
72234
|
+
query["ClientToken"] = request.clientToken;
|
|
69675
72235
|
}
|
|
69676
72236
|
|
|
69677
|
-
if (!Util.isUnset(request.
|
|
69678
|
-
query["
|
|
72237
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
72238
|
+
query["ClientToken"] = request.clientToken;
|
|
69679
72239
|
}
|
|
69680
72240
|
|
|
69681
72241
|
if (!Util.isUnset(request.ownerAccount)) {
|
|
@@ -69686,6 +72246,22 @@ export default class Client extends OpenApi {
|
|
|
69686
72246
|
query["OwnerId"] = request.ownerId;
|
|
69687
72247
|
}
|
|
69688
72248
|
|
|
72249
|
+
if (!Util.isUnset(request.qosId)) {
|
|
72250
|
+
query["QosId"] = request.qosId;
|
|
72251
|
+
}
|
|
72252
|
+
|
|
72253
|
+
if (!Util.isUnset(request.queueDescription)) {
|
|
72254
|
+
query["QueueDescription"] = request.queueDescription;
|
|
72255
|
+
}
|
|
72256
|
+
|
|
72257
|
+
if (!Util.isUnset(request.queueId)) {
|
|
72258
|
+
query["QueueId"] = request.queueId;
|
|
72259
|
+
}
|
|
72260
|
+
|
|
72261
|
+
if (!Util.isUnset(request.queueName)) {
|
|
72262
|
+
query["QueueName"] = request.queueName;
|
|
72263
|
+
}
|
|
72264
|
+
|
|
69689
72265
|
if (!Util.isUnset(request.regionId)) {
|
|
69690
72266
|
query["RegionId"] = request.regionId;
|
|
69691
72267
|
}
|
|
@@ -69694,15 +72270,11 @@ export default class Client extends OpenApi {
|
|
|
69694
72270
|
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
69695
72271
|
}
|
|
69696
72272
|
|
|
69697
|
-
if (!Util.isUnset(request.resourceOwnerId)) {
|
|
69698
|
-
query["ResourceOwnerId"] = request.resourceOwnerId;
|
|
69699
|
-
}
|
|
69700
|
-
|
|
69701
72273
|
let req = new $OpenApi.OpenApiRequest({
|
|
69702
72274
|
query: OpenApiUtil.query(query),
|
|
69703
72275
|
});
|
|
69704
72276
|
let params = new $OpenApi.Params({
|
|
69705
|
-
action: "
|
|
72277
|
+
action: "ModifyExpressConnectTrafficQosQueue",
|
|
69706
72278
|
version: "2016-04-28",
|
|
69707
72279
|
protocol: "HTTPS",
|
|
69708
72280
|
pathname: "/",
|
|
@@ -69712,35 +72284,39 @@ export default class Client extends OpenApi {
|
|
|
69712
72284
|
reqBodyType: "formData",
|
|
69713
72285
|
bodyType: "json",
|
|
69714
72286
|
});
|
|
69715
|
-
return $tea.cast<
|
|
72287
|
+
return $tea.cast<ModifyExpressConnectTrafficQosQueueResponse>(await this.callApi(params, req, runtime), new ModifyExpressConnectTrafficQosQueueResponse({}));
|
|
69716
72288
|
}
|
|
69717
72289
|
|
|
69718
|
-
async
|
|
72290
|
+
async modifyExpressConnectTrafficQosQueue(request: ModifyExpressConnectTrafficQosQueueRequest): Promise<ModifyExpressConnectTrafficQosQueueResponse> {
|
|
69719
72291
|
let runtime = new $Util.RuntimeOptions({ });
|
|
69720
|
-
return await this.
|
|
72292
|
+
return await this.modifyExpressConnectTrafficQosQueueWithOptions(request, runtime);
|
|
69721
72293
|
}
|
|
69722
72294
|
|
|
69723
|
-
async
|
|
72295
|
+
async modifyExpressConnectTrafficQosRuleWithOptions(request: ModifyExpressConnectTrafficQosRuleRequest, runtime: $Util.RuntimeOptions): Promise<ModifyExpressConnectTrafficQosRuleResponse> {
|
|
69724
72296
|
Util.validateModel(request);
|
|
69725
72297
|
let query = { };
|
|
69726
|
-
if (!Util.isUnset(request.
|
|
69727
|
-
query["
|
|
72298
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
72299
|
+
query["ClientToken"] = request.clientToken;
|
|
69728
72300
|
}
|
|
69729
72301
|
|
|
69730
|
-
if (!Util.isUnset(request.
|
|
69731
|
-
query["
|
|
72302
|
+
if (!Util.isUnset(request.clientToken)) {
|
|
72303
|
+
query["ClientToken"] = request.clientToken;
|
|
69732
72304
|
}
|
|
69733
72305
|
|
|
69734
|
-
if (!Util.isUnset(request.
|
|
69735
|
-
query["
|
|
72306
|
+
if (!Util.isUnset(request.dstCidr)) {
|
|
72307
|
+
query["DstCidr"] = request.dstCidr;
|
|
69736
72308
|
}
|
|
69737
72309
|
|
|
69738
|
-
if (!Util.isUnset(request.
|
|
69739
|
-
query["
|
|
72310
|
+
if (!Util.isUnset(request.dstIPv6Cidr)) {
|
|
72311
|
+
query["DstIPv6Cidr"] = request.dstIPv6Cidr;
|
|
69740
72312
|
}
|
|
69741
72313
|
|
|
69742
|
-
if (!Util.isUnset(request.
|
|
69743
|
-
query["
|
|
72314
|
+
if (!Util.isUnset(request.dstPortRange)) {
|
|
72315
|
+
query["DstPortRange"] = request.dstPortRange;
|
|
72316
|
+
}
|
|
72317
|
+
|
|
72318
|
+
if (!Util.isUnset(request.matchDscp)) {
|
|
72319
|
+
query["MatchDscp"] = request.matchDscp;
|
|
69744
72320
|
}
|
|
69745
72321
|
|
|
69746
72322
|
if (!Util.isUnset(request.ownerAccount)) {
|
|
@@ -69751,80 +72327,63 @@ export default class Client extends OpenApi {
|
|
|
69751
72327
|
query["OwnerId"] = request.ownerId;
|
|
69752
72328
|
}
|
|
69753
72329
|
|
|
69754
|
-
if (!Util.isUnset(request.
|
|
69755
|
-
query["
|
|
72330
|
+
if (!Util.isUnset(request.priority)) {
|
|
72331
|
+
query["Priority"] = request.priority;
|
|
69756
72332
|
}
|
|
69757
72333
|
|
|
69758
|
-
if (!Util.isUnset(request.
|
|
69759
|
-
query["
|
|
72334
|
+
if (!Util.isUnset(request.protocol)) {
|
|
72335
|
+
query["Protocol"] = request.protocol;
|
|
69760
72336
|
}
|
|
69761
72337
|
|
|
69762
|
-
if (!Util.isUnset(request.
|
|
69763
|
-
query["
|
|
72338
|
+
if (!Util.isUnset(request.qosId)) {
|
|
72339
|
+
query["QosId"] = request.qosId;
|
|
69764
72340
|
}
|
|
69765
72341
|
|
|
69766
|
-
if (!Util.isUnset(request.
|
|
69767
|
-
query["
|
|
72342
|
+
if (!Util.isUnset(request.queueId)) {
|
|
72343
|
+
query["QueueId"] = request.queueId;
|
|
69768
72344
|
}
|
|
69769
72345
|
|
|
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
|
-
}
|
|
72346
|
+
if (!Util.isUnset(request.regionId)) {
|
|
72347
|
+
query["RegionId"] = request.regionId;
|
|
72348
|
+
}
|
|
69786
72349
|
|
|
69787
|
-
|
|
69788
|
-
|
|
69789
|
-
|
|
69790
|
-
}
|
|
72350
|
+
if (!Util.isUnset(request.remarkingDscp)) {
|
|
72351
|
+
query["RemarkingDscp"] = request.remarkingDscp;
|
|
72352
|
+
}
|
|
69791
72353
|
|
|
69792
|
-
|
|
69793
|
-
|
|
69794
|
-
let query = { };
|
|
69795
|
-
if (!Util.isUnset(request.bandwidth)) {
|
|
69796
|
-
query["Bandwidth"] = request.bandwidth;
|
|
72354
|
+
if (!Util.isUnset(request.resourceOwnerAccount)) {
|
|
72355
|
+
query["ResourceOwnerAccount"] = request.resourceOwnerAccount;
|
|
69797
72356
|
}
|
|
69798
72357
|
|
|
69799
|
-
if (!Util.isUnset(request.
|
|
69800
|
-
query["
|
|
72358
|
+
if (!Util.isUnset(request.ruleDescription)) {
|
|
72359
|
+
query["RuleDescription"] = request.ruleDescription;
|
|
69801
72360
|
}
|
|
69802
72361
|
|
|
69803
|
-
if (!Util.isUnset(request.
|
|
69804
|
-
query["
|
|
72362
|
+
if (!Util.isUnset(request.ruleId)) {
|
|
72363
|
+
query["RuleId"] = request.ruleId;
|
|
69805
72364
|
}
|
|
69806
72365
|
|
|
69807
|
-
if (!Util.isUnset(request.
|
|
69808
|
-
query["
|
|
72366
|
+
if (!Util.isUnset(request.ruleName)) {
|
|
72367
|
+
query["RuleName"] = request.ruleName;
|
|
69809
72368
|
}
|
|
69810
72369
|
|
|
69811
|
-
if (!Util.isUnset(request.
|
|
69812
|
-
query["
|
|
72370
|
+
if (!Util.isUnset(request.srcCidr)) {
|
|
72371
|
+
query["SrcCidr"] = request.srcCidr;
|
|
69813
72372
|
}
|
|
69814
72373
|
|
|
69815
|
-
if (!Util.isUnset(request.
|
|
69816
|
-
query["
|
|
72374
|
+
if (!Util.isUnset(request.srcIPv6Cidr)) {
|
|
72375
|
+
query["SrcIPv6Cidr"] = request.srcIPv6Cidr;
|
|
69817
72376
|
}
|
|
69818
72377
|
|
|
69819
|
-
if (!Util.isUnset(request.
|
|
69820
|
-
query["
|
|
72378
|
+
if (!Util.isUnset(request.srcPortRange)) {
|
|
72379
|
+
query["SrcPortRange"] = request.srcPortRange;
|
|
69821
72380
|
}
|
|
69822
72381
|
|
|
69823
72382
|
let req = new $OpenApi.OpenApiRequest({
|
|
69824
72383
|
query: OpenApiUtil.query(query),
|
|
69825
72384
|
});
|
|
69826
72385
|
let params = new $OpenApi.Params({
|
|
69827
|
-
action: "
|
|
72386
|
+
action: "ModifyExpressConnectTrafficQosRule",
|
|
69828
72387
|
version: "2016-04-28",
|
|
69829
72388
|
protocol: "HTTPS",
|
|
69830
72389
|
pathname: "/",
|
|
@@ -69834,12 +72393,12 @@ export default class Client extends OpenApi {
|
|
|
69834
72393
|
reqBodyType: "formData",
|
|
69835
72394
|
bodyType: "json",
|
|
69836
72395
|
});
|
|
69837
|
-
return $tea.cast<
|
|
72396
|
+
return $tea.cast<ModifyExpressConnectTrafficQosRuleResponse>(await this.callApi(params, req, runtime), new ModifyExpressConnectTrafficQosRuleResponse({}));
|
|
69838
72397
|
}
|
|
69839
72398
|
|
|
69840
|
-
async
|
|
72399
|
+
async modifyExpressConnectTrafficQosRule(request: ModifyExpressConnectTrafficQosRuleRequest): Promise<ModifyExpressConnectTrafficQosRuleResponse> {
|
|
69841
72400
|
let runtime = new $Util.RuntimeOptions({ });
|
|
69842
|
-
return await this.
|
|
72401
|
+
return await this.modifyExpressConnectTrafficQosRuleWithOptions(request, runtime);
|
|
69843
72402
|
}
|
|
69844
72403
|
|
|
69845
72404
|
/**
|
|
@@ -71640,7 +74199,6 @@ export default class Client extends OpenApi {
|
|
|
71640
74199
|
}
|
|
71641
74200
|
|
|
71642
74201
|
/**
|
|
71643
|
-
* ## [](#)Description
|
|
71644
74202
|
* 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
74203
|
* > You cannot modify the specification of a router interface that has overdue payments.
|
|
71646
74204
|
*
|
|
@@ -71701,7 +74259,6 @@ export default class Client extends OpenApi {
|
|
|
71701
74259
|
}
|
|
71702
74260
|
|
|
71703
74261
|
/**
|
|
71704
|
-
* ## [](#)Description
|
|
71705
74262
|
* 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
74263
|
* > You cannot modify the specification of a router interface that has overdue payments.
|
|
71707
74264
|
*
|
|
@@ -72586,10 +75143,10 @@ export default class Client extends OpenApi {
|
|
|
72586
75143
|
}
|
|
72587
75144
|
|
|
72588
75145
|
/**
|
|
72589
|
-
* *
|
|
75146
|
+
* * **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
75147
|
* * If the prefix list is in the **Modifying** state, the configuration of the prefix list is being modified.
|
|
72591
75148
|
* * 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.
|
|
75149
|
+
* * 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
75150
|
* * You cannot repeatedly call **ModifyVpcPrefixList** to modify the configuration of a prefix list within the specified period of time.
|
|
72594
75151
|
*
|
|
72595
75152
|
* @param request ModifyVpcPrefixListRequest
|
|
@@ -72669,10 +75226,10 @@ export default class Client extends OpenApi {
|
|
|
72669
75226
|
}
|
|
72670
75227
|
|
|
72671
75228
|
/**
|
|
72672
|
-
* *
|
|
75229
|
+
* * **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
75230
|
* * If the prefix list is in the **Modifying** state, the configuration of the prefix list is being modified.
|
|
72674
75231
|
* * 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.
|
|
75232
|
+
* * 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
75233
|
* * You cannot repeatedly call **ModifyVpcPrefixList** to modify the configuration of a prefix list within the specified period of time.
|
|
72677
75234
|
*
|
|
72678
75235
|
* @param request ModifyVpcPrefixListRequest
|
|
@@ -73857,7 +76414,7 @@ export default class Client extends OpenApi {
|
|
|
73857
76414
|
}
|
|
73858
76415
|
|
|
73859
76416
|
/**
|
|
73860
|
-
* After
|
|
76417
|
+
* 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
76418
|
* When you call this operation, take note of the following items:
|
|
73862
76419
|
* * Only the owner of the Express Connect circuit can call this operation.
|
|
73863
76420
|
* * The Express Connect circuit to which the VBR connects must be in the **Enabled** state.
|
|
@@ -73915,7 +76472,7 @@ export default class Client extends OpenApi {
|
|
|
73915
76472
|
}
|
|
73916
76473
|
|
|
73917
76474
|
/**
|
|
73918
|
-
* After
|
|
76475
|
+
* 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
76476
|
* When you call this operation, take note of the following items:
|
|
73920
76477
|
* * Only the owner of the Express Connect circuit can call this operation.
|
|
73921
76478
|
* * The Express Connect circuit to which the VBR connects must be in the **Enabled** state.
|
|
@@ -75193,7 +77750,7 @@ export default class Client extends OpenApi {
|
|
|
75193
77750
|
}
|
|
75194
77751
|
|
|
75195
77752
|
/**
|
|
75196
|
-
* After
|
|
77753
|
+
* 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
77754
|
* > Only the owner of an Express Connect circuit can call this operation.
|
|
75198
77755
|
*
|
|
75199
77756
|
* @param request TerminateVirtualBorderRouterRequest
|
|
@@ -75249,7 +77806,7 @@ export default class Client extends OpenApi {
|
|
|
75249
77806
|
}
|
|
75250
77807
|
|
|
75251
77808
|
/**
|
|
75252
|
-
* After
|
|
77809
|
+
* 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
77810
|
* > Only the owner of an Express Connect circuit can call this operation.
|
|
75254
77811
|
*
|
|
75255
77812
|
* @param request TerminateVirtualBorderRouterRequest
|