@alicloud/cloudfw20171207 1.2.9 → 1.3.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 +409 -0
- package/dist/client.js +1025 -77
- package/dist/client.js.map +1 -1
- package/package.json +2 -2
- package/src/client.ts +1312 -100
package/src/client.ts
CHANGED
|
@@ -350,6 +350,123 @@ export class BatchCopyVpcFirewallControlPolicyResponse extends $tea.Model {
|
|
|
350
350
|
}
|
|
351
351
|
}
|
|
352
352
|
|
|
353
|
+
export class CreateNatFirewallControlPolicyRequest extends $tea.Model {
|
|
354
|
+
aclAction?: string;
|
|
355
|
+
applicationNameList?: string[];
|
|
356
|
+
description?: string;
|
|
357
|
+
destPort?: string;
|
|
358
|
+
destPortGroup?: string;
|
|
359
|
+
destPortType?: string;
|
|
360
|
+
destination?: string;
|
|
361
|
+
destinationType?: string;
|
|
362
|
+
direction?: string;
|
|
363
|
+
domainResolveType?: number;
|
|
364
|
+
ipVersion?: string;
|
|
365
|
+
lang?: string;
|
|
366
|
+
natGatewayId?: string;
|
|
367
|
+
newOrder?: string;
|
|
368
|
+
proto?: string;
|
|
369
|
+
release?: string;
|
|
370
|
+
source?: string;
|
|
371
|
+
sourceType?: string;
|
|
372
|
+
static names(): { [key: string]: string } {
|
|
373
|
+
return {
|
|
374
|
+
aclAction: 'AclAction',
|
|
375
|
+
applicationNameList: 'ApplicationNameList',
|
|
376
|
+
description: 'Description',
|
|
377
|
+
destPort: 'DestPort',
|
|
378
|
+
destPortGroup: 'DestPortGroup',
|
|
379
|
+
destPortType: 'DestPortType',
|
|
380
|
+
destination: 'Destination',
|
|
381
|
+
destinationType: 'DestinationType',
|
|
382
|
+
direction: 'Direction',
|
|
383
|
+
domainResolveType: 'DomainResolveType',
|
|
384
|
+
ipVersion: 'IpVersion',
|
|
385
|
+
lang: 'Lang',
|
|
386
|
+
natGatewayId: 'NatGatewayId',
|
|
387
|
+
newOrder: 'NewOrder',
|
|
388
|
+
proto: 'Proto',
|
|
389
|
+
release: 'Release',
|
|
390
|
+
source: 'Source',
|
|
391
|
+
sourceType: 'SourceType',
|
|
392
|
+
};
|
|
393
|
+
}
|
|
394
|
+
|
|
395
|
+
static types(): { [key: string]: any } {
|
|
396
|
+
return {
|
|
397
|
+
aclAction: 'string',
|
|
398
|
+
applicationNameList: { 'type': 'array', 'itemType': 'string' },
|
|
399
|
+
description: 'string',
|
|
400
|
+
destPort: 'string',
|
|
401
|
+
destPortGroup: 'string',
|
|
402
|
+
destPortType: 'string',
|
|
403
|
+
destination: 'string',
|
|
404
|
+
destinationType: 'string',
|
|
405
|
+
direction: 'string',
|
|
406
|
+
domainResolveType: 'number',
|
|
407
|
+
ipVersion: 'string',
|
|
408
|
+
lang: 'string',
|
|
409
|
+
natGatewayId: 'string',
|
|
410
|
+
newOrder: 'string',
|
|
411
|
+
proto: 'string',
|
|
412
|
+
release: 'string',
|
|
413
|
+
source: 'string',
|
|
414
|
+
sourceType: 'string',
|
|
415
|
+
};
|
|
416
|
+
}
|
|
417
|
+
|
|
418
|
+
constructor(map?: { [key: string]: any }) {
|
|
419
|
+
super(map);
|
|
420
|
+
}
|
|
421
|
+
}
|
|
422
|
+
|
|
423
|
+
export class CreateNatFirewallControlPolicyResponseBody extends $tea.Model {
|
|
424
|
+
aclUuid?: string;
|
|
425
|
+
requestId?: string;
|
|
426
|
+
static names(): { [key: string]: string } {
|
|
427
|
+
return {
|
|
428
|
+
aclUuid: 'AclUuid',
|
|
429
|
+
requestId: 'RequestId',
|
|
430
|
+
};
|
|
431
|
+
}
|
|
432
|
+
|
|
433
|
+
static types(): { [key: string]: any } {
|
|
434
|
+
return {
|
|
435
|
+
aclUuid: 'string',
|
|
436
|
+
requestId: 'string',
|
|
437
|
+
};
|
|
438
|
+
}
|
|
439
|
+
|
|
440
|
+
constructor(map?: { [key: string]: any }) {
|
|
441
|
+
super(map);
|
|
442
|
+
}
|
|
443
|
+
}
|
|
444
|
+
|
|
445
|
+
export class CreateNatFirewallControlPolicyResponse extends $tea.Model {
|
|
446
|
+
headers: { [key: string]: string };
|
|
447
|
+
statusCode: number;
|
|
448
|
+
body: CreateNatFirewallControlPolicyResponseBody;
|
|
449
|
+
static names(): { [key: string]: string } {
|
|
450
|
+
return {
|
|
451
|
+
headers: 'headers',
|
|
452
|
+
statusCode: 'statusCode',
|
|
453
|
+
body: 'body',
|
|
454
|
+
};
|
|
455
|
+
}
|
|
456
|
+
|
|
457
|
+
static types(): { [key: string]: any } {
|
|
458
|
+
return {
|
|
459
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
460
|
+
statusCode: 'number',
|
|
461
|
+
body: CreateNatFirewallControlPolicyResponseBody,
|
|
462
|
+
};
|
|
463
|
+
}
|
|
464
|
+
|
|
465
|
+
constructor(map?: { [key: string]: any }) {
|
|
466
|
+
super(map);
|
|
467
|
+
}
|
|
468
|
+
}
|
|
469
|
+
|
|
353
470
|
export class CreateTrFirewallV2Request extends $tea.Model {
|
|
354
471
|
cenId?: string;
|
|
355
472
|
firewallDescription?: string;
|
|
@@ -1146,6 +1263,78 @@ export class DeleteInstanceMembersResponse extends $tea.Model {
|
|
|
1146
1263
|
}
|
|
1147
1264
|
}
|
|
1148
1265
|
|
|
1266
|
+
export class DeleteNatFirewallControlPolicyRequest extends $tea.Model {
|
|
1267
|
+
aclUuid?: string;
|
|
1268
|
+
direction?: string;
|
|
1269
|
+
lang?: string;
|
|
1270
|
+
natGatewayId?: string;
|
|
1271
|
+
static names(): { [key: string]: string } {
|
|
1272
|
+
return {
|
|
1273
|
+
aclUuid: 'AclUuid',
|
|
1274
|
+
direction: 'Direction',
|
|
1275
|
+
lang: 'Lang',
|
|
1276
|
+
natGatewayId: 'NatGatewayId',
|
|
1277
|
+
};
|
|
1278
|
+
}
|
|
1279
|
+
|
|
1280
|
+
static types(): { [key: string]: any } {
|
|
1281
|
+
return {
|
|
1282
|
+
aclUuid: 'string',
|
|
1283
|
+
direction: 'string',
|
|
1284
|
+
lang: 'string',
|
|
1285
|
+
natGatewayId: 'string',
|
|
1286
|
+
};
|
|
1287
|
+
}
|
|
1288
|
+
|
|
1289
|
+
constructor(map?: { [key: string]: any }) {
|
|
1290
|
+
super(map);
|
|
1291
|
+
}
|
|
1292
|
+
}
|
|
1293
|
+
|
|
1294
|
+
export class DeleteNatFirewallControlPolicyResponseBody extends $tea.Model {
|
|
1295
|
+
requestId?: string;
|
|
1296
|
+
static names(): { [key: string]: string } {
|
|
1297
|
+
return {
|
|
1298
|
+
requestId: 'RequestId',
|
|
1299
|
+
};
|
|
1300
|
+
}
|
|
1301
|
+
|
|
1302
|
+
static types(): { [key: string]: any } {
|
|
1303
|
+
return {
|
|
1304
|
+
requestId: 'string',
|
|
1305
|
+
};
|
|
1306
|
+
}
|
|
1307
|
+
|
|
1308
|
+
constructor(map?: { [key: string]: any }) {
|
|
1309
|
+
super(map);
|
|
1310
|
+
}
|
|
1311
|
+
}
|
|
1312
|
+
|
|
1313
|
+
export class DeleteNatFirewallControlPolicyResponse extends $tea.Model {
|
|
1314
|
+
headers: { [key: string]: string };
|
|
1315
|
+
statusCode: number;
|
|
1316
|
+
body: DeleteNatFirewallControlPolicyResponseBody;
|
|
1317
|
+
static names(): { [key: string]: string } {
|
|
1318
|
+
return {
|
|
1319
|
+
headers: 'headers',
|
|
1320
|
+
statusCode: 'statusCode',
|
|
1321
|
+
body: 'body',
|
|
1322
|
+
};
|
|
1323
|
+
}
|
|
1324
|
+
|
|
1325
|
+
static types(): { [key: string]: any } {
|
|
1326
|
+
return {
|
|
1327
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1328
|
+
statusCode: 'number',
|
|
1329
|
+
body: DeleteNatFirewallControlPolicyResponseBody,
|
|
1330
|
+
};
|
|
1331
|
+
}
|
|
1332
|
+
|
|
1333
|
+
constructor(map?: { [key: string]: any }) {
|
|
1334
|
+
super(map);
|
|
1335
|
+
}
|
|
1336
|
+
}
|
|
1337
|
+
|
|
1149
1338
|
export class DeleteTrFirewallV2Request extends $tea.Model {
|
|
1150
1339
|
firewallId?: string;
|
|
1151
1340
|
lang?: string;
|
|
@@ -2220,56 +2409,50 @@ export class DescribeInvadeEventListResponse extends $tea.Model {
|
|
|
2220
2409
|
}
|
|
2221
2410
|
}
|
|
2222
2411
|
|
|
2223
|
-
export class
|
|
2224
|
-
|
|
2225
|
-
|
|
2412
|
+
export class DescribeNatFirewallControlPolicyRequest extends $tea.Model {
|
|
2413
|
+
aclAction?: string;
|
|
2414
|
+
aclUuid?: string;
|
|
2226
2415
|
currentPage?: string;
|
|
2227
|
-
|
|
2228
|
-
|
|
2416
|
+
description?: string;
|
|
2417
|
+
destination?: string;
|
|
2418
|
+
direction?: string;
|
|
2229
2419
|
lang?: string;
|
|
2230
|
-
|
|
2420
|
+
natGatewayId?: string;
|
|
2231
2421
|
pageSize?: string;
|
|
2232
|
-
|
|
2233
|
-
|
|
2234
|
-
|
|
2235
|
-
sort?: string;
|
|
2236
|
-
startTime?: string;
|
|
2237
|
-
tagIdNew?: string;
|
|
2422
|
+
proto?: string;
|
|
2423
|
+
release?: string;
|
|
2424
|
+
source?: string;
|
|
2238
2425
|
static names(): { [key: string]: string } {
|
|
2239
2426
|
return {
|
|
2240
|
-
|
|
2241
|
-
|
|
2427
|
+
aclAction: 'AclAction',
|
|
2428
|
+
aclUuid: 'AclUuid',
|
|
2242
2429
|
currentPage: 'CurrentPage',
|
|
2243
|
-
|
|
2244
|
-
|
|
2430
|
+
description: 'Description',
|
|
2431
|
+
destination: 'Destination',
|
|
2432
|
+
direction: 'Direction',
|
|
2245
2433
|
lang: 'Lang',
|
|
2246
|
-
|
|
2434
|
+
natGatewayId: 'NatGatewayId',
|
|
2247
2435
|
pageSize: 'PageSize',
|
|
2248
|
-
|
|
2249
|
-
|
|
2250
|
-
|
|
2251
|
-
sort: 'Sort',
|
|
2252
|
-
startTime: 'StartTime',
|
|
2253
|
-
tagIdNew: 'TagIdNew',
|
|
2436
|
+
proto: 'Proto',
|
|
2437
|
+
release: 'Release',
|
|
2438
|
+
source: 'Source',
|
|
2254
2439
|
};
|
|
2255
2440
|
}
|
|
2256
2441
|
|
|
2257
2442
|
static types(): { [key: string]: any } {
|
|
2258
2443
|
return {
|
|
2259
|
-
|
|
2260
|
-
|
|
2444
|
+
aclAction: 'string',
|
|
2445
|
+
aclUuid: 'string',
|
|
2261
2446
|
currentPage: 'string',
|
|
2262
|
-
|
|
2263
|
-
|
|
2447
|
+
description: 'string',
|
|
2448
|
+
destination: 'string',
|
|
2449
|
+
direction: 'string',
|
|
2264
2450
|
lang: 'string',
|
|
2265
|
-
|
|
2451
|
+
natGatewayId: 'string',
|
|
2266
2452
|
pageSize: 'string',
|
|
2267
|
-
|
|
2268
|
-
|
|
2269
|
-
|
|
2270
|
-
sort: 'string',
|
|
2271
|
-
startTime: 'string',
|
|
2272
|
-
tagIdNew: 'string',
|
|
2453
|
+
proto: 'string',
|
|
2454
|
+
release: 'string',
|
|
2455
|
+
source: 'string',
|
|
2273
2456
|
};
|
|
2274
2457
|
}
|
|
2275
2458
|
|
|
@@ -2278,13 +2461,13 @@ export class DescribeOutgoingDestinationIPRequest extends $tea.Model {
|
|
|
2278
2461
|
}
|
|
2279
2462
|
}
|
|
2280
2463
|
|
|
2281
|
-
export class
|
|
2282
|
-
|
|
2464
|
+
export class DescribeNatFirewallControlPolicyResponseBody extends $tea.Model {
|
|
2465
|
+
policys?: DescribeNatFirewallControlPolicyResponseBodyPolicys[];
|
|
2283
2466
|
requestId?: string;
|
|
2284
|
-
totalCount?:
|
|
2467
|
+
totalCount?: string;
|
|
2285
2468
|
static names(): { [key: string]: string } {
|
|
2286
2469
|
return {
|
|
2287
|
-
|
|
2470
|
+
policys: 'Policys',
|
|
2288
2471
|
requestId: 'RequestId',
|
|
2289
2472
|
totalCount: 'TotalCount',
|
|
2290
2473
|
};
|
|
@@ -2292,9 +2475,9 @@ export class DescribeOutgoingDestinationIPResponseBody extends $tea.Model {
|
|
|
2292
2475
|
|
|
2293
2476
|
static types(): { [key: string]: any } {
|
|
2294
2477
|
return {
|
|
2295
|
-
|
|
2478
|
+
policys: { 'type': 'array', 'itemType': DescribeNatFirewallControlPolicyResponseBodyPolicys },
|
|
2296
2479
|
requestId: 'string',
|
|
2297
|
-
totalCount: '
|
|
2480
|
+
totalCount: 'string',
|
|
2298
2481
|
};
|
|
2299
2482
|
}
|
|
2300
2483
|
|
|
@@ -2303,10 +2486,10 @@ export class DescribeOutgoingDestinationIPResponseBody extends $tea.Model {
|
|
|
2303
2486
|
}
|
|
2304
2487
|
}
|
|
2305
2488
|
|
|
2306
|
-
export class
|
|
2489
|
+
export class DescribeNatFirewallControlPolicyResponse extends $tea.Model {
|
|
2307
2490
|
headers: { [key: string]: string };
|
|
2308
2491
|
statusCode: number;
|
|
2309
|
-
body:
|
|
2492
|
+
body: DescribeNatFirewallControlPolicyResponseBody;
|
|
2310
2493
|
static names(): { [key: string]: string } {
|
|
2311
2494
|
return {
|
|
2312
2495
|
headers: 'headers',
|
|
@@ -2319,7 +2502,7 @@ export class DescribeOutgoingDestinationIPResponse extends $tea.Model {
|
|
|
2319
2502
|
return {
|
|
2320
2503
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2321
2504
|
statusCode: 'number',
|
|
2322
|
-
body:
|
|
2505
|
+
body: DescribeNatFirewallControlPolicyResponseBody,
|
|
2323
2506
|
};
|
|
2324
2507
|
}
|
|
2325
2508
|
|
|
@@ -2328,23 +2511,209 @@ export class DescribeOutgoingDestinationIPResponse extends $tea.Model {
|
|
|
2328
2511
|
}
|
|
2329
2512
|
}
|
|
2330
2513
|
|
|
2331
|
-
export class
|
|
2332
|
-
|
|
2333
|
-
|
|
2334
|
-
domain?: string;
|
|
2335
|
-
endTime?: string;
|
|
2514
|
+
export class DescribeNatFirewallPolicyPriorUsedRequest extends $tea.Model {
|
|
2515
|
+
direction?: string;
|
|
2516
|
+
ipVersion?: string;
|
|
2336
2517
|
lang?: string;
|
|
2337
|
-
|
|
2338
|
-
pageSize?: string;
|
|
2339
|
-
publicIP?: string;
|
|
2340
|
-
sort?: string;
|
|
2341
|
-
startTime?: string;
|
|
2342
|
-
tagIdNew?: string;
|
|
2518
|
+
natGatewayId?: string;
|
|
2343
2519
|
static names(): { [key: string]: string } {
|
|
2344
2520
|
return {
|
|
2345
|
-
|
|
2346
|
-
|
|
2347
|
-
|
|
2521
|
+
direction: 'Direction',
|
|
2522
|
+
ipVersion: 'IpVersion',
|
|
2523
|
+
lang: 'Lang',
|
|
2524
|
+
natGatewayId: 'NatGatewayId',
|
|
2525
|
+
};
|
|
2526
|
+
}
|
|
2527
|
+
|
|
2528
|
+
static types(): { [key: string]: any } {
|
|
2529
|
+
return {
|
|
2530
|
+
direction: 'string',
|
|
2531
|
+
ipVersion: 'string',
|
|
2532
|
+
lang: 'string',
|
|
2533
|
+
natGatewayId: 'string',
|
|
2534
|
+
};
|
|
2535
|
+
}
|
|
2536
|
+
|
|
2537
|
+
constructor(map?: { [key: string]: any }) {
|
|
2538
|
+
super(map);
|
|
2539
|
+
}
|
|
2540
|
+
}
|
|
2541
|
+
|
|
2542
|
+
export class DescribeNatFirewallPolicyPriorUsedResponseBody extends $tea.Model {
|
|
2543
|
+
end?: number;
|
|
2544
|
+
requestId?: string;
|
|
2545
|
+
start?: number;
|
|
2546
|
+
static names(): { [key: string]: string } {
|
|
2547
|
+
return {
|
|
2548
|
+
end: 'End',
|
|
2549
|
+
requestId: 'RequestId',
|
|
2550
|
+
start: 'Start',
|
|
2551
|
+
};
|
|
2552
|
+
}
|
|
2553
|
+
|
|
2554
|
+
static types(): { [key: string]: any } {
|
|
2555
|
+
return {
|
|
2556
|
+
end: 'number',
|
|
2557
|
+
requestId: 'string',
|
|
2558
|
+
start: 'number',
|
|
2559
|
+
};
|
|
2560
|
+
}
|
|
2561
|
+
|
|
2562
|
+
constructor(map?: { [key: string]: any }) {
|
|
2563
|
+
super(map);
|
|
2564
|
+
}
|
|
2565
|
+
}
|
|
2566
|
+
|
|
2567
|
+
export class DescribeNatFirewallPolicyPriorUsedResponse extends $tea.Model {
|
|
2568
|
+
headers: { [key: string]: string };
|
|
2569
|
+
statusCode: number;
|
|
2570
|
+
body: DescribeNatFirewallPolicyPriorUsedResponseBody;
|
|
2571
|
+
static names(): { [key: string]: string } {
|
|
2572
|
+
return {
|
|
2573
|
+
headers: 'headers',
|
|
2574
|
+
statusCode: 'statusCode',
|
|
2575
|
+
body: 'body',
|
|
2576
|
+
};
|
|
2577
|
+
}
|
|
2578
|
+
|
|
2579
|
+
static types(): { [key: string]: any } {
|
|
2580
|
+
return {
|
|
2581
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2582
|
+
statusCode: 'number',
|
|
2583
|
+
body: DescribeNatFirewallPolicyPriorUsedResponseBody,
|
|
2584
|
+
};
|
|
2585
|
+
}
|
|
2586
|
+
|
|
2587
|
+
constructor(map?: { [key: string]: any }) {
|
|
2588
|
+
super(map);
|
|
2589
|
+
}
|
|
2590
|
+
}
|
|
2591
|
+
|
|
2592
|
+
export class DescribeOutgoingDestinationIPRequest extends $tea.Model {
|
|
2593
|
+
applicationName?: string;
|
|
2594
|
+
categoryId?: string;
|
|
2595
|
+
currentPage?: string;
|
|
2596
|
+
dstIP?: string;
|
|
2597
|
+
endTime?: string;
|
|
2598
|
+
lang?: string;
|
|
2599
|
+
order?: string;
|
|
2600
|
+
pageSize?: string;
|
|
2601
|
+
port?: string;
|
|
2602
|
+
privateIP?: string;
|
|
2603
|
+
publicIP?: string;
|
|
2604
|
+
sort?: string;
|
|
2605
|
+
startTime?: string;
|
|
2606
|
+
tagIdNew?: string;
|
|
2607
|
+
static names(): { [key: string]: string } {
|
|
2608
|
+
return {
|
|
2609
|
+
applicationName: 'ApplicationName',
|
|
2610
|
+
categoryId: 'CategoryId',
|
|
2611
|
+
currentPage: 'CurrentPage',
|
|
2612
|
+
dstIP: 'DstIP',
|
|
2613
|
+
endTime: 'EndTime',
|
|
2614
|
+
lang: 'Lang',
|
|
2615
|
+
order: 'Order',
|
|
2616
|
+
pageSize: 'PageSize',
|
|
2617
|
+
port: 'Port',
|
|
2618
|
+
privateIP: 'PrivateIP',
|
|
2619
|
+
publicIP: 'PublicIP',
|
|
2620
|
+
sort: 'Sort',
|
|
2621
|
+
startTime: 'StartTime',
|
|
2622
|
+
tagIdNew: 'TagIdNew',
|
|
2623
|
+
};
|
|
2624
|
+
}
|
|
2625
|
+
|
|
2626
|
+
static types(): { [key: string]: any } {
|
|
2627
|
+
return {
|
|
2628
|
+
applicationName: 'string',
|
|
2629
|
+
categoryId: 'string',
|
|
2630
|
+
currentPage: 'string',
|
|
2631
|
+
dstIP: 'string',
|
|
2632
|
+
endTime: 'string',
|
|
2633
|
+
lang: 'string',
|
|
2634
|
+
order: 'string',
|
|
2635
|
+
pageSize: 'string',
|
|
2636
|
+
port: 'string',
|
|
2637
|
+
privateIP: 'string',
|
|
2638
|
+
publicIP: 'string',
|
|
2639
|
+
sort: 'string',
|
|
2640
|
+
startTime: 'string',
|
|
2641
|
+
tagIdNew: 'string',
|
|
2642
|
+
};
|
|
2643
|
+
}
|
|
2644
|
+
|
|
2645
|
+
constructor(map?: { [key: string]: any }) {
|
|
2646
|
+
super(map);
|
|
2647
|
+
}
|
|
2648
|
+
}
|
|
2649
|
+
|
|
2650
|
+
export class DescribeOutgoingDestinationIPResponseBody extends $tea.Model {
|
|
2651
|
+
dstIPList?: DescribeOutgoingDestinationIPResponseBodyDstIPList[];
|
|
2652
|
+
requestId?: string;
|
|
2653
|
+
totalCount?: number;
|
|
2654
|
+
static names(): { [key: string]: string } {
|
|
2655
|
+
return {
|
|
2656
|
+
dstIPList: 'DstIPList',
|
|
2657
|
+
requestId: 'RequestId',
|
|
2658
|
+
totalCount: 'TotalCount',
|
|
2659
|
+
};
|
|
2660
|
+
}
|
|
2661
|
+
|
|
2662
|
+
static types(): { [key: string]: any } {
|
|
2663
|
+
return {
|
|
2664
|
+
dstIPList: { 'type': 'array', 'itemType': DescribeOutgoingDestinationIPResponseBodyDstIPList },
|
|
2665
|
+
requestId: 'string',
|
|
2666
|
+
totalCount: 'number',
|
|
2667
|
+
};
|
|
2668
|
+
}
|
|
2669
|
+
|
|
2670
|
+
constructor(map?: { [key: string]: any }) {
|
|
2671
|
+
super(map);
|
|
2672
|
+
}
|
|
2673
|
+
}
|
|
2674
|
+
|
|
2675
|
+
export class DescribeOutgoingDestinationIPResponse extends $tea.Model {
|
|
2676
|
+
headers: { [key: string]: string };
|
|
2677
|
+
statusCode: number;
|
|
2678
|
+
body: DescribeOutgoingDestinationIPResponseBody;
|
|
2679
|
+
static names(): { [key: string]: string } {
|
|
2680
|
+
return {
|
|
2681
|
+
headers: 'headers',
|
|
2682
|
+
statusCode: 'statusCode',
|
|
2683
|
+
body: 'body',
|
|
2684
|
+
};
|
|
2685
|
+
}
|
|
2686
|
+
|
|
2687
|
+
static types(): { [key: string]: any } {
|
|
2688
|
+
return {
|
|
2689
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2690
|
+
statusCode: 'number',
|
|
2691
|
+
body: DescribeOutgoingDestinationIPResponseBody,
|
|
2692
|
+
};
|
|
2693
|
+
}
|
|
2694
|
+
|
|
2695
|
+
constructor(map?: { [key: string]: any }) {
|
|
2696
|
+
super(map);
|
|
2697
|
+
}
|
|
2698
|
+
}
|
|
2699
|
+
|
|
2700
|
+
export class DescribeOutgoingDomainRequest extends $tea.Model {
|
|
2701
|
+
categoryId?: string;
|
|
2702
|
+
currentPage?: string;
|
|
2703
|
+
domain?: string;
|
|
2704
|
+
endTime?: string;
|
|
2705
|
+
lang?: string;
|
|
2706
|
+
order?: string;
|
|
2707
|
+
pageSize?: string;
|
|
2708
|
+
publicIP?: string;
|
|
2709
|
+
sort?: string;
|
|
2710
|
+
startTime?: string;
|
|
2711
|
+
tagIdNew?: string;
|
|
2712
|
+
static names(): { [key: string]: string } {
|
|
2713
|
+
return {
|
|
2714
|
+
categoryId: 'CategoryId',
|
|
2715
|
+
currentPage: 'CurrentPage',
|
|
2716
|
+
domain: 'Domain',
|
|
2348
2717
|
endTime: 'EndTime',
|
|
2349
2718
|
lang: 'Lang',
|
|
2350
2719
|
order: 'Order',
|
|
@@ -2706,6 +3075,126 @@ export class DescribeRiskEventGroupResponse extends $tea.Model {
|
|
|
2706
3075
|
}
|
|
2707
3076
|
}
|
|
2708
3077
|
|
|
3078
|
+
export class DescribeRiskEventPayloadRequest extends $tea.Model {
|
|
3079
|
+
dstIP?: string;
|
|
3080
|
+
dstVpcId?: string;
|
|
3081
|
+
endTime?: string;
|
|
3082
|
+
firewallType?: string;
|
|
3083
|
+
publicIP?: string;
|
|
3084
|
+
srcIP?: string;
|
|
3085
|
+
srcVpcId?: string;
|
|
3086
|
+
startTime?: string;
|
|
3087
|
+
UUID?: string;
|
|
3088
|
+
static names(): { [key: string]: string } {
|
|
3089
|
+
return {
|
|
3090
|
+
dstIP: 'DstIP',
|
|
3091
|
+
dstVpcId: 'DstVpcId',
|
|
3092
|
+
endTime: 'EndTime',
|
|
3093
|
+
firewallType: 'FirewallType',
|
|
3094
|
+
publicIP: 'PublicIP',
|
|
3095
|
+
srcIP: 'SrcIP',
|
|
3096
|
+
srcVpcId: 'SrcVpcId',
|
|
3097
|
+
startTime: 'StartTime',
|
|
3098
|
+
UUID: 'UUID',
|
|
3099
|
+
};
|
|
3100
|
+
}
|
|
3101
|
+
|
|
3102
|
+
static types(): { [key: string]: any } {
|
|
3103
|
+
return {
|
|
3104
|
+
dstIP: 'string',
|
|
3105
|
+
dstVpcId: 'string',
|
|
3106
|
+
endTime: 'string',
|
|
3107
|
+
firewallType: 'string',
|
|
3108
|
+
publicIP: 'string',
|
|
3109
|
+
srcIP: 'string',
|
|
3110
|
+
srcVpcId: 'string',
|
|
3111
|
+
startTime: 'string',
|
|
3112
|
+
UUID: 'string',
|
|
3113
|
+
};
|
|
3114
|
+
}
|
|
3115
|
+
|
|
3116
|
+
constructor(map?: { [key: string]: any }) {
|
|
3117
|
+
super(map);
|
|
3118
|
+
}
|
|
3119
|
+
}
|
|
3120
|
+
|
|
3121
|
+
export class DescribeRiskEventPayloadResponseBody extends $tea.Model {
|
|
3122
|
+
dstIP?: string;
|
|
3123
|
+
dstPort?: number;
|
|
3124
|
+
dstVpcId?: string;
|
|
3125
|
+
payload?: string;
|
|
3126
|
+
payloadLen?: number;
|
|
3127
|
+
proto?: string;
|
|
3128
|
+
realIp?: string;
|
|
3129
|
+
requestId?: string;
|
|
3130
|
+
srcIP?: string;
|
|
3131
|
+
srcPort?: number;
|
|
3132
|
+
srcVpcId?: string;
|
|
3133
|
+
XForwardFor?: string;
|
|
3134
|
+
static names(): { [key: string]: string } {
|
|
3135
|
+
return {
|
|
3136
|
+
dstIP: 'DstIP',
|
|
3137
|
+
dstPort: 'DstPort',
|
|
3138
|
+
dstVpcId: 'DstVpcId',
|
|
3139
|
+
payload: 'Payload',
|
|
3140
|
+
payloadLen: 'PayloadLen',
|
|
3141
|
+
proto: 'Proto',
|
|
3142
|
+
realIp: 'RealIp',
|
|
3143
|
+
requestId: 'RequestId',
|
|
3144
|
+
srcIP: 'SrcIP',
|
|
3145
|
+
srcPort: 'SrcPort',
|
|
3146
|
+
srcVpcId: 'SrcVpcId',
|
|
3147
|
+
XForwardFor: 'XForwardFor',
|
|
3148
|
+
};
|
|
3149
|
+
}
|
|
3150
|
+
|
|
3151
|
+
static types(): { [key: string]: any } {
|
|
3152
|
+
return {
|
|
3153
|
+
dstIP: 'string',
|
|
3154
|
+
dstPort: 'number',
|
|
3155
|
+
dstVpcId: 'string',
|
|
3156
|
+
payload: 'string',
|
|
3157
|
+
payloadLen: 'number',
|
|
3158
|
+
proto: 'string',
|
|
3159
|
+
realIp: 'string',
|
|
3160
|
+
requestId: 'string',
|
|
3161
|
+
srcIP: 'string',
|
|
3162
|
+
srcPort: 'number',
|
|
3163
|
+
srcVpcId: 'string',
|
|
3164
|
+
XForwardFor: 'string',
|
|
3165
|
+
};
|
|
3166
|
+
}
|
|
3167
|
+
|
|
3168
|
+
constructor(map?: { [key: string]: any }) {
|
|
3169
|
+
super(map);
|
|
3170
|
+
}
|
|
3171
|
+
}
|
|
3172
|
+
|
|
3173
|
+
export class DescribeRiskEventPayloadResponse extends $tea.Model {
|
|
3174
|
+
headers: { [key: string]: string };
|
|
3175
|
+
statusCode: number;
|
|
3176
|
+
body: DescribeRiskEventPayloadResponseBody;
|
|
3177
|
+
static names(): { [key: string]: string } {
|
|
3178
|
+
return {
|
|
3179
|
+
headers: 'headers',
|
|
3180
|
+
statusCode: 'statusCode',
|
|
3181
|
+
body: 'body',
|
|
3182
|
+
};
|
|
3183
|
+
}
|
|
3184
|
+
|
|
3185
|
+
static types(): { [key: string]: any } {
|
|
3186
|
+
return {
|
|
3187
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3188
|
+
statusCode: 'number',
|
|
3189
|
+
body: DescribeRiskEventPayloadResponseBody,
|
|
3190
|
+
};
|
|
3191
|
+
}
|
|
3192
|
+
|
|
3193
|
+
constructor(map?: { [key: string]: any }) {
|
|
3194
|
+
super(map);
|
|
3195
|
+
}
|
|
3196
|
+
}
|
|
3197
|
+
|
|
2709
3198
|
export class DescribeTrFirewallPolicyBackUpAssociationListRequest extends $tea.Model {
|
|
2710
3199
|
firewallId?: string;
|
|
2711
3200
|
lang?: string;
|
|
@@ -4647,6 +5136,186 @@ export class ModifyInstanceMemberAttributesResponse extends $tea.Model {
|
|
|
4647
5136
|
}
|
|
4648
5137
|
}
|
|
4649
5138
|
|
|
5139
|
+
export class ModifyNatFirewallControlPolicyRequest extends $tea.Model {
|
|
5140
|
+
aclAction?: string;
|
|
5141
|
+
aclUuid?: string;
|
|
5142
|
+
applicationNameList?: string[];
|
|
5143
|
+
description?: string;
|
|
5144
|
+
destPort?: string;
|
|
5145
|
+
destPortGroup?: string;
|
|
5146
|
+
destPortType?: string;
|
|
5147
|
+
destination?: string;
|
|
5148
|
+
destinationType?: string;
|
|
5149
|
+
domainResolveType?: string;
|
|
5150
|
+
lang?: string;
|
|
5151
|
+
natGatewayId?: string;
|
|
5152
|
+
proto?: string;
|
|
5153
|
+
release?: string;
|
|
5154
|
+
source?: string;
|
|
5155
|
+
sourceType?: string;
|
|
5156
|
+
static names(): { [key: string]: string } {
|
|
5157
|
+
return {
|
|
5158
|
+
aclAction: 'AclAction',
|
|
5159
|
+
aclUuid: 'AclUuid',
|
|
5160
|
+
applicationNameList: 'ApplicationNameList',
|
|
5161
|
+
description: 'Description',
|
|
5162
|
+
destPort: 'DestPort',
|
|
5163
|
+
destPortGroup: 'DestPortGroup',
|
|
5164
|
+
destPortType: 'DestPortType',
|
|
5165
|
+
destination: 'Destination',
|
|
5166
|
+
destinationType: 'DestinationType',
|
|
5167
|
+
domainResolveType: 'DomainResolveType',
|
|
5168
|
+
lang: 'Lang',
|
|
5169
|
+
natGatewayId: 'NatGatewayId',
|
|
5170
|
+
proto: 'Proto',
|
|
5171
|
+
release: 'Release',
|
|
5172
|
+
source: 'Source',
|
|
5173
|
+
sourceType: 'SourceType',
|
|
5174
|
+
};
|
|
5175
|
+
}
|
|
5176
|
+
|
|
5177
|
+
static types(): { [key: string]: any } {
|
|
5178
|
+
return {
|
|
5179
|
+
aclAction: 'string',
|
|
5180
|
+
aclUuid: 'string',
|
|
5181
|
+
applicationNameList: { 'type': 'array', 'itemType': 'string' },
|
|
5182
|
+
description: 'string',
|
|
5183
|
+
destPort: 'string',
|
|
5184
|
+
destPortGroup: 'string',
|
|
5185
|
+
destPortType: 'string',
|
|
5186
|
+
destination: 'string',
|
|
5187
|
+
destinationType: 'string',
|
|
5188
|
+
domainResolveType: 'string',
|
|
5189
|
+
lang: 'string',
|
|
5190
|
+
natGatewayId: 'string',
|
|
5191
|
+
proto: 'string',
|
|
5192
|
+
release: 'string',
|
|
5193
|
+
source: 'string',
|
|
5194
|
+
sourceType: 'string',
|
|
5195
|
+
};
|
|
5196
|
+
}
|
|
5197
|
+
|
|
5198
|
+
constructor(map?: { [key: string]: any }) {
|
|
5199
|
+
super(map);
|
|
5200
|
+
}
|
|
5201
|
+
}
|
|
5202
|
+
|
|
5203
|
+
export class ModifyNatFirewallControlPolicyResponseBody extends $tea.Model {
|
|
5204
|
+
requestId?: string;
|
|
5205
|
+
static names(): { [key: string]: string } {
|
|
5206
|
+
return {
|
|
5207
|
+
requestId: 'RequestId',
|
|
5208
|
+
};
|
|
5209
|
+
}
|
|
5210
|
+
|
|
5211
|
+
static types(): { [key: string]: any } {
|
|
5212
|
+
return {
|
|
5213
|
+
requestId: 'string',
|
|
5214
|
+
};
|
|
5215
|
+
}
|
|
5216
|
+
|
|
5217
|
+
constructor(map?: { [key: string]: any }) {
|
|
5218
|
+
super(map);
|
|
5219
|
+
}
|
|
5220
|
+
}
|
|
5221
|
+
|
|
5222
|
+
export class ModifyNatFirewallControlPolicyResponse extends $tea.Model {
|
|
5223
|
+
headers: { [key: string]: string };
|
|
5224
|
+
statusCode: number;
|
|
5225
|
+
body: ModifyNatFirewallControlPolicyResponseBody;
|
|
5226
|
+
static names(): { [key: string]: string } {
|
|
5227
|
+
return {
|
|
5228
|
+
headers: 'headers',
|
|
5229
|
+
statusCode: 'statusCode',
|
|
5230
|
+
body: 'body',
|
|
5231
|
+
};
|
|
5232
|
+
}
|
|
5233
|
+
|
|
5234
|
+
static types(): { [key: string]: any } {
|
|
5235
|
+
return {
|
|
5236
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
5237
|
+
statusCode: 'number',
|
|
5238
|
+
body: ModifyNatFirewallControlPolicyResponseBody,
|
|
5239
|
+
};
|
|
5240
|
+
}
|
|
5241
|
+
|
|
5242
|
+
constructor(map?: { [key: string]: any }) {
|
|
5243
|
+
super(map);
|
|
5244
|
+
}
|
|
5245
|
+
}
|
|
5246
|
+
|
|
5247
|
+
export class ModifyNatFirewallControlPolicyPositionRequest extends $tea.Model {
|
|
5248
|
+
aclUuid?: string;
|
|
5249
|
+
lang?: string;
|
|
5250
|
+
natGatewayId?: string;
|
|
5251
|
+
newOrder?: number;
|
|
5252
|
+
static names(): { [key: string]: string } {
|
|
5253
|
+
return {
|
|
5254
|
+
aclUuid: 'AclUuid',
|
|
5255
|
+
lang: 'Lang',
|
|
5256
|
+
natGatewayId: 'NatGatewayId',
|
|
5257
|
+
newOrder: 'NewOrder',
|
|
5258
|
+
};
|
|
5259
|
+
}
|
|
5260
|
+
|
|
5261
|
+
static types(): { [key: string]: any } {
|
|
5262
|
+
return {
|
|
5263
|
+
aclUuid: 'string',
|
|
5264
|
+
lang: 'string',
|
|
5265
|
+
natGatewayId: 'string',
|
|
5266
|
+
newOrder: 'number',
|
|
5267
|
+
};
|
|
5268
|
+
}
|
|
5269
|
+
|
|
5270
|
+
constructor(map?: { [key: string]: any }) {
|
|
5271
|
+
super(map);
|
|
5272
|
+
}
|
|
5273
|
+
}
|
|
5274
|
+
|
|
5275
|
+
export class ModifyNatFirewallControlPolicyPositionResponseBody extends $tea.Model {
|
|
5276
|
+
requestId?: string;
|
|
5277
|
+
static names(): { [key: string]: string } {
|
|
5278
|
+
return {
|
|
5279
|
+
requestId: 'RequestId',
|
|
5280
|
+
};
|
|
5281
|
+
}
|
|
5282
|
+
|
|
5283
|
+
static types(): { [key: string]: any } {
|
|
5284
|
+
return {
|
|
5285
|
+
requestId: 'string',
|
|
5286
|
+
};
|
|
5287
|
+
}
|
|
5288
|
+
|
|
5289
|
+
constructor(map?: { [key: string]: any }) {
|
|
5290
|
+
super(map);
|
|
5291
|
+
}
|
|
5292
|
+
}
|
|
5293
|
+
|
|
5294
|
+
export class ModifyNatFirewallControlPolicyPositionResponse extends $tea.Model {
|
|
5295
|
+
headers: { [key: string]: string };
|
|
5296
|
+
statusCode: number;
|
|
5297
|
+
body: ModifyNatFirewallControlPolicyPositionResponseBody;
|
|
5298
|
+
static names(): { [key: string]: string } {
|
|
5299
|
+
return {
|
|
5300
|
+
headers: 'headers',
|
|
5301
|
+
statusCode: 'statusCode',
|
|
5302
|
+
body: 'body',
|
|
5303
|
+
};
|
|
5304
|
+
}
|
|
5305
|
+
|
|
5306
|
+
static types(): { [key: string]: any } {
|
|
5307
|
+
return {
|
|
5308
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
5309
|
+
statusCode: 'number',
|
|
5310
|
+
body: ModifyNatFirewallControlPolicyPositionResponseBody,
|
|
5311
|
+
};
|
|
5312
|
+
}
|
|
5313
|
+
|
|
5314
|
+
constructor(map?: { [key: string]: any }) {
|
|
5315
|
+
super(map);
|
|
5316
|
+
}
|
|
5317
|
+
}
|
|
5318
|
+
|
|
4650
5319
|
export class ModifyPolicyAdvancedConfigRequest extends $tea.Model {
|
|
4651
5320
|
internetSwitch?: string;
|
|
4652
5321
|
lang?: string;
|
|
@@ -6427,9 +7096,109 @@ export class DescribeInvadeEventListResponseBodyPageInfo extends $tea.Model {
|
|
|
6427
7096
|
|
|
6428
7097
|
static types(): { [key: string]: any } {
|
|
6429
7098
|
return {
|
|
6430
|
-
currentPage: 'number',
|
|
6431
|
-
pageSize: 'number',
|
|
6432
|
-
totalCount: 'number',
|
|
7099
|
+
currentPage: 'number',
|
|
7100
|
+
pageSize: 'number',
|
|
7101
|
+
totalCount: 'number',
|
|
7102
|
+
};
|
|
7103
|
+
}
|
|
7104
|
+
|
|
7105
|
+
constructor(map?: { [key: string]: any }) {
|
|
7106
|
+
super(map);
|
|
7107
|
+
}
|
|
7108
|
+
}
|
|
7109
|
+
|
|
7110
|
+
export class DescribeNatFirewallControlPolicyResponseBodyPolicys extends $tea.Model {
|
|
7111
|
+
aclAction?: string;
|
|
7112
|
+
aclUuid?: string;
|
|
7113
|
+
applicationNameList?: string[];
|
|
7114
|
+
createTime?: number;
|
|
7115
|
+
description?: string;
|
|
7116
|
+
destPort?: string;
|
|
7117
|
+
destPortGroup?: string;
|
|
7118
|
+
destPortGroupPorts?: string[];
|
|
7119
|
+
destPortType?: string;
|
|
7120
|
+
destination?: string;
|
|
7121
|
+
destinationGroupCidrs?: string[];
|
|
7122
|
+
destinationGroupType?: string;
|
|
7123
|
+
destinationType?: string;
|
|
7124
|
+
dnsResult?: string;
|
|
7125
|
+
dnsResultTime?: number;
|
|
7126
|
+
domainResolveType?: number;
|
|
7127
|
+
hitLastTime?: number;
|
|
7128
|
+
hitTimes?: number;
|
|
7129
|
+
modifyTime?: number;
|
|
7130
|
+
natGatewayId?: string;
|
|
7131
|
+
order?: number;
|
|
7132
|
+
proto?: string;
|
|
7133
|
+
release?: string;
|
|
7134
|
+
source?: string;
|
|
7135
|
+
sourceGroupCidrs?: string[];
|
|
7136
|
+
sourceGroupType?: string;
|
|
7137
|
+
sourceType?: string;
|
|
7138
|
+
spreadCnt?: string;
|
|
7139
|
+
static names(): { [key: string]: string } {
|
|
7140
|
+
return {
|
|
7141
|
+
aclAction: 'AclAction',
|
|
7142
|
+
aclUuid: 'AclUuid',
|
|
7143
|
+
applicationNameList: 'ApplicationNameList',
|
|
7144
|
+
createTime: 'CreateTime',
|
|
7145
|
+
description: 'Description',
|
|
7146
|
+
destPort: 'DestPort',
|
|
7147
|
+
destPortGroup: 'DestPortGroup',
|
|
7148
|
+
destPortGroupPorts: 'DestPortGroupPorts',
|
|
7149
|
+
destPortType: 'DestPortType',
|
|
7150
|
+
destination: 'Destination',
|
|
7151
|
+
destinationGroupCidrs: 'DestinationGroupCidrs',
|
|
7152
|
+
destinationGroupType: 'DestinationGroupType',
|
|
7153
|
+
destinationType: 'DestinationType',
|
|
7154
|
+
dnsResult: 'DnsResult',
|
|
7155
|
+
dnsResultTime: 'DnsResultTime',
|
|
7156
|
+
domainResolveType: 'DomainResolveType',
|
|
7157
|
+
hitLastTime: 'HitLastTime',
|
|
7158
|
+
hitTimes: 'HitTimes',
|
|
7159
|
+
modifyTime: 'ModifyTime',
|
|
7160
|
+
natGatewayId: 'NatGatewayId',
|
|
7161
|
+
order: 'Order',
|
|
7162
|
+
proto: 'Proto',
|
|
7163
|
+
release: 'Release',
|
|
7164
|
+
source: 'Source',
|
|
7165
|
+
sourceGroupCidrs: 'SourceGroupCidrs',
|
|
7166
|
+
sourceGroupType: 'SourceGroupType',
|
|
7167
|
+
sourceType: 'SourceType',
|
|
7168
|
+
spreadCnt: 'SpreadCnt',
|
|
7169
|
+
};
|
|
7170
|
+
}
|
|
7171
|
+
|
|
7172
|
+
static types(): { [key: string]: any } {
|
|
7173
|
+
return {
|
|
7174
|
+
aclAction: 'string',
|
|
7175
|
+
aclUuid: 'string',
|
|
7176
|
+
applicationNameList: { 'type': 'array', 'itemType': 'string' },
|
|
7177
|
+
createTime: 'number',
|
|
7178
|
+
description: 'string',
|
|
7179
|
+
destPort: 'string',
|
|
7180
|
+
destPortGroup: 'string',
|
|
7181
|
+
destPortGroupPorts: { 'type': 'array', 'itemType': 'string' },
|
|
7182
|
+
destPortType: 'string',
|
|
7183
|
+
destination: 'string',
|
|
7184
|
+
destinationGroupCidrs: { 'type': 'array', 'itemType': 'string' },
|
|
7185
|
+
destinationGroupType: 'string',
|
|
7186
|
+
destinationType: 'string',
|
|
7187
|
+
dnsResult: 'string',
|
|
7188
|
+
dnsResultTime: 'number',
|
|
7189
|
+
domainResolveType: 'number',
|
|
7190
|
+
hitLastTime: 'number',
|
|
7191
|
+
hitTimes: 'number',
|
|
7192
|
+
modifyTime: 'number',
|
|
7193
|
+
natGatewayId: 'string',
|
|
7194
|
+
order: 'number',
|
|
7195
|
+
proto: 'string',
|
|
7196
|
+
release: 'string',
|
|
7197
|
+
source: 'string',
|
|
7198
|
+
sourceGroupCidrs: { 'type': 'array', 'itemType': 'string' },
|
|
7199
|
+
sourceGroupType: 'string',
|
|
7200
|
+
sourceType: 'string',
|
|
7201
|
+
spreadCnt: 'string',
|
|
6433
7202
|
};
|
|
6434
7203
|
}
|
|
6435
7204
|
|
|
@@ -8657,6 +9426,103 @@ export default class Client extends OpenApi {
|
|
|
8657
9426
|
return await this.batchCopyVpcFirewallControlPolicyWithOptions(request, runtime);
|
|
8658
9427
|
}
|
|
8659
9428
|
|
|
9429
|
+
async createNatFirewallControlPolicyWithOptions(request: CreateNatFirewallControlPolicyRequest, runtime: $Util.RuntimeOptions): Promise<CreateNatFirewallControlPolicyResponse> {
|
|
9430
|
+
Util.validateModel(request);
|
|
9431
|
+
let query = { };
|
|
9432
|
+
if (!Util.isUnset(request.aclAction)) {
|
|
9433
|
+
query["AclAction"] = request.aclAction;
|
|
9434
|
+
}
|
|
9435
|
+
|
|
9436
|
+
if (!Util.isUnset(request.applicationNameList)) {
|
|
9437
|
+
query["ApplicationNameList"] = request.applicationNameList;
|
|
9438
|
+
}
|
|
9439
|
+
|
|
9440
|
+
if (!Util.isUnset(request.description)) {
|
|
9441
|
+
query["Description"] = request.description;
|
|
9442
|
+
}
|
|
9443
|
+
|
|
9444
|
+
if (!Util.isUnset(request.destPort)) {
|
|
9445
|
+
query["DestPort"] = request.destPort;
|
|
9446
|
+
}
|
|
9447
|
+
|
|
9448
|
+
if (!Util.isUnset(request.destPortGroup)) {
|
|
9449
|
+
query["DestPortGroup"] = request.destPortGroup;
|
|
9450
|
+
}
|
|
9451
|
+
|
|
9452
|
+
if (!Util.isUnset(request.destPortType)) {
|
|
9453
|
+
query["DestPortType"] = request.destPortType;
|
|
9454
|
+
}
|
|
9455
|
+
|
|
9456
|
+
if (!Util.isUnset(request.destination)) {
|
|
9457
|
+
query["Destination"] = request.destination;
|
|
9458
|
+
}
|
|
9459
|
+
|
|
9460
|
+
if (!Util.isUnset(request.destinationType)) {
|
|
9461
|
+
query["DestinationType"] = request.destinationType;
|
|
9462
|
+
}
|
|
9463
|
+
|
|
9464
|
+
if (!Util.isUnset(request.direction)) {
|
|
9465
|
+
query["Direction"] = request.direction;
|
|
9466
|
+
}
|
|
9467
|
+
|
|
9468
|
+
if (!Util.isUnset(request.domainResolveType)) {
|
|
9469
|
+
query["DomainResolveType"] = request.domainResolveType;
|
|
9470
|
+
}
|
|
9471
|
+
|
|
9472
|
+
if (!Util.isUnset(request.ipVersion)) {
|
|
9473
|
+
query["IpVersion"] = request.ipVersion;
|
|
9474
|
+
}
|
|
9475
|
+
|
|
9476
|
+
if (!Util.isUnset(request.lang)) {
|
|
9477
|
+
query["Lang"] = request.lang;
|
|
9478
|
+
}
|
|
9479
|
+
|
|
9480
|
+
if (!Util.isUnset(request.natGatewayId)) {
|
|
9481
|
+
query["NatGatewayId"] = request.natGatewayId;
|
|
9482
|
+
}
|
|
9483
|
+
|
|
9484
|
+
if (!Util.isUnset(request.newOrder)) {
|
|
9485
|
+
query["NewOrder"] = request.newOrder;
|
|
9486
|
+
}
|
|
9487
|
+
|
|
9488
|
+
if (!Util.isUnset(request.proto)) {
|
|
9489
|
+
query["Proto"] = request.proto;
|
|
9490
|
+
}
|
|
9491
|
+
|
|
9492
|
+
if (!Util.isUnset(request.release)) {
|
|
9493
|
+
query["Release"] = request.release;
|
|
9494
|
+
}
|
|
9495
|
+
|
|
9496
|
+
if (!Util.isUnset(request.source)) {
|
|
9497
|
+
query["Source"] = request.source;
|
|
9498
|
+
}
|
|
9499
|
+
|
|
9500
|
+
if (!Util.isUnset(request.sourceType)) {
|
|
9501
|
+
query["SourceType"] = request.sourceType;
|
|
9502
|
+
}
|
|
9503
|
+
|
|
9504
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
9505
|
+
query: OpenApiUtil.query(query),
|
|
9506
|
+
});
|
|
9507
|
+
let params = new $OpenApi.Params({
|
|
9508
|
+
action: "CreateNatFirewallControlPolicy",
|
|
9509
|
+
version: "2017-12-07",
|
|
9510
|
+
protocol: "HTTPS",
|
|
9511
|
+
pathname: "/",
|
|
9512
|
+
method: "POST",
|
|
9513
|
+
authType: "AK",
|
|
9514
|
+
style: "RPC",
|
|
9515
|
+
reqBodyType: "formData",
|
|
9516
|
+
bodyType: "json",
|
|
9517
|
+
});
|
|
9518
|
+
return $tea.cast<CreateNatFirewallControlPolicyResponse>(await this.callApi(params, req, runtime), new CreateNatFirewallControlPolicyResponse({}));
|
|
9519
|
+
}
|
|
9520
|
+
|
|
9521
|
+
async createNatFirewallControlPolicy(request: CreateNatFirewallControlPolicyRequest): Promise<CreateNatFirewallControlPolicyResponse> {
|
|
9522
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
9523
|
+
return await this.createNatFirewallControlPolicyWithOptions(request, runtime);
|
|
9524
|
+
}
|
|
9525
|
+
|
|
8660
9526
|
async createTrFirewallV2WithOptions(request: CreateTrFirewallV2Request, runtime: $Util.RuntimeOptions): Promise<CreateTrFirewallV2Response> {
|
|
8661
9527
|
Util.validateModel(request);
|
|
8662
9528
|
let query = { };
|
|
@@ -9266,6 +10132,47 @@ export default class Client extends OpenApi {
|
|
|
9266
10132
|
return await this.deleteInstanceMembersWithOptions(request, runtime);
|
|
9267
10133
|
}
|
|
9268
10134
|
|
|
10135
|
+
async deleteNatFirewallControlPolicyWithOptions(request: DeleteNatFirewallControlPolicyRequest, runtime: $Util.RuntimeOptions): Promise<DeleteNatFirewallControlPolicyResponse> {
|
|
10136
|
+
Util.validateModel(request);
|
|
10137
|
+
let query = { };
|
|
10138
|
+
if (!Util.isUnset(request.aclUuid)) {
|
|
10139
|
+
query["AclUuid"] = request.aclUuid;
|
|
10140
|
+
}
|
|
10141
|
+
|
|
10142
|
+
if (!Util.isUnset(request.direction)) {
|
|
10143
|
+
query["Direction"] = request.direction;
|
|
10144
|
+
}
|
|
10145
|
+
|
|
10146
|
+
if (!Util.isUnset(request.lang)) {
|
|
10147
|
+
query["Lang"] = request.lang;
|
|
10148
|
+
}
|
|
10149
|
+
|
|
10150
|
+
if (!Util.isUnset(request.natGatewayId)) {
|
|
10151
|
+
query["NatGatewayId"] = request.natGatewayId;
|
|
10152
|
+
}
|
|
10153
|
+
|
|
10154
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
10155
|
+
query: OpenApiUtil.query(query),
|
|
10156
|
+
});
|
|
10157
|
+
let params = new $OpenApi.Params({
|
|
10158
|
+
action: "DeleteNatFirewallControlPolicy",
|
|
10159
|
+
version: "2017-12-07",
|
|
10160
|
+
protocol: "HTTPS",
|
|
10161
|
+
pathname: "/",
|
|
10162
|
+
method: "POST",
|
|
10163
|
+
authType: "AK",
|
|
10164
|
+
style: "RPC",
|
|
10165
|
+
reqBodyType: "formData",
|
|
10166
|
+
bodyType: "json",
|
|
10167
|
+
});
|
|
10168
|
+
return $tea.cast<DeleteNatFirewallControlPolicyResponse>(await this.callApi(params, req, runtime), new DeleteNatFirewallControlPolicyResponse({}));
|
|
10169
|
+
}
|
|
10170
|
+
|
|
10171
|
+
async deleteNatFirewallControlPolicy(request: DeleteNatFirewallControlPolicyRequest): Promise<DeleteNatFirewallControlPolicyResponse> {
|
|
10172
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
10173
|
+
return await this.deleteNatFirewallControlPolicyWithOptions(request, runtime);
|
|
10174
|
+
}
|
|
10175
|
+
|
|
9269
10176
|
async deleteTrFirewallV2WithOptions(request: DeleteTrFirewallV2Request, runtime: $Util.RuntimeOptions): Promise<DeleteTrFirewallV2Response> {
|
|
9270
10177
|
Util.validateModel(request);
|
|
9271
10178
|
let query = { };
|
|
@@ -9929,86 +10836,200 @@ export default class Client extends OpenApi {
|
|
|
9929
10836
|
reqBodyType: "formData",
|
|
9930
10837
|
bodyType: "json",
|
|
9931
10838
|
});
|
|
9932
|
-
return $tea.cast<DescribeInternetTrafficTrendResponse>(await this.callApi(params, req, runtime), new DescribeInternetTrafficTrendResponse({}));
|
|
10839
|
+
return $tea.cast<DescribeInternetTrafficTrendResponse>(await this.callApi(params, req, runtime), new DescribeInternetTrafficTrendResponse({}));
|
|
10840
|
+
}
|
|
10841
|
+
|
|
10842
|
+
async describeInternetTrafficTrend(request: DescribeInternetTrafficTrendRequest): Promise<DescribeInternetTrafficTrendResponse> {
|
|
10843
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
10844
|
+
return await this.describeInternetTrafficTrendWithOptions(request, runtime);
|
|
10845
|
+
}
|
|
10846
|
+
|
|
10847
|
+
async describeInvadeEventListWithOptions(request: DescribeInvadeEventListRequest, runtime: $Util.RuntimeOptions): Promise<DescribeInvadeEventListResponse> {
|
|
10848
|
+
Util.validateModel(request);
|
|
10849
|
+
let query = { };
|
|
10850
|
+
if (!Util.isUnset(request.assetsIP)) {
|
|
10851
|
+
query["AssetsIP"] = request.assetsIP;
|
|
10852
|
+
}
|
|
10853
|
+
|
|
10854
|
+
if (!Util.isUnset(request.assetsInstanceId)) {
|
|
10855
|
+
query["AssetsInstanceId"] = request.assetsInstanceId;
|
|
10856
|
+
}
|
|
10857
|
+
|
|
10858
|
+
if (!Util.isUnset(request.assetsInstanceName)) {
|
|
10859
|
+
query["AssetsInstanceName"] = request.assetsInstanceName;
|
|
10860
|
+
}
|
|
10861
|
+
|
|
10862
|
+
if (!Util.isUnset(request.currentPage)) {
|
|
10863
|
+
query["CurrentPage"] = request.currentPage;
|
|
10864
|
+
}
|
|
10865
|
+
|
|
10866
|
+
if (!Util.isUnset(request.endTime)) {
|
|
10867
|
+
query["EndTime"] = request.endTime;
|
|
10868
|
+
}
|
|
10869
|
+
|
|
10870
|
+
if (!Util.isUnset(request.eventKey)) {
|
|
10871
|
+
query["EventKey"] = request.eventKey;
|
|
10872
|
+
}
|
|
10873
|
+
|
|
10874
|
+
if (!Util.isUnset(request.eventName)) {
|
|
10875
|
+
query["EventName"] = request.eventName;
|
|
10876
|
+
}
|
|
10877
|
+
|
|
10878
|
+
if (!Util.isUnset(request.eventUuid)) {
|
|
10879
|
+
query["EventUuid"] = request.eventUuid;
|
|
10880
|
+
}
|
|
10881
|
+
|
|
10882
|
+
if (!Util.isUnset(request.isIgnore)) {
|
|
10883
|
+
query["IsIgnore"] = request.isIgnore;
|
|
10884
|
+
}
|
|
10885
|
+
|
|
10886
|
+
if (!Util.isUnset(request.lang)) {
|
|
10887
|
+
query["Lang"] = request.lang;
|
|
10888
|
+
}
|
|
10889
|
+
|
|
10890
|
+
if (!Util.isUnset(request.memberUid)) {
|
|
10891
|
+
query["MemberUid"] = request.memberUid;
|
|
10892
|
+
}
|
|
10893
|
+
|
|
10894
|
+
if (!Util.isUnset(request.pageSize)) {
|
|
10895
|
+
query["PageSize"] = request.pageSize;
|
|
10896
|
+
}
|
|
10897
|
+
|
|
10898
|
+
if (!Util.isUnset(request.processStatusList)) {
|
|
10899
|
+
query["ProcessStatusList"] = request.processStatusList;
|
|
10900
|
+
}
|
|
10901
|
+
|
|
10902
|
+
if (!Util.isUnset(request.riskLevel)) {
|
|
10903
|
+
query["RiskLevel"] = request.riskLevel;
|
|
10904
|
+
}
|
|
10905
|
+
|
|
10906
|
+
if (!Util.isUnset(request.sourceIp)) {
|
|
10907
|
+
query["SourceIp"] = request.sourceIp;
|
|
10908
|
+
}
|
|
10909
|
+
|
|
10910
|
+
if (!Util.isUnset(request.startTime)) {
|
|
10911
|
+
query["StartTime"] = request.startTime;
|
|
10912
|
+
}
|
|
10913
|
+
|
|
10914
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
10915
|
+
query: OpenApiUtil.query(query),
|
|
10916
|
+
});
|
|
10917
|
+
let params = new $OpenApi.Params({
|
|
10918
|
+
action: "DescribeInvadeEventList",
|
|
10919
|
+
version: "2017-12-07",
|
|
10920
|
+
protocol: "HTTPS",
|
|
10921
|
+
pathname: "/",
|
|
10922
|
+
method: "POST",
|
|
10923
|
+
authType: "AK",
|
|
10924
|
+
style: "RPC",
|
|
10925
|
+
reqBodyType: "formData",
|
|
10926
|
+
bodyType: "json",
|
|
10927
|
+
});
|
|
10928
|
+
return $tea.cast<DescribeInvadeEventListResponse>(await this.callApi(params, req, runtime), new DescribeInvadeEventListResponse({}));
|
|
9933
10929
|
}
|
|
9934
10930
|
|
|
9935
|
-
async
|
|
10931
|
+
async describeInvadeEventList(request: DescribeInvadeEventListRequest): Promise<DescribeInvadeEventListResponse> {
|
|
9936
10932
|
let runtime = new $Util.RuntimeOptions({ });
|
|
9937
|
-
return await this.
|
|
10933
|
+
return await this.describeInvadeEventListWithOptions(request, runtime);
|
|
9938
10934
|
}
|
|
9939
10935
|
|
|
9940
|
-
async
|
|
10936
|
+
async describeNatFirewallControlPolicyWithOptions(request: DescribeNatFirewallControlPolicyRequest, runtime: $Util.RuntimeOptions): Promise<DescribeNatFirewallControlPolicyResponse> {
|
|
9941
10937
|
Util.validateModel(request);
|
|
9942
10938
|
let query = { };
|
|
9943
|
-
if (!Util.isUnset(request.
|
|
9944
|
-
query["
|
|
9945
|
-
}
|
|
9946
|
-
|
|
9947
|
-
if (!Util.isUnset(request.assetsInstanceId)) {
|
|
9948
|
-
query["AssetsInstanceId"] = request.assetsInstanceId;
|
|
10939
|
+
if (!Util.isUnset(request.aclAction)) {
|
|
10940
|
+
query["AclAction"] = request.aclAction;
|
|
9949
10941
|
}
|
|
9950
10942
|
|
|
9951
|
-
if (!Util.isUnset(request.
|
|
9952
|
-
query["
|
|
10943
|
+
if (!Util.isUnset(request.aclUuid)) {
|
|
10944
|
+
query["AclUuid"] = request.aclUuid;
|
|
9953
10945
|
}
|
|
9954
10946
|
|
|
9955
10947
|
if (!Util.isUnset(request.currentPage)) {
|
|
9956
10948
|
query["CurrentPage"] = request.currentPage;
|
|
9957
10949
|
}
|
|
9958
10950
|
|
|
9959
|
-
if (!Util.isUnset(request.
|
|
9960
|
-
query["
|
|
9961
|
-
}
|
|
9962
|
-
|
|
9963
|
-
if (!Util.isUnset(request.eventKey)) {
|
|
9964
|
-
query["EventKey"] = request.eventKey;
|
|
9965
|
-
}
|
|
9966
|
-
|
|
9967
|
-
if (!Util.isUnset(request.eventName)) {
|
|
9968
|
-
query["EventName"] = request.eventName;
|
|
10951
|
+
if (!Util.isUnset(request.description)) {
|
|
10952
|
+
query["Description"] = request.description;
|
|
9969
10953
|
}
|
|
9970
10954
|
|
|
9971
|
-
if (!Util.isUnset(request.
|
|
9972
|
-
query["
|
|
10955
|
+
if (!Util.isUnset(request.destination)) {
|
|
10956
|
+
query["Destination"] = request.destination;
|
|
9973
10957
|
}
|
|
9974
10958
|
|
|
9975
|
-
if (!Util.isUnset(request.
|
|
9976
|
-
query["
|
|
10959
|
+
if (!Util.isUnset(request.direction)) {
|
|
10960
|
+
query["Direction"] = request.direction;
|
|
9977
10961
|
}
|
|
9978
10962
|
|
|
9979
10963
|
if (!Util.isUnset(request.lang)) {
|
|
9980
10964
|
query["Lang"] = request.lang;
|
|
9981
10965
|
}
|
|
9982
10966
|
|
|
9983
|
-
if (!Util.isUnset(request.
|
|
9984
|
-
query["
|
|
10967
|
+
if (!Util.isUnset(request.natGatewayId)) {
|
|
10968
|
+
query["NatGatewayId"] = request.natGatewayId;
|
|
9985
10969
|
}
|
|
9986
10970
|
|
|
9987
10971
|
if (!Util.isUnset(request.pageSize)) {
|
|
9988
10972
|
query["PageSize"] = request.pageSize;
|
|
9989
10973
|
}
|
|
9990
10974
|
|
|
9991
|
-
if (!Util.isUnset(request.
|
|
9992
|
-
query["
|
|
10975
|
+
if (!Util.isUnset(request.proto)) {
|
|
10976
|
+
query["Proto"] = request.proto;
|
|
9993
10977
|
}
|
|
9994
10978
|
|
|
9995
|
-
if (!Util.isUnset(request.
|
|
9996
|
-
query["
|
|
10979
|
+
if (!Util.isUnset(request.release)) {
|
|
10980
|
+
query["Release"] = request.release;
|
|
9997
10981
|
}
|
|
9998
10982
|
|
|
9999
|
-
if (!Util.isUnset(request.
|
|
10000
|
-
query["
|
|
10983
|
+
if (!Util.isUnset(request.source)) {
|
|
10984
|
+
query["Source"] = request.source;
|
|
10001
10985
|
}
|
|
10002
10986
|
|
|
10003
|
-
|
|
10004
|
-
query
|
|
10987
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
10988
|
+
query: OpenApiUtil.query(query),
|
|
10989
|
+
});
|
|
10990
|
+
let params = new $OpenApi.Params({
|
|
10991
|
+
action: "DescribeNatFirewallControlPolicy",
|
|
10992
|
+
version: "2017-12-07",
|
|
10993
|
+
protocol: "HTTPS",
|
|
10994
|
+
pathname: "/",
|
|
10995
|
+
method: "POST",
|
|
10996
|
+
authType: "AK",
|
|
10997
|
+
style: "RPC",
|
|
10998
|
+
reqBodyType: "formData",
|
|
10999
|
+
bodyType: "json",
|
|
11000
|
+
});
|
|
11001
|
+
return $tea.cast<DescribeNatFirewallControlPolicyResponse>(await this.callApi(params, req, runtime), new DescribeNatFirewallControlPolicyResponse({}));
|
|
11002
|
+
}
|
|
11003
|
+
|
|
11004
|
+
async describeNatFirewallControlPolicy(request: DescribeNatFirewallControlPolicyRequest): Promise<DescribeNatFirewallControlPolicyResponse> {
|
|
11005
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
11006
|
+
return await this.describeNatFirewallControlPolicyWithOptions(request, runtime);
|
|
11007
|
+
}
|
|
11008
|
+
|
|
11009
|
+
async describeNatFirewallPolicyPriorUsedWithOptions(request: DescribeNatFirewallPolicyPriorUsedRequest, runtime: $Util.RuntimeOptions): Promise<DescribeNatFirewallPolicyPriorUsedResponse> {
|
|
11010
|
+
Util.validateModel(request);
|
|
11011
|
+
let query = { };
|
|
11012
|
+
if (!Util.isUnset(request.direction)) {
|
|
11013
|
+
query["Direction"] = request.direction;
|
|
11014
|
+
}
|
|
11015
|
+
|
|
11016
|
+
if (!Util.isUnset(request.ipVersion)) {
|
|
11017
|
+
query["IpVersion"] = request.ipVersion;
|
|
11018
|
+
}
|
|
11019
|
+
|
|
11020
|
+
if (!Util.isUnset(request.lang)) {
|
|
11021
|
+
query["Lang"] = request.lang;
|
|
11022
|
+
}
|
|
11023
|
+
|
|
11024
|
+
if (!Util.isUnset(request.natGatewayId)) {
|
|
11025
|
+
query["NatGatewayId"] = request.natGatewayId;
|
|
10005
11026
|
}
|
|
10006
11027
|
|
|
10007
11028
|
let req = new $OpenApi.OpenApiRequest({
|
|
10008
11029
|
query: OpenApiUtil.query(query),
|
|
10009
11030
|
});
|
|
10010
11031
|
let params = new $OpenApi.Params({
|
|
10011
|
-
action: "
|
|
11032
|
+
action: "DescribeNatFirewallPolicyPriorUsed",
|
|
10012
11033
|
version: "2017-12-07",
|
|
10013
11034
|
protocol: "HTTPS",
|
|
10014
11035
|
pathname: "/",
|
|
@@ -10018,12 +11039,12 @@ export default class Client extends OpenApi {
|
|
|
10018
11039
|
reqBodyType: "formData",
|
|
10019
11040
|
bodyType: "json",
|
|
10020
11041
|
});
|
|
10021
|
-
return $tea.cast<
|
|
11042
|
+
return $tea.cast<DescribeNatFirewallPolicyPriorUsedResponse>(await this.callApi(params, req, runtime), new DescribeNatFirewallPolicyPriorUsedResponse({}));
|
|
10022
11043
|
}
|
|
10023
11044
|
|
|
10024
|
-
async
|
|
11045
|
+
async describeNatFirewallPolicyPriorUsed(request: DescribeNatFirewallPolicyPriorUsedRequest): Promise<DescribeNatFirewallPolicyPriorUsedResponse> {
|
|
10025
11046
|
let runtime = new $Util.RuntimeOptions({ });
|
|
10026
|
-
return await this.
|
|
11047
|
+
return await this.describeNatFirewallPolicyPriorUsedWithOptions(request, runtime);
|
|
10027
11048
|
}
|
|
10028
11049
|
|
|
10029
11050
|
async describeOutgoingDestinationIPWithOptions(request: DescribeOutgoingDestinationIPRequest, runtime: $Util.RuntimeOptions): Promise<DescribeOutgoingDestinationIPResponse> {
|
|
@@ -10422,6 +11443,67 @@ export default class Client extends OpenApi {
|
|
|
10422
11443
|
return await this.describeRiskEventGroupWithOptions(request, runtime);
|
|
10423
11444
|
}
|
|
10424
11445
|
|
|
11446
|
+
async describeRiskEventPayloadWithOptions(request: DescribeRiskEventPayloadRequest, runtime: $Util.RuntimeOptions): Promise<DescribeRiskEventPayloadResponse> {
|
|
11447
|
+
Util.validateModel(request);
|
|
11448
|
+
let query = { };
|
|
11449
|
+
if (!Util.isUnset(request.dstIP)) {
|
|
11450
|
+
query["DstIP"] = request.dstIP;
|
|
11451
|
+
}
|
|
11452
|
+
|
|
11453
|
+
if (!Util.isUnset(request.dstVpcId)) {
|
|
11454
|
+
query["DstVpcId"] = request.dstVpcId;
|
|
11455
|
+
}
|
|
11456
|
+
|
|
11457
|
+
if (!Util.isUnset(request.endTime)) {
|
|
11458
|
+
query["EndTime"] = request.endTime;
|
|
11459
|
+
}
|
|
11460
|
+
|
|
11461
|
+
if (!Util.isUnset(request.firewallType)) {
|
|
11462
|
+
query["FirewallType"] = request.firewallType;
|
|
11463
|
+
}
|
|
11464
|
+
|
|
11465
|
+
if (!Util.isUnset(request.publicIP)) {
|
|
11466
|
+
query["PublicIP"] = request.publicIP;
|
|
11467
|
+
}
|
|
11468
|
+
|
|
11469
|
+
if (!Util.isUnset(request.srcIP)) {
|
|
11470
|
+
query["SrcIP"] = request.srcIP;
|
|
11471
|
+
}
|
|
11472
|
+
|
|
11473
|
+
if (!Util.isUnset(request.srcVpcId)) {
|
|
11474
|
+
query["SrcVpcId"] = request.srcVpcId;
|
|
11475
|
+
}
|
|
11476
|
+
|
|
11477
|
+
if (!Util.isUnset(request.startTime)) {
|
|
11478
|
+
query["StartTime"] = request.startTime;
|
|
11479
|
+
}
|
|
11480
|
+
|
|
11481
|
+
if (!Util.isUnset(request.UUID)) {
|
|
11482
|
+
query["UUID"] = request.UUID;
|
|
11483
|
+
}
|
|
11484
|
+
|
|
11485
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
11486
|
+
query: OpenApiUtil.query(query),
|
|
11487
|
+
});
|
|
11488
|
+
let params = new $OpenApi.Params({
|
|
11489
|
+
action: "DescribeRiskEventPayload",
|
|
11490
|
+
version: "2017-12-07",
|
|
11491
|
+
protocol: "HTTPS",
|
|
11492
|
+
pathname: "/",
|
|
11493
|
+
method: "POST",
|
|
11494
|
+
authType: "AK",
|
|
11495
|
+
style: "RPC",
|
|
11496
|
+
reqBodyType: "formData",
|
|
11497
|
+
bodyType: "json",
|
|
11498
|
+
});
|
|
11499
|
+
return $tea.cast<DescribeRiskEventPayloadResponse>(await this.callApi(params, req, runtime), new DescribeRiskEventPayloadResponse({}));
|
|
11500
|
+
}
|
|
11501
|
+
|
|
11502
|
+
async describeRiskEventPayload(request: DescribeRiskEventPayloadRequest): Promise<DescribeRiskEventPayloadResponse> {
|
|
11503
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
11504
|
+
return await this.describeRiskEventPayloadWithOptions(request, runtime);
|
|
11505
|
+
}
|
|
11506
|
+
|
|
10425
11507
|
async describeTrFirewallPolicyBackUpAssociationListWithOptions(request: DescribeTrFirewallPolicyBackUpAssociationListRequest, runtime: $Util.RuntimeOptions): Promise<DescribeTrFirewallPolicyBackUpAssociationListResponse> {
|
|
10426
11508
|
Util.validateModel(request);
|
|
10427
11509
|
let query = { };
|
|
@@ -11774,6 +12856,136 @@ export default class Client extends OpenApi {
|
|
|
11774
12856
|
return await this.modifyInstanceMemberAttributesWithOptions(request, runtime);
|
|
11775
12857
|
}
|
|
11776
12858
|
|
|
12859
|
+
async modifyNatFirewallControlPolicyWithOptions(request: ModifyNatFirewallControlPolicyRequest, runtime: $Util.RuntimeOptions): Promise<ModifyNatFirewallControlPolicyResponse> {
|
|
12860
|
+
Util.validateModel(request);
|
|
12861
|
+
let query = { };
|
|
12862
|
+
if (!Util.isUnset(request.aclAction)) {
|
|
12863
|
+
query["AclAction"] = request.aclAction;
|
|
12864
|
+
}
|
|
12865
|
+
|
|
12866
|
+
if (!Util.isUnset(request.aclUuid)) {
|
|
12867
|
+
query["AclUuid"] = request.aclUuid;
|
|
12868
|
+
}
|
|
12869
|
+
|
|
12870
|
+
if (!Util.isUnset(request.applicationNameList)) {
|
|
12871
|
+
query["ApplicationNameList"] = request.applicationNameList;
|
|
12872
|
+
}
|
|
12873
|
+
|
|
12874
|
+
if (!Util.isUnset(request.description)) {
|
|
12875
|
+
query["Description"] = request.description;
|
|
12876
|
+
}
|
|
12877
|
+
|
|
12878
|
+
if (!Util.isUnset(request.destPort)) {
|
|
12879
|
+
query["DestPort"] = request.destPort;
|
|
12880
|
+
}
|
|
12881
|
+
|
|
12882
|
+
if (!Util.isUnset(request.destPortGroup)) {
|
|
12883
|
+
query["DestPortGroup"] = request.destPortGroup;
|
|
12884
|
+
}
|
|
12885
|
+
|
|
12886
|
+
if (!Util.isUnset(request.destPortType)) {
|
|
12887
|
+
query["DestPortType"] = request.destPortType;
|
|
12888
|
+
}
|
|
12889
|
+
|
|
12890
|
+
if (!Util.isUnset(request.destination)) {
|
|
12891
|
+
query["Destination"] = request.destination;
|
|
12892
|
+
}
|
|
12893
|
+
|
|
12894
|
+
if (!Util.isUnset(request.destinationType)) {
|
|
12895
|
+
query["DestinationType"] = request.destinationType;
|
|
12896
|
+
}
|
|
12897
|
+
|
|
12898
|
+
if (!Util.isUnset(request.domainResolveType)) {
|
|
12899
|
+
query["DomainResolveType"] = request.domainResolveType;
|
|
12900
|
+
}
|
|
12901
|
+
|
|
12902
|
+
if (!Util.isUnset(request.lang)) {
|
|
12903
|
+
query["Lang"] = request.lang;
|
|
12904
|
+
}
|
|
12905
|
+
|
|
12906
|
+
if (!Util.isUnset(request.natGatewayId)) {
|
|
12907
|
+
query["NatGatewayId"] = request.natGatewayId;
|
|
12908
|
+
}
|
|
12909
|
+
|
|
12910
|
+
if (!Util.isUnset(request.proto)) {
|
|
12911
|
+
query["Proto"] = request.proto;
|
|
12912
|
+
}
|
|
12913
|
+
|
|
12914
|
+
if (!Util.isUnset(request.release)) {
|
|
12915
|
+
query["Release"] = request.release;
|
|
12916
|
+
}
|
|
12917
|
+
|
|
12918
|
+
if (!Util.isUnset(request.source)) {
|
|
12919
|
+
query["Source"] = request.source;
|
|
12920
|
+
}
|
|
12921
|
+
|
|
12922
|
+
if (!Util.isUnset(request.sourceType)) {
|
|
12923
|
+
query["SourceType"] = request.sourceType;
|
|
12924
|
+
}
|
|
12925
|
+
|
|
12926
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
12927
|
+
query: OpenApiUtil.query(query),
|
|
12928
|
+
});
|
|
12929
|
+
let params = new $OpenApi.Params({
|
|
12930
|
+
action: "ModifyNatFirewallControlPolicy",
|
|
12931
|
+
version: "2017-12-07",
|
|
12932
|
+
protocol: "HTTPS",
|
|
12933
|
+
pathname: "/",
|
|
12934
|
+
method: "POST",
|
|
12935
|
+
authType: "AK",
|
|
12936
|
+
style: "RPC",
|
|
12937
|
+
reqBodyType: "formData",
|
|
12938
|
+
bodyType: "json",
|
|
12939
|
+
});
|
|
12940
|
+
return $tea.cast<ModifyNatFirewallControlPolicyResponse>(await this.callApi(params, req, runtime), new ModifyNatFirewallControlPolicyResponse({}));
|
|
12941
|
+
}
|
|
12942
|
+
|
|
12943
|
+
async modifyNatFirewallControlPolicy(request: ModifyNatFirewallControlPolicyRequest): Promise<ModifyNatFirewallControlPolicyResponse> {
|
|
12944
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
12945
|
+
return await this.modifyNatFirewallControlPolicyWithOptions(request, runtime);
|
|
12946
|
+
}
|
|
12947
|
+
|
|
12948
|
+
async modifyNatFirewallControlPolicyPositionWithOptions(request: ModifyNatFirewallControlPolicyPositionRequest, runtime: $Util.RuntimeOptions): Promise<ModifyNatFirewallControlPolicyPositionResponse> {
|
|
12949
|
+
Util.validateModel(request);
|
|
12950
|
+
let query = { };
|
|
12951
|
+
if (!Util.isUnset(request.aclUuid)) {
|
|
12952
|
+
query["AclUuid"] = request.aclUuid;
|
|
12953
|
+
}
|
|
12954
|
+
|
|
12955
|
+
if (!Util.isUnset(request.lang)) {
|
|
12956
|
+
query["Lang"] = request.lang;
|
|
12957
|
+
}
|
|
12958
|
+
|
|
12959
|
+
if (!Util.isUnset(request.natGatewayId)) {
|
|
12960
|
+
query["NatGatewayId"] = request.natGatewayId;
|
|
12961
|
+
}
|
|
12962
|
+
|
|
12963
|
+
if (!Util.isUnset(request.newOrder)) {
|
|
12964
|
+
query["NewOrder"] = request.newOrder;
|
|
12965
|
+
}
|
|
12966
|
+
|
|
12967
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
12968
|
+
query: OpenApiUtil.query(query),
|
|
12969
|
+
});
|
|
12970
|
+
let params = new $OpenApi.Params({
|
|
12971
|
+
action: "ModifyNatFirewallControlPolicyPosition",
|
|
12972
|
+
version: "2017-12-07",
|
|
12973
|
+
protocol: "HTTPS",
|
|
12974
|
+
pathname: "/",
|
|
12975
|
+
method: "POST",
|
|
12976
|
+
authType: "AK",
|
|
12977
|
+
style: "RPC",
|
|
12978
|
+
reqBodyType: "formData",
|
|
12979
|
+
bodyType: "json",
|
|
12980
|
+
});
|
|
12981
|
+
return $tea.cast<ModifyNatFirewallControlPolicyPositionResponse>(await this.callApi(params, req, runtime), new ModifyNatFirewallControlPolicyPositionResponse({}));
|
|
12982
|
+
}
|
|
12983
|
+
|
|
12984
|
+
async modifyNatFirewallControlPolicyPosition(request: ModifyNatFirewallControlPolicyPositionRequest): Promise<ModifyNatFirewallControlPolicyPositionResponse> {
|
|
12985
|
+
let runtime = new $Util.RuntimeOptions({ });
|
|
12986
|
+
return await this.modifyNatFirewallControlPolicyPositionWithOptions(request, runtime);
|
|
12987
|
+
}
|
|
12988
|
+
|
|
11777
12989
|
/**
|
|
11778
12990
|
* You can call the ModifyPolicyAdvancedConfig operation to enable or disable the strict mode for an access control policy.
|
|
11779
12991
|
* ## Limits
|