@alicloud/ga20191120 1.0.6 → 1.0.9
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/LICENSE +13 -0
- package/README.md +25 -0
- package/dist/client.d.ts +519 -0
- package/dist/client.js +2399 -644
- package/dist/client.js.map +1 -1
- package/package.json +3 -3
- package/src/client.ts +3062 -660
package/dist/client.js
CHANGED
|
@@ -519,6 +519,7 @@ class CreateAcceleratorRequest extends $tea.Model {
|
|
|
519
519
|
autoUseCoupon: 'AutoUseCoupon',
|
|
520
520
|
clientToken: 'ClientToken',
|
|
521
521
|
duration: 'Duration',
|
|
522
|
+
ipSetConfig: 'IpSetConfig',
|
|
522
523
|
name: 'Name',
|
|
523
524
|
pricingCycle: 'PricingCycle',
|
|
524
525
|
regionId: 'RegionId',
|
|
@@ -533,6 +534,7 @@ class CreateAcceleratorRequest extends $tea.Model {
|
|
|
533
534
|
autoUseCoupon: 'string',
|
|
534
535
|
clientToken: 'string',
|
|
535
536
|
duration: 'number',
|
|
537
|
+
ipSetConfig: CreateAcceleratorRequestIpSetConfig,
|
|
536
538
|
name: 'string',
|
|
537
539
|
pricingCycle: 'string',
|
|
538
540
|
regionId: 'string',
|
|
@@ -641,6 +643,72 @@ class CreateAclResponse extends $tea.Model {
|
|
|
641
643
|
}
|
|
642
644
|
}
|
|
643
645
|
exports.CreateAclResponse = CreateAclResponse;
|
|
646
|
+
class CreateApplicationMonitorRequest extends $tea.Model {
|
|
647
|
+
constructor(map) {
|
|
648
|
+
super(map);
|
|
649
|
+
}
|
|
650
|
+
static names() {
|
|
651
|
+
return {
|
|
652
|
+
acceleratorId: 'AcceleratorId',
|
|
653
|
+
address: 'Address',
|
|
654
|
+
clientToken: 'ClientToken',
|
|
655
|
+
detectThreshold: 'DetectThreshold',
|
|
656
|
+
listenerId: 'ListenerId',
|
|
657
|
+
optionsJson: 'OptionsJson',
|
|
658
|
+
regionId: 'RegionId',
|
|
659
|
+
taskName: 'TaskName',
|
|
660
|
+
};
|
|
661
|
+
}
|
|
662
|
+
static types() {
|
|
663
|
+
return {
|
|
664
|
+
acceleratorId: 'string',
|
|
665
|
+
address: 'string',
|
|
666
|
+
clientToken: 'string',
|
|
667
|
+
detectThreshold: 'number',
|
|
668
|
+
listenerId: 'string',
|
|
669
|
+
optionsJson: 'string',
|
|
670
|
+
regionId: 'string',
|
|
671
|
+
taskName: 'string',
|
|
672
|
+
};
|
|
673
|
+
}
|
|
674
|
+
}
|
|
675
|
+
exports.CreateApplicationMonitorRequest = CreateApplicationMonitorRequest;
|
|
676
|
+
class CreateApplicationMonitorResponseBody extends $tea.Model {
|
|
677
|
+
constructor(map) {
|
|
678
|
+
super(map);
|
|
679
|
+
}
|
|
680
|
+
static names() {
|
|
681
|
+
return {
|
|
682
|
+
requestId: 'RequestId',
|
|
683
|
+
taskId: 'TaskId',
|
|
684
|
+
};
|
|
685
|
+
}
|
|
686
|
+
static types() {
|
|
687
|
+
return {
|
|
688
|
+
requestId: 'string',
|
|
689
|
+
taskId: 'string',
|
|
690
|
+
};
|
|
691
|
+
}
|
|
692
|
+
}
|
|
693
|
+
exports.CreateApplicationMonitorResponseBody = CreateApplicationMonitorResponseBody;
|
|
694
|
+
class CreateApplicationMonitorResponse extends $tea.Model {
|
|
695
|
+
constructor(map) {
|
|
696
|
+
super(map);
|
|
697
|
+
}
|
|
698
|
+
static names() {
|
|
699
|
+
return {
|
|
700
|
+
headers: 'headers',
|
|
701
|
+
body: 'body',
|
|
702
|
+
};
|
|
703
|
+
}
|
|
704
|
+
static types() {
|
|
705
|
+
return {
|
|
706
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
707
|
+
body: CreateApplicationMonitorResponseBody,
|
|
708
|
+
};
|
|
709
|
+
}
|
|
710
|
+
}
|
|
711
|
+
exports.CreateApplicationMonitorResponse = CreateApplicationMonitorResponse;
|
|
644
712
|
class CreateBandwidthPackageRequest extends $tea.Model {
|
|
645
713
|
constructor(map) {
|
|
646
714
|
super(map);
|
|
@@ -1425,6 +1493,60 @@ class DeleteAclResponse extends $tea.Model {
|
|
|
1425
1493
|
}
|
|
1426
1494
|
}
|
|
1427
1495
|
exports.DeleteAclResponse = DeleteAclResponse;
|
|
1496
|
+
class DeleteApplicationMonitorRequest extends $tea.Model {
|
|
1497
|
+
constructor(map) {
|
|
1498
|
+
super(map);
|
|
1499
|
+
}
|
|
1500
|
+
static names() {
|
|
1501
|
+
return {
|
|
1502
|
+
clientToken: 'ClientToken',
|
|
1503
|
+
regionId: 'RegionId',
|
|
1504
|
+
taskId: 'TaskId',
|
|
1505
|
+
};
|
|
1506
|
+
}
|
|
1507
|
+
static types() {
|
|
1508
|
+
return {
|
|
1509
|
+
clientToken: 'string',
|
|
1510
|
+
regionId: 'string',
|
|
1511
|
+
taskId: 'string',
|
|
1512
|
+
};
|
|
1513
|
+
}
|
|
1514
|
+
}
|
|
1515
|
+
exports.DeleteApplicationMonitorRequest = DeleteApplicationMonitorRequest;
|
|
1516
|
+
class DeleteApplicationMonitorResponseBody extends $tea.Model {
|
|
1517
|
+
constructor(map) {
|
|
1518
|
+
super(map);
|
|
1519
|
+
}
|
|
1520
|
+
static names() {
|
|
1521
|
+
return {
|
|
1522
|
+
requestId: 'RequestId',
|
|
1523
|
+
};
|
|
1524
|
+
}
|
|
1525
|
+
static types() {
|
|
1526
|
+
return {
|
|
1527
|
+
requestId: 'string',
|
|
1528
|
+
};
|
|
1529
|
+
}
|
|
1530
|
+
}
|
|
1531
|
+
exports.DeleteApplicationMonitorResponseBody = DeleteApplicationMonitorResponseBody;
|
|
1532
|
+
class DeleteApplicationMonitorResponse extends $tea.Model {
|
|
1533
|
+
constructor(map) {
|
|
1534
|
+
super(map);
|
|
1535
|
+
}
|
|
1536
|
+
static names() {
|
|
1537
|
+
return {
|
|
1538
|
+
headers: 'headers',
|
|
1539
|
+
body: 'body',
|
|
1540
|
+
};
|
|
1541
|
+
}
|
|
1542
|
+
static types() {
|
|
1543
|
+
return {
|
|
1544
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1545
|
+
body: DeleteApplicationMonitorResponseBody,
|
|
1546
|
+
};
|
|
1547
|
+
}
|
|
1548
|
+
}
|
|
1549
|
+
exports.DeleteApplicationMonitorResponse = DeleteApplicationMonitorResponse;
|
|
1428
1550
|
class DeleteBandwidthPackageRequest extends $tea.Model {
|
|
1429
1551
|
constructor(map) {
|
|
1430
1552
|
super(map);
|
|
@@ -2065,6 +2187,7 @@ class DescribeAcceleratorResponseBody extends $tea.Model {
|
|
|
2065
2187
|
dnsName: 'DnsName',
|
|
2066
2188
|
expiredTime: 'ExpiredTime',
|
|
2067
2189
|
instanceChargeType: 'InstanceChargeType',
|
|
2190
|
+
ipSetConfig: 'IpSetConfig',
|
|
2068
2191
|
name: 'Name',
|
|
2069
2192
|
regionId: 'RegionId',
|
|
2070
2193
|
requestId: 'RequestId',
|
|
@@ -2085,6 +2208,7 @@ class DescribeAcceleratorResponseBody extends $tea.Model {
|
|
|
2085
2208
|
dnsName: 'string',
|
|
2086
2209
|
expiredTime: 'number',
|
|
2087
2210
|
instanceChargeType: 'string',
|
|
2211
|
+
ipSetConfig: DescribeAcceleratorResponseBodyIpSetConfig,
|
|
2088
2212
|
name: 'string',
|
|
2089
2213
|
regionId: 'string',
|
|
2090
2214
|
requestId: 'string',
|
|
@@ -2173,6 +2297,78 @@ class DescribeAcceleratorAutoRenewAttributeResponse extends $tea.Model {
|
|
|
2173
2297
|
}
|
|
2174
2298
|
}
|
|
2175
2299
|
exports.DescribeAcceleratorAutoRenewAttributeResponse = DescribeAcceleratorAutoRenewAttributeResponse;
|
|
2300
|
+
class DescribeApplicationMonitorRequest extends $tea.Model {
|
|
2301
|
+
constructor(map) {
|
|
2302
|
+
super(map);
|
|
2303
|
+
}
|
|
2304
|
+
static names() {
|
|
2305
|
+
return {
|
|
2306
|
+
clientToken: 'ClientToken',
|
|
2307
|
+
regionId: 'RegionId',
|
|
2308
|
+
taskId: 'TaskId',
|
|
2309
|
+
};
|
|
2310
|
+
}
|
|
2311
|
+
static types() {
|
|
2312
|
+
return {
|
|
2313
|
+
clientToken: 'string',
|
|
2314
|
+
regionId: 'string',
|
|
2315
|
+
taskId: 'string',
|
|
2316
|
+
};
|
|
2317
|
+
}
|
|
2318
|
+
}
|
|
2319
|
+
exports.DescribeApplicationMonitorRequest = DescribeApplicationMonitorRequest;
|
|
2320
|
+
class DescribeApplicationMonitorResponseBody extends $tea.Model {
|
|
2321
|
+
constructor(map) {
|
|
2322
|
+
super(map);
|
|
2323
|
+
}
|
|
2324
|
+
static names() {
|
|
2325
|
+
return {
|
|
2326
|
+
acceleratorId: 'AcceleratorId',
|
|
2327
|
+
address: 'Address',
|
|
2328
|
+
detectThreshold: 'DetectThreshold',
|
|
2329
|
+
ispCityList: 'IspCityList',
|
|
2330
|
+
listenerId: 'ListenerId',
|
|
2331
|
+
optionsJson: 'OptionsJson',
|
|
2332
|
+
regionId: 'RegionId',
|
|
2333
|
+
requestId: 'RequestId',
|
|
2334
|
+
taskId: 'TaskId',
|
|
2335
|
+
taskName: 'TaskName',
|
|
2336
|
+
};
|
|
2337
|
+
}
|
|
2338
|
+
static types() {
|
|
2339
|
+
return {
|
|
2340
|
+
acceleratorId: 'string',
|
|
2341
|
+
address: 'string',
|
|
2342
|
+
detectThreshold: 'string',
|
|
2343
|
+
ispCityList: { 'type': 'array', 'itemType': DescribeApplicationMonitorResponseBodyIspCityList },
|
|
2344
|
+
listenerId: 'string',
|
|
2345
|
+
optionsJson: 'string',
|
|
2346
|
+
regionId: 'string',
|
|
2347
|
+
requestId: 'string',
|
|
2348
|
+
taskId: 'string',
|
|
2349
|
+
taskName: 'string',
|
|
2350
|
+
};
|
|
2351
|
+
}
|
|
2352
|
+
}
|
|
2353
|
+
exports.DescribeApplicationMonitorResponseBody = DescribeApplicationMonitorResponseBody;
|
|
2354
|
+
class DescribeApplicationMonitorResponse extends $tea.Model {
|
|
2355
|
+
constructor(map) {
|
|
2356
|
+
super(map);
|
|
2357
|
+
}
|
|
2358
|
+
static names() {
|
|
2359
|
+
return {
|
|
2360
|
+
headers: 'headers',
|
|
2361
|
+
body: 'body',
|
|
2362
|
+
};
|
|
2363
|
+
}
|
|
2364
|
+
static types() {
|
|
2365
|
+
return {
|
|
2366
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2367
|
+
body: DescribeApplicationMonitorResponseBody,
|
|
2368
|
+
};
|
|
2369
|
+
}
|
|
2370
|
+
}
|
|
2371
|
+
exports.DescribeApplicationMonitorResponse = DescribeApplicationMonitorResponse;
|
|
2176
2372
|
class DescribeBandwidthPackageRequest extends $tea.Model {
|
|
2177
2373
|
constructor(map) {
|
|
2178
2374
|
super(map);
|
|
@@ -2677,51 +2873,43 @@ class DetachLogStoreFromEndpointGroupResponse extends $tea.Model {
|
|
|
2677
2873
|
}
|
|
2678
2874
|
}
|
|
2679
2875
|
exports.DetachLogStoreFromEndpointGroupResponse = DetachLogStoreFromEndpointGroupResponse;
|
|
2680
|
-
class
|
|
2876
|
+
class DetectApplicationMonitorRequest extends $tea.Model {
|
|
2681
2877
|
constructor(map) {
|
|
2682
2878
|
super(map);
|
|
2683
2879
|
}
|
|
2684
2880
|
static names() {
|
|
2685
2881
|
return {
|
|
2686
|
-
aclIds: 'AclIds',
|
|
2687
2882
|
clientToken: 'ClientToken',
|
|
2688
|
-
dryRun: 'DryRun',
|
|
2689
|
-
listenerId: 'ListenerId',
|
|
2690
2883
|
regionId: 'RegionId',
|
|
2884
|
+
taskId: 'TaskId',
|
|
2691
2885
|
};
|
|
2692
2886
|
}
|
|
2693
2887
|
static types() {
|
|
2694
2888
|
return {
|
|
2695
|
-
aclIds: { 'type': 'array', 'itemType': 'string' },
|
|
2696
2889
|
clientToken: 'string',
|
|
2697
|
-
dryRun: 'boolean',
|
|
2698
|
-
listenerId: 'string',
|
|
2699
2890
|
regionId: 'string',
|
|
2891
|
+
taskId: 'string',
|
|
2700
2892
|
};
|
|
2701
2893
|
}
|
|
2702
2894
|
}
|
|
2703
|
-
exports.
|
|
2704
|
-
class
|
|
2895
|
+
exports.DetectApplicationMonitorRequest = DetectApplicationMonitorRequest;
|
|
2896
|
+
class DetectApplicationMonitorResponseBody extends $tea.Model {
|
|
2705
2897
|
constructor(map) {
|
|
2706
2898
|
super(map);
|
|
2707
2899
|
}
|
|
2708
2900
|
static names() {
|
|
2709
2901
|
return {
|
|
2710
|
-
aclIds: 'AclIds',
|
|
2711
|
-
listenerId: 'ListenerId',
|
|
2712
2902
|
requestId: 'RequestId',
|
|
2713
2903
|
};
|
|
2714
2904
|
}
|
|
2715
2905
|
static types() {
|
|
2716
2906
|
return {
|
|
2717
|
-
aclIds: { 'type': 'array', 'itemType': 'string' },
|
|
2718
|
-
listenerId: 'string',
|
|
2719
2907
|
requestId: 'string',
|
|
2720
2908
|
};
|
|
2721
2909
|
}
|
|
2722
2910
|
}
|
|
2723
|
-
exports.
|
|
2724
|
-
class
|
|
2911
|
+
exports.DetectApplicationMonitorResponseBody = DetectApplicationMonitorResponseBody;
|
|
2912
|
+
class DetectApplicationMonitorResponse extends $tea.Model {
|
|
2725
2913
|
constructor(map) {
|
|
2726
2914
|
super(map);
|
|
2727
2915
|
}
|
|
@@ -2734,36 +2922,32 @@ class DissociateAclsFromListenerResponse extends $tea.Model {
|
|
|
2734
2922
|
static types() {
|
|
2735
2923
|
return {
|
|
2736
2924
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2737
|
-
body:
|
|
2925
|
+
body: DetectApplicationMonitorResponseBody,
|
|
2738
2926
|
};
|
|
2739
2927
|
}
|
|
2740
2928
|
}
|
|
2741
|
-
exports.
|
|
2742
|
-
class
|
|
2929
|
+
exports.DetectApplicationMonitorResponse = DetectApplicationMonitorResponse;
|
|
2930
|
+
class DisableApplicationMonitorRequest extends $tea.Model {
|
|
2743
2931
|
constructor(map) {
|
|
2744
2932
|
super(map);
|
|
2745
2933
|
}
|
|
2746
2934
|
static names() {
|
|
2747
2935
|
return {
|
|
2748
|
-
acceleratorId: 'AcceleratorId',
|
|
2749
2936
|
clientToken: 'ClientToken',
|
|
2750
|
-
domains: 'Domains',
|
|
2751
|
-
listenerId: 'ListenerId',
|
|
2752
2937
|
regionId: 'RegionId',
|
|
2938
|
+
taskId: 'TaskId',
|
|
2753
2939
|
};
|
|
2754
2940
|
}
|
|
2755
2941
|
static types() {
|
|
2756
2942
|
return {
|
|
2757
|
-
acceleratorId: 'string',
|
|
2758
2943
|
clientToken: 'string',
|
|
2759
|
-
domains: { 'type': 'array', 'itemType': 'string' },
|
|
2760
|
-
listenerId: 'string',
|
|
2761
2944
|
regionId: 'string',
|
|
2945
|
+
taskId: 'string',
|
|
2762
2946
|
};
|
|
2763
2947
|
}
|
|
2764
2948
|
}
|
|
2765
|
-
exports.
|
|
2766
|
-
class
|
|
2949
|
+
exports.DisableApplicationMonitorRequest = DisableApplicationMonitorRequest;
|
|
2950
|
+
class DisableApplicationMonitorResponseBody extends $tea.Model {
|
|
2767
2951
|
constructor(map) {
|
|
2768
2952
|
super(map);
|
|
2769
2953
|
}
|
|
@@ -2778,8 +2962,8 @@ class DissociateAdditionalCertificatesFromListenerResponseBody extends $tea.Mode
|
|
|
2778
2962
|
};
|
|
2779
2963
|
}
|
|
2780
2964
|
}
|
|
2781
|
-
exports.
|
|
2782
|
-
class
|
|
2965
|
+
exports.DisableApplicationMonitorResponseBody = DisableApplicationMonitorResponseBody;
|
|
2966
|
+
class DisableApplicationMonitorResponse extends $tea.Model {
|
|
2783
2967
|
constructor(map) {
|
|
2784
2968
|
super(map);
|
|
2785
2969
|
}
|
|
@@ -2792,58 +2976,56 @@ class DissociateAdditionalCertificatesFromListenerResponse extends $tea.Model {
|
|
|
2792
2976
|
static types() {
|
|
2793
2977
|
return {
|
|
2794
2978
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2795
|
-
body:
|
|
2979
|
+
body: DisableApplicationMonitorResponseBody,
|
|
2796
2980
|
};
|
|
2797
2981
|
}
|
|
2798
2982
|
}
|
|
2799
|
-
exports.
|
|
2800
|
-
class
|
|
2983
|
+
exports.DisableApplicationMonitorResponse = DisableApplicationMonitorResponse;
|
|
2984
|
+
class DissociateAclsFromListenerRequest extends $tea.Model {
|
|
2801
2985
|
constructor(map) {
|
|
2802
2986
|
super(map);
|
|
2803
2987
|
}
|
|
2804
2988
|
static names() {
|
|
2805
2989
|
return {
|
|
2806
|
-
|
|
2990
|
+
aclIds: 'AclIds',
|
|
2991
|
+
clientToken: 'ClientToken',
|
|
2992
|
+
dryRun: 'DryRun',
|
|
2993
|
+
listenerId: 'ListenerId',
|
|
2807
2994
|
regionId: 'RegionId',
|
|
2808
2995
|
};
|
|
2809
2996
|
}
|
|
2810
2997
|
static types() {
|
|
2811
2998
|
return {
|
|
2812
|
-
|
|
2999
|
+
aclIds: { 'type': 'array', 'itemType': 'string' },
|
|
3000
|
+
clientToken: 'string',
|
|
3001
|
+
dryRun: 'boolean',
|
|
3002
|
+
listenerId: 'string',
|
|
2813
3003
|
regionId: 'string',
|
|
2814
3004
|
};
|
|
2815
3005
|
}
|
|
2816
3006
|
}
|
|
2817
|
-
exports.
|
|
2818
|
-
class
|
|
3007
|
+
exports.DissociateAclsFromListenerRequest = DissociateAclsFromListenerRequest;
|
|
3008
|
+
class DissociateAclsFromListenerResponseBody extends $tea.Model {
|
|
2819
3009
|
constructor(map) {
|
|
2820
3010
|
super(map);
|
|
2821
3011
|
}
|
|
2822
3012
|
static names() {
|
|
2823
3013
|
return {
|
|
2824
|
-
|
|
2825
|
-
|
|
2826
|
-
aclName: 'AclName',
|
|
2827
|
-
aclStatus: 'AclStatus',
|
|
2828
|
-
addressIPVersion: 'AddressIPVersion',
|
|
2829
|
-
relatedListeners: 'RelatedListeners',
|
|
3014
|
+
aclIds: 'AclIds',
|
|
3015
|
+
listenerId: 'ListenerId',
|
|
2830
3016
|
requestId: 'RequestId',
|
|
2831
3017
|
};
|
|
2832
3018
|
}
|
|
2833
3019
|
static types() {
|
|
2834
3020
|
return {
|
|
2835
|
-
|
|
2836
|
-
|
|
2837
|
-
aclName: 'string',
|
|
2838
|
-
aclStatus: 'string',
|
|
2839
|
-
addressIPVersion: 'string',
|
|
2840
|
-
relatedListeners: { 'type': 'array', 'itemType': GetAclResponseBodyRelatedListeners },
|
|
3021
|
+
aclIds: { 'type': 'array', 'itemType': 'string' },
|
|
3022
|
+
listenerId: 'string',
|
|
2841
3023
|
requestId: 'string',
|
|
2842
3024
|
};
|
|
2843
3025
|
}
|
|
2844
3026
|
}
|
|
2845
|
-
exports.
|
|
2846
|
-
class
|
|
3027
|
+
exports.DissociateAclsFromListenerResponseBody = DissociateAclsFromListenerResponseBody;
|
|
3028
|
+
class DissociateAclsFromListenerResponse extends $tea.Model {
|
|
2847
3029
|
constructor(map) {
|
|
2848
3030
|
super(map);
|
|
2849
3031
|
}
|
|
@@ -2856,65 +3038,241 @@ class GetAclResponse extends $tea.Model {
|
|
|
2856
3038
|
static types() {
|
|
2857
3039
|
return {
|
|
2858
3040
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2859
|
-
body:
|
|
3041
|
+
body: DissociateAclsFromListenerResponseBody,
|
|
2860
3042
|
};
|
|
2861
3043
|
}
|
|
2862
3044
|
}
|
|
2863
|
-
exports.
|
|
2864
|
-
class
|
|
3045
|
+
exports.DissociateAclsFromListenerResponse = DissociateAclsFromListenerResponse;
|
|
3046
|
+
class DissociateAdditionalCertificatesFromListenerRequest extends $tea.Model {
|
|
2865
3047
|
constructor(map) {
|
|
2866
3048
|
super(map);
|
|
2867
3049
|
}
|
|
2868
3050
|
static names() {
|
|
2869
3051
|
return {
|
|
2870
3052
|
acceleratorId: 'AcceleratorId',
|
|
3053
|
+
clientToken: 'ClientToken',
|
|
3054
|
+
domains: 'Domains',
|
|
3055
|
+
listenerId: 'ListenerId',
|
|
2871
3056
|
regionId: 'RegionId',
|
|
2872
3057
|
};
|
|
2873
3058
|
}
|
|
2874
3059
|
static types() {
|
|
2875
3060
|
return {
|
|
2876
3061
|
acceleratorId: 'string',
|
|
3062
|
+
clientToken: 'string',
|
|
3063
|
+
domains: { 'type': 'array', 'itemType': 'string' },
|
|
3064
|
+
listenerId: 'string',
|
|
2877
3065
|
regionId: 'string',
|
|
2878
3066
|
};
|
|
2879
3067
|
}
|
|
2880
3068
|
}
|
|
2881
|
-
exports.
|
|
2882
|
-
class
|
|
3069
|
+
exports.DissociateAdditionalCertificatesFromListenerRequest = DissociateAdditionalCertificatesFromListenerRequest;
|
|
3070
|
+
class DissociateAdditionalCertificatesFromListenerResponseBody extends $tea.Model {
|
|
2883
3071
|
constructor(map) {
|
|
2884
3072
|
super(map);
|
|
2885
3073
|
}
|
|
2886
3074
|
static names() {
|
|
2887
3075
|
return {
|
|
2888
|
-
acceleratorId: 'AcceleratorId',
|
|
2889
|
-
basicBandwidthPackage: 'BasicBandwidthPackage',
|
|
2890
|
-
basicEndpointGroupId: 'BasicEndpointGroupId',
|
|
2891
|
-
basicIpSetId: 'BasicIpSetId',
|
|
2892
|
-
cenId: 'CenId',
|
|
2893
|
-
createTime: 'CreateTime',
|
|
2894
|
-
crossDomainBandwidthPackage: 'CrossDomainBandwidthPackage',
|
|
2895
|
-
description: 'Description',
|
|
2896
|
-
expiredTime: 'ExpiredTime',
|
|
2897
|
-
instanceChargeType: 'InstanceChargeType',
|
|
2898
|
-
name: 'Name',
|
|
2899
|
-
regionId: 'RegionId',
|
|
2900
3076
|
requestId: 'RequestId',
|
|
2901
|
-
state: 'State',
|
|
2902
3077
|
};
|
|
2903
3078
|
}
|
|
2904
3079
|
static types() {
|
|
2905
3080
|
return {
|
|
2906
|
-
|
|
2907
|
-
|
|
2908
|
-
|
|
2909
|
-
|
|
2910
|
-
|
|
2911
|
-
|
|
2912
|
-
|
|
2913
|
-
|
|
2914
|
-
|
|
2915
|
-
|
|
2916
|
-
|
|
2917
|
-
|
|
3081
|
+
requestId: 'string',
|
|
3082
|
+
};
|
|
3083
|
+
}
|
|
3084
|
+
}
|
|
3085
|
+
exports.DissociateAdditionalCertificatesFromListenerResponseBody = DissociateAdditionalCertificatesFromListenerResponseBody;
|
|
3086
|
+
class DissociateAdditionalCertificatesFromListenerResponse extends $tea.Model {
|
|
3087
|
+
constructor(map) {
|
|
3088
|
+
super(map);
|
|
3089
|
+
}
|
|
3090
|
+
static names() {
|
|
3091
|
+
return {
|
|
3092
|
+
headers: 'headers',
|
|
3093
|
+
body: 'body',
|
|
3094
|
+
};
|
|
3095
|
+
}
|
|
3096
|
+
static types() {
|
|
3097
|
+
return {
|
|
3098
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3099
|
+
body: DissociateAdditionalCertificatesFromListenerResponseBody,
|
|
3100
|
+
};
|
|
3101
|
+
}
|
|
3102
|
+
}
|
|
3103
|
+
exports.DissociateAdditionalCertificatesFromListenerResponse = DissociateAdditionalCertificatesFromListenerResponse;
|
|
3104
|
+
class EnableApplicationMonitorRequest extends $tea.Model {
|
|
3105
|
+
constructor(map) {
|
|
3106
|
+
super(map);
|
|
3107
|
+
}
|
|
3108
|
+
static names() {
|
|
3109
|
+
return {
|
|
3110
|
+
clientToken: 'ClientToken',
|
|
3111
|
+
regionId: 'RegionId',
|
|
3112
|
+
taskId: 'TaskId',
|
|
3113
|
+
};
|
|
3114
|
+
}
|
|
3115
|
+
static types() {
|
|
3116
|
+
return {
|
|
3117
|
+
clientToken: 'string',
|
|
3118
|
+
regionId: 'string',
|
|
3119
|
+
taskId: 'string',
|
|
3120
|
+
};
|
|
3121
|
+
}
|
|
3122
|
+
}
|
|
3123
|
+
exports.EnableApplicationMonitorRequest = EnableApplicationMonitorRequest;
|
|
3124
|
+
class EnableApplicationMonitorResponseBody extends $tea.Model {
|
|
3125
|
+
constructor(map) {
|
|
3126
|
+
super(map);
|
|
3127
|
+
}
|
|
3128
|
+
static names() {
|
|
3129
|
+
return {
|
|
3130
|
+
requestId: 'RequestId',
|
|
3131
|
+
};
|
|
3132
|
+
}
|
|
3133
|
+
static types() {
|
|
3134
|
+
return {
|
|
3135
|
+
requestId: 'string',
|
|
3136
|
+
};
|
|
3137
|
+
}
|
|
3138
|
+
}
|
|
3139
|
+
exports.EnableApplicationMonitorResponseBody = EnableApplicationMonitorResponseBody;
|
|
3140
|
+
class EnableApplicationMonitorResponse extends $tea.Model {
|
|
3141
|
+
constructor(map) {
|
|
3142
|
+
super(map);
|
|
3143
|
+
}
|
|
3144
|
+
static names() {
|
|
3145
|
+
return {
|
|
3146
|
+
headers: 'headers',
|
|
3147
|
+
body: 'body',
|
|
3148
|
+
};
|
|
3149
|
+
}
|
|
3150
|
+
static types() {
|
|
3151
|
+
return {
|
|
3152
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3153
|
+
body: EnableApplicationMonitorResponseBody,
|
|
3154
|
+
};
|
|
3155
|
+
}
|
|
3156
|
+
}
|
|
3157
|
+
exports.EnableApplicationMonitorResponse = EnableApplicationMonitorResponse;
|
|
3158
|
+
class GetAclRequest extends $tea.Model {
|
|
3159
|
+
constructor(map) {
|
|
3160
|
+
super(map);
|
|
3161
|
+
}
|
|
3162
|
+
static names() {
|
|
3163
|
+
return {
|
|
3164
|
+
aclId: 'AclId',
|
|
3165
|
+
regionId: 'RegionId',
|
|
3166
|
+
};
|
|
3167
|
+
}
|
|
3168
|
+
static types() {
|
|
3169
|
+
return {
|
|
3170
|
+
aclId: 'string',
|
|
3171
|
+
regionId: 'string',
|
|
3172
|
+
};
|
|
3173
|
+
}
|
|
3174
|
+
}
|
|
3175
|
+
exports.GetAclRequest = GetAclRequest;
|
|
3176
|
+
class GetAclResponseBody extends $tea.Model {
|
|
3177
|
+
constructor(map) {
|
|
3178
|
+
super(map);
|
|
3179
|
+
}
|
|
3180
|
+
static names() {
|
|
3181
|
+
return {
|
|
3182
|
+
aclEntries: 'AclEntries',
|
|
3183
|
+
aclId: 'AclId',
|
|
3184
|
+
aclName: 'AclName',
|
|
3185
|
+
aclStatus: 'AclStatus',
|
|
3186
|
+
addressIPVersion: 'AddressIPVersion',
|
|
3187
|
+
relatedListeners: 'RelatedListeners',
|
|
3188
|
+
requestId: 'RequestId',
|
|
3189
|
+
};
|
|
3190
|
+
}
|
|
3191
|
+
static types() {
|
|
3192
|
+
return {
|
|
3193
|
+
aclEntries: { 'type': 'array', 'itemType': GetAclResponseBodyAclEntries },
|
|
3194
|
+
aclId: 'string',
|
|
3195
|
+
aclName: 'string',
|
|
3196
|
+
aclStatus: 'string',
|
|
3197
|
+
addressIPVersion: 'string',
|
|
3198
|
+
relatedListeners: { 'type': 'array', 'itemType': GetAclResponseBodyRelatedListeners },
|
|
3199
|
+
requestId: 'string',
|
|
3200
|
+
};
|
|
3201
|
+
}
|
|
3202
|
+
}
|
|
3203
|
+
exports.GetAclResponseBody = GetAclResponseBody;
|
|
3204
|
+
class GetAclResponse extends $tea.Model {
|
|
3205
|
+
constructor(map) {
|
|
3206
|
+
super(map);
|
|
3207
|
+
}
|
|
3208
|
+
static names() {
|
|
3209
|
+
return {
|
|
3210
|
+
headers: 'headers',
|
|
3211
|
+
body: 'body',
|
|
3212
|
+
};
|
|
3213
|
+
}
|
|
3214
|
+
static types() {
|
|
3215
|
+
return {
|
|
3216
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3217
|
+
body: GetAclResponseBody,
|
|
3218
|
+
};
|
|
3219
|
+
}
|
|
3220
|
+
}
|
|
3221
|
+
exports.GetAclResponse = GetAclResponse;
|
|
3222
|
+
class GetBasicAcceleratorRequest extends $tea.Model {
|
|
3223
|
+
constructor(map) {
|
|
3224
|
+
super(map);
|
|
3225
|
+
}
|
|
3226
|
+
static names() {
|
|
3227
|
+
return {
|
|
3228
|
+
acceleratorId: 'AcceleratorId',
|
|
3229
|
+
regionId: 'RegionId',
|
|
3230
|
+
};
|
|
3231
|
+
}
|
|
3232
|
+
static types() {
|
|
3233
|
+
return {
|
|
3234
|
+
acceleratorId: 'string',
|
|
3235
|
+
regionId: 'string',
|
|
3236
|
+
};
|
|
3237
|
+
}
|
|
3238
|
+
}
|
|
3239
|
+
exports.GetBasicAcceleratorRequest = GetBasicAcceleratorRequest;
|
|
3240
|
+
class GetBasicAcceleratorResponseBody extends $tea.Model {
|
|
3241
|
+
constructor(map) {
|
|
3242
|
+
super(map);
|
|
3243
|
+
}
|
|
3244
|
+
static names() {
|
|
3245
|
+
return {
|
|
3246
|
+
acceleratorId: 'AcceleratorId',
|
|
3247
|
+
basicBandwidthPackage: 'BasicBandwidthPackage',
|
|
3248
|
+
basicEndpointGroupId: 'BasicEndpointGroupId',
|
|
3249
|
+
basicIpSetId: 'BasicIpSetId',
|
|
3250
|
+
cenId: 'CenId',
|
|
3251
|
+
createTime: 'CreateTime',
|
|
3252
|
+
crossDomainBandwidthPackage: 'CrossDomainBandwidthPackage',
|
|
3253
|
+
description: 'Description',
|
|
3254
|
+
expiredTime: 'ExpiredTime',
|
|
3255
|
+
instanceChargeType: 'InstanceChargeType',
|
|
3256
|
+
name: 'Name',
|
|
3257
|
+
regionId: 'RegionId',
|
|
3258
|
+
requestId: 'RequestId',
|
|
3259
|
+
state: 'State',
|
|
3260
|
+
};
|
|
3261
|
+
}
|
|
3262
|
+
static types() {
|
|
3263
|
+
return {
|
|
3264
|
+
acceleratorId: 'string',
|
|
3265
|
+
basicBandwidthPackage: GetBasicAcceleratorResponseBodyBasicBandwidthPackage,
|
|
3266
|
+
basicEndpointGroupId: 'string',
|
|
3267
|
+
basicIpSetId: 'string',
|
|
3268
|
+
cenId: 'string',
|
|
3269
|
+
createTime: 'number',
|
|
3270
|
+
crossDomainBandwidthPackage: GetBasicAcceleratorResponseBodyCrossDomainBandwidthPackage,
|
|
3271
|
+
description: 'string',
|
|
3272
|
+
expiredTime: 'number',
|
|
3273
|
+
instanceChargeType: 'string',
|
|
3274
|
+
name: 'string',
|
|
3275
|
+
regionId: 'string',
|
|
2918
3276
|
requestId: 'string',
|
|
2919
3277
|
state: 'string',
|
|
2920
3278
|
};
|
|
@@ -3387,6 +3745,138 @@ class ListAclsResponse extends $tea.Model {
|
|
|
3387
3745
|
}
|
|
3388
3746
|
}
|
|
3389
3747
|
exports.ListAclsResponse = ListAclsResponse;
|
|
3748
|
+
class ListApplicationMonitorRequest extends $tea.Model {
|
|
3749
|
+
constructor(map) {
|
|
3750
|
+
super(map);
|
|
3751
|
+
}
|
|
3752
|
+
static names() {
|
|
3753
|
+
return {
|
|
3754
|
+
pageNumber: 'PageNumber',
|
|
3755
|
+
pageSize: 'PageSize',
|
|
3756
|
+
regionId: 'RegionId',
|
|
3757
|
+
searchValue: 'SearchValue',
|
|
3758
|
+
};
|
|
3759
|
+
}
|
|
3760
|
+
static types() {
|
|
3761
|
+
return {
|
|
3762
|
+
pageNumber: 'number',
|
|
3763
|
+
pageSize: 'number',
|
|
3764
|
+
regionId: 'string',
|
|
3765
|
+
searchValue: 'string',
|
|
3766
|
+
};
|
|
3767
|
+
}
|
|
3768
|
+
}
|
|
3769
|
+
exports.ListApplicationMonitorRequest = ListApplicationMonitorRequest;
|
|
3770
|
+
class ListApplicationMonitorResponseBody extends $tea.Model {
|
|
3771
|
+
constructor(map) {
|
|
3772
|
+
super(map);
|
|
3773
|
+
}
|
|
3774
|
+
static names() {
|
|
3775
|
+
return {
|
|
3776
|
+
applicationMonitors: 'ApplicationMonitors',
|
|
3777
|
+
pageNumber: 'PageNumber',
|
|
3778
|
+
pageSize: 'PageSize',
|
|
3779
|
+
requestId: 'RequestId',
|
|
3780
|
+
totalCount: 'TotalCount',
|
|
3781
|
+
};
|
|
3782
|
+
}
|
|
3783
|
+
static types() {
|
|
3784
|
+
return {
|
|
3785
|
+
applicationMonitors: { 'type': 'array', 'itemType': ListApplicationMonitorResponseBodyApplicationMonitors },
|
|
3786
|
+
pageNumber: 'number',
|
|
3787
|
+
pageSize: 'number',
|
|
3788
|
+
requestId: 'string',
|
|
3789
|
+
totalCount: 'number',
|
|
3790
|
+
};
|
|
3791
|
+
}
|
|
3792
|
+
}
|
|
3793
|
+
exports.ListApplicationMonitorResponseBody = ListApplicationMonitorResponseBody;
|
|
3794
|
+
class ListApplicationMonitorResponse extends $tea.Model {
|
|
3795
|
+
constructor(map) {
|
|
3796
|
+
super(map);
|
|
3797
|
+
}
|
|
3798
|
+
static names() {
|
|
3799
|
+
return {
|
|
3800
|
+
headers: 'headers',
|
|
3801
|
+
body: 'body',
|
|
3802
|
+
};
|
|
3803
|
+
}
|
|
3804
|
+
static types() {
|
|
3805
|
+
return {
|
|
3806
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3807
|
+
body: ListApplicationMonitorResponseBody,
|
|
3808
|
+
};
|
|
3809
|
+
}
|
|
3810
|
+
}
|
|
3811
|
+
exports.ListApplicationMonitorResponse = ListApplicationMonitorResponse;
|
|
3812
|
+
class ListApplicationMonitorDetectResultRequest extends $tea.Model {
|
|
3813
|
+
constructor(map) {
|
|
3814
|
+
super(map);
|
|
3815
|
+
}
|
|
3816
|
+
static names() {
|
|
3817
|
+
return {
|
|
3818
|
+
beginTime: 'BeginTime',
|
|
3819
|
+
endTime: 'EndTime',
|
|
3820
|
+
pageNumber: 'PageNumber',
|
|
3821
|
+
pageSize: 'PageSize',
|
|
3822
|
+
regionId: 'RegionId',
|
|
3823
|
+
taskId: 'TaskId',
|
|
3824
|
+
};
|
|
3825
|
+
}
|
|
3826
|
+
static types() {
|
|
3827
|
+
return {
|
|
3828
|
+
beginTime: 'number',
|
|
3829
|
+
endTime: 'number',
|
|
3830
|
+
pageNumber: 'number',
|
|
3831
|
+
pageSize: 'number',
|
|
3832
|
+
regionId: 'string',
|
|
3833
|
+
taskId: 'string',
|
|
3834
|
+
};
|
|
3835
|
+
}
|
|
3836
|
+
}
|
|
3837
|
+
exports.ListApplicationMonitorDetectResultRequest = ListApplicationMonitorDetectResultRequest;
|
|
3838
|
+
class ListApplicationMonitorDetectResultResponseBody extends $tea.Model {
|
|
3839
|
+
constructor(map) {
|
|
3840
|
+
super(map);
|
|
3841
|
+
}
|
|
3842
|
+
static names() {
|
|
3843
|
+
return {
|
|
3844
|
+
applicationMonitorDetectResultList: 'ApplicationMonitorDetectResultList',
|
|
3845
|
+
pageNumber: 'PageNumber',
|
|
3846
|
+
pageSize: 'PageSize',
|
|
3847
|
+
requestId: 'RequestId',
|
|
3848
|
+
totalCount: 'TotalCount',
|
|
3849
|
+
};
|
|
3850
|
+
}
|
|
3851
|
+
static types() {
|
|
3852
|
+
return {
|
|
3853
|
+
applicationMonitorDetectResultList: { 'type': 'array', 'itemType': ListApplicationMonitorDetectResultResponseBodyApplicationMonitorDetectResultList },
|
|
3854
|
+
pageNumber: 'number',
|
|
3855
|
+
pageSize: 'number',
|
|
3856
|
+
requestId: 'string',
|
|
3857
|
+
totalCount: 'number',
|
|
3858
|
+
};
|
|
3859
|
+
}
|
|
3860
|
+
}
|
|
3861
|
+
exports.ListApplicationMonitorDetectResultResponseBody = ListApplicationMonitorDetectResultResponseBody;
|
|
3862
|
+
class ListApplicationMonitorDetectResultResponse extends $tea.Model {
|
|
3863
|
+
constructor(map) {
|
|
3864
|
+
super(map);
|
|
3865
|
+
}
|
|
3866
|
+
static names() {
|
|
3867
|
+
return {
|
|
3868
|
+
headers: 'headers',
|
|
3869
|
+
body: 'body',
|
|
3870
|
+
};
|
|
3871
|
+
}
|
|
3872
|
+
static types() {
|
|
3873
|
+
return {
|
|
3874
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3875
|
+
body: ListApplicationMonitorDetectResultResponseBody,
|
|
3876
|
+
};
|
|
3877
|
+
}
|
|
3878
|
+
}
|
|
3879
|
+
exports.ListApplicationMonitorDetectResultResponse = ListApplicationMonitorDetectResultResponse;
|
|
3390
3880
|
class ListAvailableAccelerateAreasRequest extends $tea.Model {
|
|
3391
3881
|
constructor(map) {
|
|
3392
3882
|
super(map);
|
|
@@ -4555,6 +5045,70 @@ class UpdateAclAttributeResponse extends $tea.Model {
|
|
|
4555
5045
|
}
|
|
4556
5046
|
}
|
|
4557
5047
|
exports.UpdateAclAttributeResponse = UpdateAclAttributeResponse;
|
|
5048
|
+
class UpdateApplicationMonitorRequest extends $tea.Model {
|
|
5049
|
+
constructor(map) {
|
|
5050
|
+
super(map);
|
|
5051
|
+
}
|
|
5052
|
+
static names() {
|
|
5053
|
+
return {
|
|
5054
|
+
address: 'Address',
|
|
5055
|
+
clientToken: 'ClientToken',
|
|
5056
|
+
detectThreshold: 'DetectThreshold',
|
|
5057
|
+
listenerId: 'ListenerId',
|
|
5058
|
+
optionsJson: 'OptionsJson',
|
|
5059
|
+
regionId: 'RegionId',
|
|
5060
|
+
taskId: 'TaskId',
|
|
5061
|
+
taskName: 'TaskName',
|
|
5062
|
+
};
|
|
5063
|
+
}
|
|
5064
|
+
static types() {
|
|
5065
|
+
return {
|
|
5066
|
+
address: 'string',
|
|
5067
|
+
clientToken: 'string',
|
|
5068
|
+
detectThreshold: 'number',
|
|
5069
|
+
listenerId: 'string',
|
|
5070
|
+
optionsJson: 'string',
|
|
5071
|
+
regionId: 'string',
|
|
5072
|
+
taskId: 'string',
|
|
5073
|
+
taskName: 'string',
|
|
5074
|
+
};
|
|
5075
|
+
}
|
|
5076
|
+
}
|
|
5077
|
+
exports.UpdateApplicationMonitorRequest = UpdateApplicationMonitorRequest;
|
|
5078
|
+
class UpdateApplicationMonitorResponseBody extends $tea.Model {
|
|
5079
|
+
constructor(map) {
|
|
5080
|
+
super(map);
|
|
5081
|
+
}
|
|
5082
|
+
static names() {
|
|
5083
|
+
return {
|
|
5084
|
+
requestId: 'RequestId',
|
|
5085
|
+
};
|
|
5086
|
+
}
|
|
5087
|
+
static types() {
|
|
5088
|
+
return {
|
|
5089
|
+
requestId: 'string',
|
|
5090
|
+
};
|
|
5091
|
+
}
|
|
5092
|
+
}
|
|
5093
|
+
exports.UpdateApplicationMonitorResponseBody = UpdateApplicationMonitorResponseBody;
|
|
5094
|
+
class UpdateApplicationMonitorResponse extends $tea.Model {
|
|
5095
|
+
constructor(map) {
|
|
5096
|
+
super(map);
|
|
5097
|
+
}
|
|
5098
|
+
static names() {
|
|
5099
|
+
return {
|
|
5100
|
+
headers: 'headers',
|
|
5101
|
+
body: 'body',
|
|
5102
|
+
};
|
|
5103
|
+
}
|
|
5104
|
+
static types() {
|
|
5105
|
+
return {
|
|
5106
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
5107
|
+
body: UpdateApplicationMonitorResponseBody,
|
|
5108
|
+
};
|
|
5109
|
+
}
|
|
5110
|
+
}
|
|
5111
|
+
exports.UpdateApplicationMonitorResponse = UpdateApplicationMonitorResponse;
|
|
4558
5112
|
class UpdateBandwidthPackageRequest extends $tea.Model {
|
|
4559
5113
|
constructor(map) {
|
|
4560
5114
|
super(map);
|
|
@@ -5221,6 +5775,22 @@ class AssociateAdditionalCertificatesWithListenerRequestCertificates extends $te
|
|
|
5221
5775
|
}
|
|
5222
5776
|
}
|
|
5223
5777
|
exports.AssociateAdditionalCertificatesWithListenerRequestCertificates = AssociateAdditionalCertificatesWithListenerRequestCertificates;
|
|
5778
|
+
class CreateAcceleratorRequestIpSetConfig extends $tea.Model {
|
|
5779
|
+
constructor(map) {
|
|
5780
|
+
super(map);
|
|
5781
|
+
}
|
|
5782
|
+
static names() {
|
|
5783
|
+
return {
|
|
5784
|
+
accessMode: 'AccessMode',
|
|
5785
|
+
};
|
|
5786
|
+
}
|
|
5787
|
+
static types() {
|
|
5788
|
+
return {
|
|
5789
|
+
accessMode: 'string',
|
|
5790
|
+
};
|
|
5791
|
+
}
|
|
5792
|
+
}
|
|
5793
|
+
exports.CreateAcceleratorRequestIpSetConfig = CreateAcceleratorRequestIpSetConfig;
|
|
5224
5794
|
class CreateAclRequestAclEntries extends $tea.Model {
|
|
5225
5795
|
constructor(map) {
|
|
5226
5796
|
super(map);
|
|
@@ -5404,6 +5974,7 @@ class CreateForwardingRulesRequestForwardingRulesRuleActions extends $tea.Model
|
|
|
5404
5974
|
forwardGroupConfig: 'ForwardGroupConfig',
|
|
5405
5975
|
order: 'Order',
|
|
5406
5976
|
ruleActionType: 'RuleActionType',
|
|
5977
|
+
ruleActionValue: 'RuleActionValue',
|
|
5407
5978
|
};
|
|
5408
5979
|
}
|
|
5409
5980
|
static types() {
|
|
@@ -5411,6 +5982,7 @@ class CreateForwardingRulesRequestForwardingRulesRuleActions extends $tea.Model
|
|
|
5411
5982
|
forwardGroupConfig: CreateForwardingRulesRequestForwardingRulesRuleActionsForwardGroupConfig,
|
|
5412
5983
|
order: 'number',
|
|
5413
5984
|
ruleActionType: 'string',
|
|
5985
|
+
ruleActionValue: 'string',
|
|
5414
5986
|
};
|
|
5415
5987
|
}
|
|
5416
5988
|
}
|
|
@@ -5456,6 +6028,7 @@ class CreateForwardingRulesRequestForwardingRulesRuleConditions extends $tea.Mod
|
|
|
5456
6028
|
hostConfig: 'HostConfig',
|
|
5457
6029
|
pathConfig: 'PathConfig',
|
|
5458
6030
|
ruleConditionType: 'RuleConditionType',
|
|
6031
|
+
ruleConditionValue: 'RuleConditionValue',
|
|
5459
6032
|
};
|
|
5460
6033
|
}
|
|
5461
6034
|
static types() {
|
|
@@ -5463,6 +6036,7 @@ class CreateForwardingRulesRequestForwardingRulesRuleConditions extends $tea.Mod
|
|
|
5463
6036
|
hostConfig: CreateForwardingRulesRequestForwardingRulesRuleConditionsHostConfig,
|
|
5464
6037
|
pathConfig: CreateForwardingRulesRequestForwardingRulesRuleConditionsPathConfig,
|
|
5465
6038
|
ruleConditionType: 'string',
|
|
6039
|
+
ruleConditionValue: 'string',
|
|
5466
6040
|
};
|
|
5467
6041
|
}
|
|
5468
6042
|
}
|
|
@@ -5477,6 +6051,7 @@ class CreateForwardingRulesRequestForwardingRules extends $tea.Model {
|
|
|
5477
6051
|
priority: 'Priority',
|
|
5478
6052
|
ruleActions: 'RuleActions',
|
|
5479
6053
|
ruleConditions: 'RuleConditions',
|
|
6054
|
+
ruleDirection: 'RuleDirection',
|
|
5480
6055
|
};
|
|
5481
6056
|
}
|
|
5482
6057
|
static types() {
|
|
@@ -5485,6 +6060,7 @@ class CreateForwardingRulesRequestForwardingRules extends $tea.Model {
|
|
|
5485
6060
|
priority: 'number',
|
|
5486
6061
|
ruleActions: { 'type': 'array', 'itemType': CreateForwardingRulesRequestForwardingRulesRuleActions },
|
|
5487
6062
|
ruleConditions: { 'type': 'array', 'itemType': CreateForwardingRulesRequestForwardingRulesRuleConditions },
|
|
6063
|
+
ruleDirection: 'string',
|
|
5488
6064
|
};
|
|
5489
6065
|
}
|
|
5490
6066
|
}
|
|
@@ -5657,6 +6233,44 @@ class DescribeAcceleratorResponseBodyCrossDomainBandwidthPackage extends $tea.Mo
|
|
|
5657
6233
|
}
|
|
5658
6234
|
}
|
|
5659
6235
|
exports.DescribeAcceleratorResponseBodyCrossDomainBandwidthPackage = DescribeAcceleratorResponseBodyCrossDomainBandwidthPackage;
|
|
6236
|
+
class DescribeAcceleratorResponseBodyIpSetConfig extends $tea.Model {
|
|
6237
|
+
constructor(map) {
|
|
6238
|
+
super(map);
|
|
6239
|
+
}
|
|
6240
|
+
static names() {
|
|
6241
|
+
return {
|
|
6242
|
+
accessMode: 'AccessMode',
|
|
6243
|
+
};
|
|
6244
|
+
}
|
|
6245
|
+
static types() {
|
|
6246
|
+
return {
|
|
6247
|
+
accessMode: 'string',
|
|
6248
|
+
};
|
|
6249
|
+
}
|
|
6250
|
+
}
|
|
6251
|
+
exports.DescribeAcceleratorResponseBodyIpSetConfig = DescribeAcceleratorResponseBodyIpSetConfig;
|
|
6252
|
+
class DescribeApplicationMonitorResponseBodyIspCityList extends $tea.Model {
|
|
6253
|
+
constructor(map) {
|
|
6254
|
+
super(map);
|
|
6255
|
+
}
|
|
6256
|
+
static names() {
|
|
6257
|
+
return {
|
|
6258
|
+
city: 'City',
|
|
6259
|
+
cityName: 'CityName',
|
|
6260
|
+
isp: 'Isp',
|
|
6261
|
+
ispName: 'IspName',
|
|
6262
|
+
};
|
|
6263
|
+
}
|
|
6264
|
+
static types() {
|
|
6265
|
+
return {
|
|
6266
|
+
city: 'string',
|
|
6267
|
+
cityName: 'string',
|
|
6268
|
+
isp: 'string',
|
|
6269
|
+
ispName: 'string',
|
|
6270
|
+
};
|
|
6271
|
+
}
|
|
6272
|
+
}
|
|
6273
|
+
exports.DescribeApplicationMonitorResponseBodyIspCityList = DescribeApplicationMonitorResponseBodyIspCityList;
|
|
5660
6274
|
class DescribeEndpointGroupResponseBodyEndpointConfigurations extends $tea.Model {
|
|
5661
6275
|
constructor(map) {
|
|
5662
6276
|
super(map);
|
|
@@ -6017,6 +6631,22 @@ class ListAcceleratorsResponseBodyAcceleratorsCrossDomainBandwidthPackage extend
|
|
|
6017
6631
|
}
|
|
6018
6632
|
}
|
|
6019
6633
|
exports.ListAcceleratorsResponseBodyAcceleratorsCrossDomainBandwidthPackage = ListAcceleratorsResponseBodyAcceleratorsCrossDomainBandwidthPackage;
|
|
6634
|
+
class ListAcceleratorsResponseBodyAcceleratorsIpSetConfig extends $tea.Model {
|
|
6635
|
+
constructor(map) {
|
|
6636
|
+
super(map);
|
|
6637
|
+
}
|
|
6638
|
+
static names() {
|
|
6639
|
+
return {
|
|
6640
|
+
accessMode: 'AccessMode',
|
|
6641
|
+
};
|
|
6642
|
+
}
|
|
6643
|
+
static types() {
|
|
6644
|
+
return {
|
|
6645
|
+
accessMode: 'string',
|
|
6646
|
+
};
|
|
6647
|
+
}
|
|
6648
|
+
}
|
|
6649
|
+
exports.ListAcceleratorsResponseBodyAcceleratorsIpSetConfig = ListAcceleratorsResponseBodyAcceleratorsIpSetConfig;
|
|
6020
6650
|
class ListAcceleratorsResponseBodyAccelerators extends $tea.Model {
|
|
6021
6651
|
constructor(map) {
|
|
6022
6652
|
super(map);
|
|
@@ -6034,6 +6664,7 @@ class ListAcceleratorsResponseBodyAccelerators extends $tea.Model {
|
|
|
6034
6664
|
dnsName: 'DnsName',
|
|
6035
6665
|
expiredTime: 'ExpiredTime',
|
|
6036
6666
|
instanceChargeType: 'InstanceChargeType',
|
|
6667
|
+
ipSetConfig: 'IpSetConfig',
|
|
6037
6668
|
name: 'Name',
|
|
6038
6669
|
regionId: 'RegionId',
|
|
6039
6670
|
secondDnsName: 'SecondDnsName',
|
|
@@ -6055,6 +6686,7 @@ class ListAcceleratorsResponseBodyAccelerators extends $tea.Model {
|
|
|
6055
6686
|
dnsName: 'string',
|
|
6056
6687
|
expiredTime: 'number',
|
|
6057
6688
|
instanceChargeType: 'string',
|
|
6689
|
+
ipSetConfig: ListAcceleratorsResponseBodyAcceleratorsIpSetConfig,
|
|
6058
6690
|
name: 'string',
|
|
6059
6691
|
regionId: 'string',
|
|
6060
6692
|
secondDnsName: 'string',
|
|
@@ -6087,6 +6719,64 @@ class ListAclsResponseBodyAcls extends $tea.Model {
|
|
|
6087
6719
|
}
|
|
6088
6720
|
}
|
|
6089
6721
|
exports.ListAclsResponseBodyAcls = ListAclsResponseBodyAcls;
|
|
6722
|
+
class ListApplicationMonitorResponseBodyApplicationMonitors extends $tea.Model {
|
|
6723
|
+
constructor(map) {
|
|
6724
|
+
super(map);
|
|
6725
|
+
}
|
|
6726
|
+
static names() {
|
|
6727
|
+
return {
|
|
6728
|
+
acceleratorId: 'AcceleratorId',
|
|
6729
|
+
address: 'Address',
|
|
6730
|
+
detectThreshold: 'DetectThreshold',
|
|
6731
|
+
listenerId: 'ListenerId',
|
|
6732
|
+
optionsJson: 'OptionsJson',
|
|
6733
|
+
state: 'State',
|
|
6734
|
+
taskId: 'TaskId',
|
|
6735
|
+
taskName: 'TaskName',
|
|
6736
|
+
};
|
|
6737
|
+
}
|
|
6738
|
+
static types() {
|
|
6739
|
+
return {
|
|
6740
|
+
acceleratorId: 'string',
|
|
6741
|
+
address: 'string',
|
|
6742
|
+
detectThreshold: 'number',
|
|
6743
|
+
listenerId: 'string',
|
|
6744
|
+
optionsJson: 'string',
|
|
6745
|
+
state: 'string',
|
|
6746
|
+
taskId: 'string',
|
|
6747
|
+
taskName: 'string',
|
|
6748
|
+
};
|
|
6749
|
+
}
|
|
6750
|
+
}
|
|
6751
|
+
exports.ListApplicationMonitorResponseBodyApplicationMonitors = ListApplicationMonitorResponseBodyApplicationMonitors;
|
|
6752
|
+
class ListApplicationMonitorDetectResultResponseBodyApplicationMonitorDetectResultList extends $tea.Model {
|
|
6753
|
+
constructor(map) {
|
|
6754
|
+
super(map);
|
|
6755
|
+
}
|
|
6756
|
+
static names() {
|
|
6757
|
+
return {
|
|
6758
|
+
acceleratorId: 'AcceleratorId',
|
|
6759
|
+
detail: 'Detail',
|
|
6760
|
+
diagStatus: 'DiagStatus',
|
|
6761
|
+
listenerId: 'ListenerId',
|
|
6762
|
+
port: 'Port',
|
|
6763
|
+
protocol: 'Protocol',
|
|
6764
|
+
taskId: 'TaskId',
|
|
6765
|
+
};
|
|
6766
|
+
}
|
|
6767
|
+
static types() {
|
|
6768
|
+
return {
|
|
6769
|
+
acceleratorId: 'string',
|
|
6770
|
+
detail: 'string',
|
|
6771
|
+
diagStatus: 'string',
|
|
6772
|
+
listenerId: 'string',
|
|
6773
|
+
port: 'string',
|
|
6774
|
+
protocol: 'string',
|
|
6775
|
+
taskId: 'string',
|
|
6776
|
+
};
|
|
6777
|
+
}
|
|
6778
|
+
}
|
|
6779
|
+
exports.ListApplicationMonitorDetectResultResponseBodyApplicationMonitorDetectResultList = ListApplicationMonitorDetectResultResponseBodyApplicationMonitorDetectResultList;
|
|
6090
6780
|
class ListAvailableAccelerateAreasResponseBodyAreasRegionList extends $tea.Model {
|
|
6091
6781
|
constructor(map) {
|
|
6092
6782
|
super(map);
|
|
@@ -6464,6 +7154,7 @@ class ListForwardingRulesResponseBodyForwardingRulesRuleActions extends $tea.Mod
|
|
|
6464
7154
|
forwardGroupConfig: 'ForwardGroupConfig',
|
|
6465
7155
|
order: 'Order',
|
|
6466
7156
|
ruleActionType: 'RuleActionType',
|
|
7157
|
+
ruleActionValue: 'RuleActionValue',
|
|
6467
7158
|
};
|
|
6468
7159
|
}
|
|
6469
7160
|
static types() {
|
|
@@ -6471,6 +7162,7 @@ class ListForwardingRulesResponseBodyForwardingRulesRuleActions extends $tea.Mod
|
|
|
6471
7162
|
forwardGroupConfig: ListForwardingRulesResponseBodyForwardingRulesRuleActionsForwardGroupConfig,
|
|
6472
7163
|
order: 'number',
|
|
6473
7164
|
ruleActionType: 'string',
|
|
7165
|
+
ruleActionValue: 'string',
|
|
6474
7166
|
};
|
|
6475
7167
|
}
|
|
6476
7168
|
}
|
|
@@ -6516,6 +7208,7 @@ class ListForwardingRulesResponseBodyForwardingRulesRuleConditions extends $tea.
|
|
|
6516
7208
|
hostConfig: 'HostConfig',
|
|
6517
7209
|
pathConfig: 'PathConfig',
|
|
6518
7210
|
ruleConditionType: 'RuleConditionType',
|
|
7211
|
+
ruleConditionValue: 'RuleConditionValue',
|
|
6519
7212
|
};
|
|
6520
7213
|
}
|
|
6521
7214
|
static types() {
|
|
@@ -6523,6 +7216,7 @@ class ListForwardingRulesResponseBodyForwardingRulesRuleConditions extends $tea.
|
|
|
6523
7216
|
hostConfig: ListForwardingRulesResponseBodyForwardingRulesRuleConditionsHostConfig,
|
|
6524
7217
|
pathConfig: ListForwardingRulesResponseBodyForwardingRulesRuleConditionsPathConfig,
|
|
6525
7218
|
ruleConditionType: 'string',
|
|
7219
|
+
ruleConditionValue: 'string',
|
|
6526
7220
|
};
|
|
6527
7221
|
}
|
|
6528
7222
|
}
|
|
@@ -6533,6 +7227,7 @@ class ListForwardingRulesResponseBodyForwardingRules extends $tea.Model {
|
|
|
6533
7227
|
}
|
|
6534
7228
|
static names() {
|
|
6535
7229
|
return {
|
|
7230
|
+
forwardingRuleDirection: 'ForwardingRuleDirection',
|
|
6536
7231
|
forwardingRuleId: 'ForwardingRuleId',
|
|
6537
7232
|
forwardingRuleName: 'ForwardingRuleName',
|
|
6538
7233
|
forwardingRuleStatus: 'ForwardingRuleStatus',
|
|
@@ -6544,6 +7239,7 @@ class ListForwardingRulesResponseBodyForwardingRules extends $tea.Model {
|
|
|
6544
7239
|
}
|
|
6545
7240
|
static types() {
|
|
6546
7241
|
return {
|
|
7242
|
+
forwardingRuleDirection: 'string',
|
|
6547
7243
|
forwardingRuleId: 'string',
|
|
6548
7244
|
forwardingRuleName: 'string',
|
|
6549
7245
|
forwardingRuleStatus: 'string',
|
|
@@ -6938,6 +7634,7 @@ class UpdateForwardingRulesRequestForwardingRulesRuleActions extends $tea.Model
|
|
|
6938
7634
|
forwardGroupConfig: 'ForwardGroupConfig',
|
|
6939
7635
|
order: 'Order',
|
|
6940
7636
|
ruleActionType: 'RuleActionType',
|
|
7637
|
+
ruleActionValue: 'RuleActionValue',
|
|
6941
7638
|
};
|
|
6942
7639
|
}
|
|
6943
7640
|
static types() {
|
|
@@ -6945,6 +7642,7 @@ class UpdateForwardingRulesRequestForwardingRulesRuleActions extends $tea.Model
|
|
|
6945
7642
|
forwardGroupConfig: UpdateForwardingRulesRequestForwardingRulesRuleActionsForwardGroupConfig,
|
|
6946
7643
|
order: 'number',
|
|
6947
7644
|
ruleActionType: 'string',
|
|
7645
|
+
ruleActionValue: 'string',
|
|
6948
7646
|
};
|
|
6949
7647
|
}
|
|
6950
7648
|
}
|
|
@@ -6990,6 +7688,7 @@ class UpdateForwardingRulesRequestForwardingRulesRuleConditions extends $tea.Mod
|
|
|
6990
7688
|
hostConfig: 'HostConfig',
|
|
6991
7689
|
pathConfig: 'PathConfig',
|
|
6992
7690
|
ruleConditionType: 'RuleConditionType',
|
|
7691
|
+
ruleConditionValue: 'RuleConditionValue',
|
|
6993
7692
|
};
|
|
6994
7693
|
}
|
|
6995
7694
|
static types() {
|
|
@@ -6997,6 +7696,7 @@ class UpdateForwardingRulesRequestForwardingRulesRuleConditions extends $tea.Mod
|
|
|
6997
7696
|
hostConfig: UpdateForwardingRulesRequestForwardingRulesRuleConditionsHostConfig,
|
|
6998
7697
|
pathConfig: UpdateForwardingRulesRequestForwardingRulesRuleConditionsPathConfig,
|
|
6999
7698
|
ruleConditionType: 'string',
|
|
7699
|
+
ruleConditionValue: 'string',
|
|
7000
7700
|
};
|
|
7001
7701
|
}
|
|
7002
7702
|
}
|
|
@@ -7012,6 +7712,7 @@ class UpdateForwardingRulesRequestForwardingRules extends $tea.Model {
|
|
|
7012
7712
|
priority: 'Priority',
|
|
7013
7713
|
ruleActions: 'RuleActions',
|
|
7014
7714
|
ruleConditions: 'RuleConditions',
|
|
7715
|
+
ruleDirection: 'RuleDirection',
|
|
7015
7716
|
};
|
|
7016
7717
|
}
|
|
7017
7718
|
static types() {
|
|
@@ -7021,6 +7722,7 @@ class UpdateForwardingRulesRequestForwardingRules extends $tea.Model {
|
|
|
7021
7722
|
priority: 'number',
|
|
7022
7723
|
ruleActions: { 'type': 'array', 'itemType': UpdateForwardingRulesRequestForwardingRulesRuleActions },
|
|
7023
7724
|
ruleConditions: { 'type': 'array', 'itemType': UpdateForwardingRulesRequestForwardingRulesRuleConditions },
|
|
7725
|
+
ruleDirection: 'string',
|
|
7024
7726
|
};
|
|
7025
7727
|
}
|
|
7026
7728
|
}
|
|
@@ -7154,14 +7856,23 @@ class Client extends openapi_client_1.default {
|
|
|
7154
7856
|
async addEntriesToAclWithOptions(request, runtime) {
|
|
7155
7857
|
tea_util_1.default.validateModel(request);
|
|
7156
7858
|
let query = {};
|
|
7157
|
-
|
|
7158
|
-
|
|
7159
|
-
|
|
7160
|
-
|
|
7161
|
-
|
|
7859
|
+
if (!tea_util_1.default.isUnset(request.aclEntries)) {
|
|
7860
|
+
query["AclEntries"] = request.aclEntries;
|
|
7861
|
+
}
|
|
7862
|
+
if (!tea_util_1.default.isUnset(request.aclId)) {
|
|
7863
|
+
query["AclId"] = request.aclId;
|
|
7864
|
+
}
|
|
7865
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
7866
|
+
query["ClientToken"] = request.clientToken;
|
|
7867
|
+
}
|
|
7868
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
7869
|
+
query["DryRun"] = request.dryRun;
|
|
7870
|
+
}
|
|
7871
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
7872
|
+
query["RegionId"] = request.regionId;
|
|
7873
|
+
}
|
|
7162
7874
|
let req = new $OpenApi.OpenApiRequest({
|
|
7163
7875
|
query: openapi_util_1.default.query(query),
|
|
7164
|
-
body: tea_util_1.default.toMap(request),
|
|
7165
7876
|
});
|
|
7166
7877
|
let params = new $OpenApi.Params({
|
|
7167
7878
|
action: "AddEntriesToAcl",
|
|
@@ -7171,7 +7882,7 @@ class Client extends openapi_client_1.default {
|
|
|
7171
7882
|
method: "POST",
|
|
7172
7883
|
authType: "AK",
|
|
7173
7884
|
style: "RPC",
|
|
7174
|
-
reqBodyType: "
|
|
7885
|
+
reqBodyType: "formData",
|
|
7175
7886
|
bodyType: "json",
|
|
7176
7887
|
});
|
|
7177
7888
|
return $tea.cast(await this.callApi(params, req, runtime), new AddEntriesToAclResponse({}));
|
|
@@ -7183,15 +7894,26 @@ class Client extends openapi_client_1.default {
|
|
|
7183
7894
|
async associateAclsWithListenerWithOptions(request, runtime) {
|
|
7184
7895
|
tea_util_1.default.validateModel(request);
|
|
7185
7896
|
let query = {};
|
|
7186
|
-
|
|
7187
|
-
|
|
7188
|
-
|
|
7189
|
-
|
|
7190
|
-
|
|
7191
|
-
|
|
7897
|
+
if (!tea_util_1.default.isUnset(request.aclIds)) {
|
|
7898
|
+
query["AclIds"] = request.aclIds;
|
|
7899
|
+
}
|
|
7900
|
+
if (!tea_util_1.default.isUnset(request.aclType)) {
|
|
7901
|
+
query["AclType"] = request.aclType;
|
|
7902
|
+
}
|
|
7903
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
7904
|
+
query["ClientToken"] = request.clientToken;
|
|
7905
|
+
}
|
|
7906
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
7907
|
+
query["DryRun"] = request.dryRun;
|
|
7908
|
+
}
|
|
7909
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
7910
|
+
query["ListenerId"] = request.listenerId;
|
|
7911
|
+
}
|
|
7912
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
7913
|
+
query["RegionId"] = request.regionId;
|
|
7914
|
+
}
|
|
7192
7915
|
let req = new $OpenApi.OpenApiRequest({
|
|
7193
7916
|
query: openapi_util_1.default.query(query),
|
|
7194
|
-
body: tea_util_1.default.toMap(request),
|
|
7195
7917
|
});
|
|
7196
7918
|
let params = new $OpenApi.Params({
|
|
7197
7919
|
action: "AssociateAclsWithListener",
|
|
@@ -7201,7 +7923,7 @@ class Client extends openapi_client_1.default {
|
|
|
7201
7923
|
method: "POST",
|
|
7202
7924
|
authType: "AK",
|
|
7203
7925
|
style: "RPC",
|
|
7204
|
-
reqBodyType: "
|
|
7926
|
+
reqBodyType: "formData",
|
|
7205
7927
|
bodyType: "json",
|
|
7206
7928
|
});
|
|
7207
7929
|
return $tea.cast(await this.callApi(params, req, runtime), new AssociateAclsWithListenerResponse({}));
|
|
@@ -7213,14 +7935,23 @@ class Client extends openapi_client_1.default {
|
|
|
7213
7935
|
async associateAdditionalCertificatesWithListenerWithOptions(request, runtime) {
|
|
7214
7936
|
tea_util_1.default.validateModel(request);
|
|
7215
7937
|
let query = {};
|
|
7216
|
-
|
|
7217
|
-
|
|
7218
|
-
|
|
7219
|
-
|
|
7220
|
-
|
|
7938
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
7939
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
7940
|
+
}
|
|
7941
|
+
if (!tea_util_1.default.isUnset(request.certificates)) {
|
|
7942
|
+
query["Certificates"] = request.certificates;
|
|
7943
|
+
}
|
|
7944
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
7945
|
+
query["ClientToken"] = request.clientToken;
|
|
7946
|
+
}
|
|
7947
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
7948
|
+
query["ListenerId"] = request.listenerId;
|
|
7949
|
+
}
|
|
7950
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
7951
|
+
query["RegionId"] = request.regionId;
|
|
7952
|
+
}
|
|
7221
7953
|
let req = new $OpenApi.OpenApiRequest({
|
|
7222
7954
|
query: openapi_util_1.default.query(query),
|
|
7223
|
-
body: tea_util_1.default.toMap(request),
|
|
7224
7955
|
});
|
|
7225
7956
|
let params = new $OpenApi.Params({
|
|
7226
7957
|
action: "AssociateAdditionalCertificatesWithListener",
|
|
@@ -7230,7 +7961,7 @@ class Client extends openapi_client_1.default {
|
|
|
7230
7961
|
method: "POST",
|
|
7231
7962
|
authType: "AK",
|
|
7232
7963
|
style: "RPC",
|
|
7233
|
-
reqBodyType: "
|
|
7964
|
+
reqBodyType: "formData",
|
|
7234
7965
|
bodyType: "json",
|
|
7235
7966
|
});
|
|
7236
7967
|
return $tea.cast(await this.callApi(params, req, runtime), new AssociateAdditionalCertificatesWithListenerResponse({}));
|
|
@@ -7242,13 +7973,20 @@ class Client extends openapi_client_1.default {
|
|
|
7242
7973
|
async attachDdosToAcceleratorWithOptions(request, runtime) {
|
|
7243
7974
|
tea_util_1.default.validateModel(request);
|
|
7244
7975
|
let query = {};
|
|
7245
|
-
|
|
7246
|
-
|
|
7247
|
-
|
|
7248
|
-
|
|
7976
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
7977
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
7978
|
+
}
|
|
7979
|
+
if (!tea_util_1.default.isUnset(request.ddosId)) {
|
|
7980
|
+
query["DdosId"] = request.ddosId;
|
|
7981
|
+
}
|
|
7982
|
+
if (!tea_util_1.default.isUnset(request.ddosRegionId)) {
|
|
7983
|
+
query["DdosRegionId"] = request.ddosRegionId;
|
|
7984
|
+
}
|
|
7985
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
7986
|
+
query["RegionId"] = request.regionId;
|
|
7987
|
+
}
|
|
7249
7988
|
let req = new $OpenApi.OpenApiRequest({
|
|
7250
7989
|
query: openapi_util_1.default.query(query),
|
|
7251
|
-
body: tea_util_1.default.toMap(request),
|
|
7252
7990
|
});
|
|
7253
7991
|
let params = new $OpenApi.Params({
|
|
7254
7992
|
action: "AttachDdosToAccelerator",
|
|
@@ -7258,7 +7996,7 @@ class Client extends openapi_client_1.default {
|
|
|
7258
7996
|
method: "POST",
|
|
7259
7997
|
authType: "AK",
|
|
7260
7998
|
style: "RPC",
|
|
7261
|
-
reqBodyType: "
|
|
7999
|
+
reqBodyType: "formData",
|
|
7262
8000
|
bodyType: "json",
|
|
7263
8001
|
});
|
|
7264
8002
|
return $tea.cast(await this.callApi(params, req, runtime), new AttachDdosToAcceleratorResponse({}));
|
|
@@ -7270,17 +8008,32 @@ class Client extends openapi_client_1.default {
|
|
|
7270
8008
|
async attachLogStoreToEndpointGroupWithOptions(request, runtime) {
|
|
7271
8009
|
tea_util_1.default.validateModel(request);
|
|
7272
8010
|
let query = {};
|
|
7273
|
-
|
|
7274
|
-
|
|
7275
|
-
|
|
7276
|
-
|
|
7277
|
-
|
|
7278
|
-
|
|
7279
|
-
|
|
7280
|
-
|
|
8011
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8012
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8013
|
+
}
|
|
8014
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8015
|
+
query["ClientToken"] = request.clientToken;
|
|
8016
|
+
}
|
|
8017
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupIds)) {
|
|
8018
|
+
query["EndpointGroupIds"] = request.endpointGroupIds;
|
|
8019
|
+
}
|
|
8020
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
8021
|
+
query["ListenerId"] = request.listenerId;
|
|
8022
|
+
}
|
|
8023
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8024
|
+
query["RegionId"] = request.regionId;
|
|
8025
|
+
}
|
|
8026
|
+
if (!tea_util_1.default.isUnset(request.slsLogStoreName)) {
|
|
8027
|
+
query["SlsLogStoreName"] = request.slsLogStoreName;
|
|
8028
|
+
}
|
|
8029
|
+
if (!tea_util_1.default.isUnset(request.slsProjectName)) {
|
|
8030
|
+
query["SlsProjectName"] = request.slsProjectName;
|
|
8031
|
+
}
|
|
8032
|
+
if (!tea_util_1.default.isUnset(request.slsRegionId)) {
|
|
8033
|
+
query["SlsRegionId"] = request.slsRegionId;
|
|
8034
|
+
}
|
|
7281
8035
|
let req = new $OpenApi.OpenApiRequest({
|
|
7282
8036
|
query: openapi_util_1.default.query(query),
|
|
7283
|
-
body: tea_util_1.default.toMap(request),
|
|
7284
8037
|
});
|
|
7285
8038
|
let params = new $OpenApi.Params({
|
|
7286
8039
|
action: "AttachLogStoreToEndpointGroup",
|
|
@@ -7290,7 +8043,7 @@ class Client extends openapi_client_1.default {
|
|
|
7290
8043
|
method: "POST",
|
|
7291
8044
|
authType: "AK",
|
|
7292
8045
|
style: "RPC",
|
|
7293
|
-
reqBodyType: "
|
|
8046
|
+
reqBodyType: "formData",
|
|
7294
8047
|
bodyType: "json",
|
|
7295
8048
|
});
|
|
7296
8049
|
return $tea.cast(await this.callApi(params, req, runtime), new AttachLogStoreToEndpointGroupResponse({}));
|
|
@@ -7302,12 +8055,17 @@ class Client extends openapi_client_1.default {
|
|
|
7302
8055
|
async bandwidthPackageAddAcceleratorWithOptions(request, runtime) {
|
|
7303
8056
|
tea_util_1.default.validateModel(request);
|
|
7304
8057
|
let query = {};
|
|
7305
|
-
|
|
7306
|
-
|
|
7307
|
-
|
|
8058
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8059
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8060
|
+
}
|
|
8061
|
+
if (!tea_util_1.default.isUnset(request.bandwidthPackageId)) {
|
|
8062
|
+
query["BandwidthPackageId"] = request.bandwidthPackageId;
|
|
8063
|
+
}
|
|
8064
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8065
|
+
query["RegionId"] = request.regionId;
|
|
8066
|
+
}
|
|
7308
8067
|
let req = new $OpenApi.OpenApiRequest({
|
|
7309
8068
|
query: openapi_util_1.default.query(query),
|
|
7310
|
-
body: tea_util_1.default.toMap(request),
|
|
7311
8069
|
});
|
|
7312
8070
|
let params = new $OpenApi.Params({
|
|
7313
8071
|
action: "BandwidthPackageAddAccelerator",
|
|
@@ -7317,7 +8075,7 @@ class Client extends openapi_client_1.default {
|
|
|
7317
8075
|
method: "POST",
|
|
7318
8076
|
authType: "AK",
|
|
7319
8077
|
style: "RPC",
|
|
7320
|
-
reqBodyType: "
|
|
8078
|
+
reqBodyType: "formData",
|
|
7321
8079
|
bodyType: "json",
|
|
7322
8080
|
});
|
|
7323
8081
|
return $tea.cast(await this.callApi(params, req, runtime), new BandwidthPackageAddAcceleratorResponse({}));
|
|
@@ -7329,12 +8087,17 @@ class Client extends openapi_client_1.default {
|
|
|
7329
8087
|
async bandwidthPackageRemoveAcceleratorWithOptions(request, runtime) {
|
|
7330
8088
|
tea_util_1.default.validateModel(request);
|
|
7331
8089
|
let query = {};
|
|
7332
|
-
|
|
7333
|
-
|
|
7334
|
-
|
|
8090
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8091
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8092
|
+
}
|
|
8093
|
+
if (!tea_util_1.default.isUnset(request.bandwidthPackageId)) {
|
|
8094
|
+
query["BandwidthPackageId"] = request.bandwidthPackageId;
|
|
8095
|
+
}
|
|
8096
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8097
|
+
query["RegionId"] = request.regionId;
|
|
8098
|
+
}
|
|
7335
8099
|
let req = new $OpenApi.OpenApiRequest({
|
|
7336
8100
|
query: openapi_util_1.default.query(query),
|
|
7337
|
-
body: tea_util_1.default.toMap(request),
|
|
7338
8101
|
});
|
|
7339
8102
|
let params = new $OpenApi.Params({
|
|
7340
8103
|
action: "BandwidthPackageRemoveAccelerator",
|
|
@@ -7344,7 +8107,7 @@ class Client extends openapi_client_1.default {
|
|
|
7344
8107
|
method: "POST",
|
|
7345
8108
|
authType: "AK",
|
|
7346
8109
|
style: "RPC",
|
|
7347
|
-
reqBodyType: "
|
|
8110
|
+
reqBodyType: "formData",
|
|
7348
8111
|
bodyType: "json",
|
|
7349
8112
|
});
|
|
7350
8113
|
return $tea.cast(await this.callApi(params, req, runtime), new BandwidthPackageRemoveAcceleratorResponse({}));
|
|
@@ -7356,17 +8119,32 @@ class Client extends openapi_client_1.default {
|
|
|
7356
8119
|
async configEndpointProbeWithOptions(request, runtime) {
|
|
7357
8120
|
tea_util_1.default.validateModel(request);
|
|
7358
8121
|
let query = {};
|
|
7359
|
-
|
|
7360
|
-
|
|
7361
|
-
|
|
7362
|
-
|
|
7363
|
-
|
|
7364
|
-
|
|
7365
|
-
|
|
7366
|
-
|
|
8122
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8123
|
+
query["ClientToken"] = request.clientToken;
|
|
8124
|
+
}
|
|
8125
|
+
if (!tea_util_1.default.isUnset(request.enable)) {
|
|
8126
|
+
query["Enable"] = request.enable;
|
|
8127
|
+
}
|
|
8128
|
+
if (!tea_util_1.default.isUnset(request.endpoint)) {
|
|
8129
|
+
query["Endpoint"] = request.endpoint;
|
|
8130
|
+
}
|
|
8131
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupId)) {
|
|
8132
|
+
query["EndpointGroupId"] = request.endpointGroupId;
|
|
8133
|
+
}
|
|
8134
|
+
if (!tea_util_1.default.isUnset(request.endpointType)) {
|
|
8135
|
+
query["EndpointType"] = request.endpointType;
|
|
8136
|
+
}
|
|
8137
|
+
if (!tea_util_1.default.isUnset(request.probePort)) {
|
|
8138
|
+
query["ProbePort"] = request.probePort;
|
|
8139
|
+
}
|
|
8140
|
+
if (!tea_util_1.default.isUnset(request.probeProtocol)) {
|
|
8141
|
+
query["ProbeProtocol"] = request.probeProtocol;
|
|
8142
|
+
}
|
|
8143
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8144
|
+
query["RegionId"] = request.regionId;
|
|
8145
|
+
}
|
|
7367
8146
|
let req = new $OpenApi.OpenApiRequest({
|
|
7368
8147
|
query: openapi_util_1.default.query(query),
|
|
7369
|
-
body: tea_util_1.default.toMap(request),
|
|
7370
8148
|
});
|
|
7371
8149
|
let params = new $OpenApi.Params({
|
|
7372
8150
|
action: "ConfigEndpointProbe",
|
|
@@ -7376,7 +8154,7 @@ class Client extends openapi_client_1.default {
|
|
|
7376
8154
|
method: "POST",
|
|
7377
8155
|
authType: "AK",
|
|
7378
8156
|
style: "RPC",
|
|
7379
|
-
reqBodyType: "
|
|
8157
|
+
reqBodyType: "formData",
|
|
7380
8158
|
bodyType: "json",
|
|
7381
8159
|
});
|
|
7382
8160
|
return $tea.cast(await this.callApi(params, req, runtime), new ConfigEndpointProbeResponse({}));
|
|
@@ -7388,19 +8166,41 @@ class Client extends openapi_client_1.default {
|
|
|
7388
8166
|
async createAcceleratorWithOptions(request, runtime) {
|
|
7389
8167
|
tea_util_1.default.validateModel(request);
|
|
7390
8168
|
let query = {};
|
|
7391
|
-
|
|
7392
|
-
|
|
7393
|
-
|
|
7394
|
-
|
|
7395
|
-
|
|
7396
|
-
|
|
7397
|
-
|
|
7398
|
-
|
|
7399
|
-
|
|
7400
|
-
|
|
8169
|
+
if (!tea_util_1.default.isUnset(request.autoPay)) {
|
|
8170
|
+
query["AutoPay"] = request.autoPay;
|
|
8171
|
+
}
|
|
8172
|
+
if (!tea_util_1.default.isUnset(request.autoRenew)) {
|
|
8173
|
+
query["AutoRenew"] = request.autoRenew;
|
|
8174
|
+
}
|
|
8175
|
+
if (!tea_util_1.default.isUnset(request.autoRenewDuration)) {
|
|
8176
|
+
query["AutoRenewDuration"] = request.autoRenewDuration;
|
|
8177
|
+
}
|
|
8178
|
+
if (!tea_util_1.default.isUnset(request.autoUseCoupon)) {
|
|
8179
|
+
query["AutoUseCoupon"] = request.autoUseCoupon;
|
|
8180
|
+
}
|
|
8181
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8182
|
+
query["ClientToken"] = request.clientToken;
|
|
8183
|
+
}
|
|
8184
|
+
if (!tea_util_1.default.isUnset(request.duration)) {
|
|
8185
|
+
query["Duration"] = request.duration;
|
|
8186
|
+
}
|
|
8187
|
+
if (!tea_util_1.default.isUnset($tea.toMap(request.ipSetConfig))) {
|
|
8188
|
+
query["IpSetConfig"] = request.ipSetConfig;
|
|
8189
|
+
}
|
|
8190
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
8191
|
+
query["Name"] = request.name;
|
|
8192
|
+
}
|
|
8193
|
+
if (!tea_util_1.default.isUnset(request.pricingCycle)) {
|
|
8194
|
+
query["PricingCycle"] = request.pricingCycle;
|
|
8195
|
+
}
|
|
8196
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8197
|
+
query["RegionId"] = request.regionId;
|
|
8198
|
+
}
|
|
8199
|
+
if (!tea_util_1.default.isUnset(request.spec)) {
|
|
8200
|
+
query["Spec"] = request.spec;
|
|
8201
|
+
}
|
|
7401
8202
|
let req = new $OpenApi.OpenApiRequest({
|
|
7402
8203
|
query: openapi_util_1.default.query(query),
|
|
7403
|
-
body: tea_util_1.default.toMap(request),
|
|
7404
8204
|
});
|
|
7405
8205
|
let params = new $OpenApi.Params({
|
|
7406
8206
|
action: "CreateAccelerator",
|
|
@@ -7410,7 +8210,7 @@ class Client extends openapi_client_1.default {
|
|
|
7410
8210
|
method: "POST",
|
|
7411
8211
|
authType: "AK",
|
|
7412
8212
|
style: "RPC",
|
|
7413
|
-
reqBodyType: "
|
|
8213
|
+
reqBodyType: "formData",
|
|
7414
8214
|
bodyType: "json",
|
|
7415
8215
|
});
|
|
7416
8216
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateAcceleratorResponse({}));
|
|
@@ -7422,15 +8222,26 @@ class Client extends openapi_client_1.default {
|
|
|
7422
8222
|
async createAclWithOptions(request, runtime) {
|
|
7423
8223
|
tea_util_1.default.validateModel(request);
|
|
7424
8224
|
let query = {};
|
|
7425
|
-
|
|
7426
|
-
|
|
7427
|
-
|
|
7428
|
-
|
|
7429
|
-
|
|
7430
|
-
|
|
8225
|
+
if (!tea_util_1.default.isUnset(request.aclEntries)) {
|
|
8226
|
+
query["AclEntries"] = request.aclEntries;
|
|
8227
|
+
}
|
|
8228
|
+
if (!tea_util_1.default.isUnset(request.aclName)) {
|
|
8229
|
+
query["AclName"] = request.aclName;
|
|
8230
|
+
}
|
|
8231
|
+
if (!tea_util_1.default.isUnset(request.addressIPVersion)) {
|
|
8232
|
+
query["AddressIPVersion"] = request.addressIPVersion;
|
|
8233
|
+
}
|
|
8234
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8235
|
+
query["ClientToken"] = request.clientToken;
|
|
8236
|
+
}
|
|
8237
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
8238
|
+
query["DryRun"] = request.dryRun;
|
|
8239
|
+
}
|
|
8240
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8241
|
+
query["RegionId"] = request.regionId;
|
|
8242
|
+
}
|
|
7431
8243
|
let req = new $OpenApi.OpenApiRequest({
|
|
7432
8244
|
query: openapi_util_1.default.query(query),
|
|
7433
|
-
body: tea_util_1.default.toMap(request),
|
|
7434
8245
|
});
|
|
7435
8246
|
let params = new $OpenApi.Params({
|
|
7436
8247
|
action: "CreateAcl",
|
|
@@ -7440,7 +8251,7 @@ class Client extends openapi_client_1.default {
|
|
|
7440
8251
|
method: "POST",
|
|
7441
8252
|
authType: "AK",
|
|
7442
8253
|
style: "RPC",
|
|
7443
|
-
reqBodyType: "
|
|
8254
|
+
reqBodyType: "formData",
|
|
7444
8255
|
bodyType: "json",
|
|
7445
8256
|
});
|
|
7446
8257
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateAclResponse({}));
|
|
@@ -7449,26 +8260,100 @@ class Client extends openapi_client_1.default {
|
|
|
7449
8260
|
let runtime = new $Util.RuntimeOptions({});
|
|
7450
8261
|
return await this.createAclWithOptions(request, runtime);
|
|
7451
8262
|
}
|
|
8263
|
+
async createApplicationMonitorWithOptions(request, runtime) {
|
|
8264
|
+
tea_util_1.default.validateModel(request);
|
|
8265
|
+
let query = {};
|
|
8266
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8267
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8268
|
+
}
|
|
8269
|
+
if (!tea_util_1.default.isUnset(request.address)) {
|
|
8270
|
+
query["Address"] = request.address;
|
|
8271
|
+
}
|
|
8272
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8273
|
+
query["ClientToken"] = request.clientToken;
|
|
8274
|
+
}
|
|
8275
|
+
if (!tea_util_1.default.isUnset(request.detectThreshold)) {
|
|
8276
|
+
query["DetectThreshold"] = request.detectThreshold;
|
|
8277
|
+
}
|
|
8278
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
8279
|
+
query["ListenerId"] = request.listenerId;
|
|
8280
|
+
}
|
|
8281
|
+
if (!tea_util_1.default.isUnset(request.optionsJson)) {
|
|
8282
|
+
query["OptionsJson"] = request.optionsJson;
|
|
8283
|
+
}
|
|
8284
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8285
|
+
query["RegionId"] = request.regionId;
|
|
8286
|
+
}
|
|
8287
|
+
if (!tea_util_1.default.isUnset(request.taskName)) {
|
|
8288
|
+
query["TaskName"] = request.taskName;
|
|
8289
|
+
}
|
|
8290
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
8291
|
+
query: openapi_util_1.default.query(query),
|
|
8292
|
+
});
|
|
8293
|
+
let params = new $OpenApi.Params({
|
|
8294
|
+
action: "CreateApplicationMonitor",
|
|
8295
|
+
version: "2019-11-20",
|
|
8296
|
+
protocol: "HTTPS",
|
|
8297
|
+
pathname: "/",
|
|
8298
|
+
method: "POST",
|
|
8299
|
+
authType: "AK",
|
|
8300
|
+
style: "RPC",
|
|
8301
|
+
reqBodyType: "formData",
|
|
8302
|
+
bodyType: "json",
|
|
8303
|
+
});
|
|
8304
|
+
return $tea.cast(await this.callApi(params, req, runtime), new CreateApplicationMonitorResponse({}));
|
|
8305
|
+
}
|
|
8306
|
+
async createApplicationMonitor(request) {
|
|
8307
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
8308
|
+
return await this.createApplicationMonitorWithOptions(request, runtime);
|
|
8309
|
+
}
|
|
7452
8310
|
async createBandwidthPackageWithOptions(request, runtime) {
|
|
7453
8311
|
tea_util_1.default.validateModel(request);
|
|
7454
8312
|
let query = {};
|
|
7455
|
-
|
|
7456
|
-
|
|
7457
|
-
|
|
7458
|
-
|
|
7459
|
-
|
|
7460
|
-
|
|
7461
|
-
|
|
7462
|
-
|
|
7463
|
-
|
|
7464
|
-
|
|
7465
|
-
|
|
7466
|
-
|
|
7467
|
-
|
|
7468
|
-
|
|
8313
|
+
if (!tea_util_1.default.isUnset(request.autoPay)) {
|
|
8314
|
+
query["AutoPay"] = request.autoPay;
|
|
8315
|
+
}
|
|
8316
|
+
if (!tea_util_1.default.isUnset(request.autoUseCoupon)) {
|
|
8317
|
+
query["AutoUseCoupon"] = request.autoUseCoupon;
|
|
8318
|
+
}
|
|
8319
|
+
if (!tea_util_1.default.isUnset(request.bandwidth)) {
|
|
8320
|
+
query["Bandwidth"] = request.bandwidth;
|
|
8321
|
+
}
|
|
8322
|
+
if (!tea_util_1.default.isUnset(request.bandwidthType)) {
|
|
8323
|
+
query["BandwidthType"] = request.bandwidthType;
|
|
8324
|
+
}
|
|
8325
|
+
if (!tea_util_1.default.isUnset(request.billingType)) {
|
|
8326
|
+
query["BillingType"] = request.billingType;
|
|
8327
|
+
}
|
|
8328
|
+
if (!tea_util_1.default.isUnset(request.cbnGeographicRegionIdA)) {
|
|
8329
|
+
query["CbnGeographicRegionIdA"] = request.cbnGeographicRegionIdA;
|
|
8330
|
+
}
|
|
8331
|
+
if (!tea_util_1.default.isUnset(request.cbnGeographicRegionIdB)) {
|
|
8332
|
+
query["CbnGeographicRegionIdB"] = request.cbnGeographicRegionIdB;
|
|
8333
|
+
}
|
|
8334
|
+
if (!tea_util_1.default.isUnset(request.chargeType)) {
|
|
8335
|
+
query["ChargeType"] = request.chargeType;
|
|
8336
|
+
}
|
|
8337
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8338
|
+
query["ClientToken"] = request.clientToken;
|
|
8339
|
+
}
|
|
8340
|
+
if (!tea_util_1.default.isUnset(request.duration)) {
|
|
8341
|
+
query["Duration"] = request.duration;
|
|
8342
|
+
}
|
|
8343
|
+
if (!tea_util_1.default.isUnset(request.pricingCycle)) {
|
|
8344
|
+
query["PricingCycle"] = request.pricingCycle;
|
|
8345
|
+
}
|
|
8346
|
+
if (!tea_util_1.default.isUnset(request.ratio)) {
|
|
8347
|
+
query["Ratio"] = request.ratio;
|
|
8348
|
+
}
|
|
8349
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8350
|
+
query["RegionId"] = request.regionId;
|
|
8351
|
+
}
|
|
8352
|
+
if (!tea_util_1.default.isUnset(request.type)) {
|
|
8353
|
+
query["Type"] = request.type;
|
|
8354
|
+
}
|
|
7469
8355
|
let req = new $OpenApi.OpenApiRequest({
|
|
7470
8356
|
query: openapi_util_1.default.query(query),
|
|
7471
|
-
body: tea_util_1.default.toMap(request),
|
|
7472
8357
|
});
|
|
7473
8358
|
let params = new $OpenApi.Params({
|
|
7474
8359
|
action: "CreateBandwidthPackage",
|
|
@@ -7478,7 +8363,7 @@ class Client extends openapi_client_1.default {
|
|
|
7478
8363
|
method: "POST",
|
|
7479
8364
|
authType: "AK",
|
|
7480
8365
|
style: "RPC",
|
|
7481
|
-
reqBodyType: "
|
|
8366
|
+
reqBodyType: "formData",
|
|
7482
8367
|
bodyType: "json",
|
|
7483
8368
|
});
|
|
7484
8369
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateBandwidthPackageResponse({}));
|
|
@@ -7490,17 +8375,32 @@ class Client extends openapi_client_1.default {
|
|
|
7490
8375
|
async createBasicAcceleratorWithOptions(request, runtime) {
|
|
7491
8376
|
tea_util_1.default.validateModel(request);
|
|
7492
8377
|
let query = {};
|
|
7493
|
-
|
|
7494
|
-
|
|
7495
|
-
|
|
7496
|
-
|
|
7497
|
-
|
|
7498
|
-
|
|
7499
|
-
|
|
7500
|
-
|
|
8378
|
+
if (!tea_util_1.default.isUnset(request.autoPay)) {
|
|
8379
|
+
query["AutoPay"] = request.autoPay;
|
|
8380
|
+
}
|
|
8381
|
+
if (!tea_util_1.default.isUnset(request.autoRenew)) {
|
|
8382
|
+
query["AutoRenew"] = request.autoRenew;
|
|
8383
|
+
}
|
|
8384
|
+
if (!tea_util_1.default.isUnset(request.autoRenewDuration)) {
|
|
8385
|
+
query["AutoRenewDuration"] = request.autoRenewDuration;
|
|
8386
|
+
}
|
|
8387
|
+
if (!tea_util_1.default.isUnset(request.autoUseCoupon)) {
|
|
8388
|
+
query["AutoUseCoupon"] = request.autoUseCoupon;
|
|
8389
|
+
}
|
|
8390
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8391
|
+
query["ClientToken"] = request.clientToken;
|
|
8392
|
+
}
|
|
8393
|
+
if (!tea_util_1.default.isUnset(request.duration)) {
|
|
8394
|
+
query["Duration"] = request.duration;
|
|
8395
|
+
}
|
|
8396
|
+
if (!tea_util_1.default.isUnset(request.pricingCycle)) {
|
|
8397
|
+
query["PricingCycle"] = request.pricingCycle;
|
|
8398
|
+
}
|
|
8399
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8400
|
+
query["RegionId"] = request.regionId;
|
|
8401
|
+
}
|
|
7501
8402
|
let req = new $OpenApi.OpenApiRequest({
|
|
7502
8403
|
query: openapi_util_1.default.query(query),
|
|
7503
|
-
body: tea_util_1.default.toMap(request),
|
|
7504
8404
|
});
|
|
7505
8405
|
let params = new $OpenApi.Params({
|
|
7506
8406
|
action: "CreateBasicAccelerator",
|
|
@@ -7510,7 +8410,7 @@ class Client extends openapi_client_1.default {
|
|
|
7510
8410
|
method: "POST",
|
|
7511
8411
|
authType: "AK",
|
|
7512
8412
|
style: "RPC",
|
|
7513
|
-
reqBodyType: "
|
|
8413
|
+
reqBodyType: "formData",
|
|
7514
8414
|
bodyType: "json",
|
|
7515
8415
|
});
|
|
7516
8416
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateBasicAcceleratorResponse({}));
|
|
@@ -7522,17 +8422,32 @@ class Client extends openapi_client_1.default {
|
|
|
7522
8422
|
async createBasicEndpointGroupWithOptions(request, runtime) {
|
|
7523
8423
|
tea_util_1.default.validateModel(request);
|
|
7524
8424
|
let query = {};
|
|
7525
|
-
|
|
7526
|
-
|
|
7527
|
-
|
|
7528
|
-
|
|
7529
|
-
|
|
7530
|
-
|
|
7531
|
-
|
|
7532
|
-
|
|
8425
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8426
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8427
|
+
}
|
|
8428
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8429
|
+
query["ClientToken"] = request.clientToken;
|
|
8430
|
+
}
|
|
8431
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
8432
|
+
query["Description"] = request.description;
|
|
8433
|
+
}
|
|
8434
|
+
if (!tea_util_1.default.isUnset(request.endpointAddress)) {
|
|
8435
|
+
query["EndpointAddress"] = request.endpointAddress;
|
|
8436
|
+
}
|
|
8437
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupRegion)) {
|
|
8438
|
+
query["EndpointGroupRegion"] = request.endpointGroupRegion;
|
|
8439
|
+
}
|
|
8440
|
+
if (!tea_util_1.default.isUnset(request.endpointType)) {
|
|
8441
|
+
query["EndpointType"] = request.endpointType;
|
|
8442
|
+
}
|
|
8443
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
8444
|
+
query["Name"] = request.name;
|
|
8445
|
+
}
|
|
8446
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8447
|
+
query["RegionId"] = request.regionId;
|
|
8448
|
+
}
|
|
7533
8449
|
let req = new $OpenApi.OpenApiRequest({
|
|
7534
8450
|
query: openapi_util_1.default.query(query),
|
|
7535
|
-
body: tea_util_1.default.toMap(request),
|
|
7536
8451
|
});
|
|
7537
8452
|
let params = new $OpenApi.Params({
|
|
7538
8453
|
action: "CreateBasicEndpointGroup",
|
|
@@ -7542,7 +8457,7 @@ class Client extends openapi_client_1.default {
|
|
|
7542
8457
|
method: "POST",
|
|
7543
8458
|
authType: "AK",
|
|
7544
8459
|
style: "RPC",
|
|
7545
|
-
reqBodyType: "
|
|
8460
|
+
reqBodyType: "formData",
|
|
7546
8461
|
bodyType: "json",
|
|
7547
8462
|
});
|
|
7548
8463
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateBasicEndpointGroupResponse({}));
|
|
@@ -7554,13 +8469,20 @@ class Client extends openapi_client_1.default {
|
|
|
7554
8469
|
async createBasicIpSetWithOptions(request, runtime) {
|
|
7555
8470
|
tea_util_1.default.validateModel(request);
|
|
7556
8471
|
let query = {};
|
|
7557
|
-
|
|
7558
|
-
|
|
7559
|
-
|
|
7560
|
-
|
|
8472
|
+
if (!tea_util_1.default.isUnset(request.accelerateRegionId)) {
|
|
8473
|
+
query["AccelerateRegionId"] = request.accelerateRegionId;
|
|
8474
|
+
}
|
|
8475
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8476
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8477
|
+
}
|
|
8478
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8479
|
+
query["ClientToken"] = request.clientToken;
|
|
8480
|
+
}
|
|
8481
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8482
|
+
query["RegionId"] = request.regionId;
|
|
8483
|
+
}
|
|
7561
8484
|
let req = new $OpenApi.OpenApiRequest({
|
|
7562
8485
|
query: openapi_util_1.default.query(query),
|
|
7563
|
-
body: tea_util_1.default.toMap(request),
|
|
7564
8486
|
});
|
|
7565
8487
|
let params = new $OpenApi.Params({
|
|
7566
8488
|
action: "CreateBasicIpSet",
|
|
@@ -7570,7 +8492,7 @@ class Client extends openapi_client_1.default {
|
|
|
7570
8492
|
method: "POST",
|
|
7571
8493
|
authType: "AK",
|
|
7572
8494
|
style: "RPC",
|
|
7573
|
-
reqBodyType: "
|
|
8495
|
+
reqBodyType: "formData",
|
|
7574
8496
|
bodyType: "json",
|
|
7575
8497
|
});
|
|
7576
8498
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateBasicIpSetResponse({}));
|
|
@@ -7582,27 +8504,62 @@ class Client extends openapi_client_1.default {
|
|
|
7582
8504
|
async createEndpointGroupWithOptions(request, runtime) {
|
|
7583
8505
|
tea_util_1.default.validateModel(request);
|
|
7584
8506
|
let query = {};
|
|
7585
|
-
|
|
7586
|
-
|
|
7587
|
-
|
|
7588
|
-
|
|
7589
|
-
|
|
7590
|
-
|
|
7591
|
-
|
|
7592
|
-
|
|
7593
|
-
|
|
7594
|
-
|
|
7595
|
-
|
|
7596
|
-
|
|
7597
|
-
|
|
7598
|
-
|
|
7599
|
-
|
|
7600
|
-
|
|
7601
|
-
|
|
7602
|
-
|
|
8507
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8508
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8509
|
+
}
|
|
8510
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8511
|
+
query["ClientToken"] = request.clientToken;
|
|
8512
|
+
}
|
|
8513
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
8514
|
+
query["Description"] = request.description;
|
|
8515
|
+
}
|
|
8516
|
+
if (!tea_util_1.default.isUnset(request.endpointConfigurations)) {
|
|
8517
|
+
query["EndpointConfigurations"] = request.endpointConfigurations;
|
|
8518
|
+
}
|
|
8519
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupRegion)) {
|
|
8520
|
+
query["EndpointGroupRegion"] = request.endpointGroupRegion;
|
|
8521
|
+
}
|
|
8522
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupType)) {
|
|
8523
|
+
query["EndpointGroupType"] = request.endpointGroupType;
|
|
8524
|
+
}
|
|
8525
|
+
if (!tea_util_1.default.isUnset(request.endpointRequestProtocol)) {
|
|
8526
|
+
query["EndpointRequestProtocol"] = request.endpointRequestProtocol;
|
|
8527
|
+
}
|
|
8528
|
+
if (!tea_util_1.default.isUnset(request.healthCheckEnabled)) {
|
|
8529
|
+
query["HealthCheckEnabled"] = request.healthCheckEnabled;
|
|
8530
|
+
}
|
|
8531
|
+
if (!tea_util_1.default.isUnset(request.healthCheckIntervalSeconds)) {
|
|
8532
|
+
query["HealthCheckIntervalSeconds"] = request.healthCheckIntervalSeconds;
|
|
8533
|
+
}
|
|
8534
|
+
if (!tea_util_1.default.isUnset(request.healthCheckPath)) {
|
|
8535
|
+
query["HealthCheckPath"] = request.healthCheckPath;
|
|
8536
|
+
}
|
|
8537
|
+
if (!tea_util_1.default.isUnset(request.healthCheckPort)) {
|
|
8538
|
+
query["HealthCheckPort"] = request.healthCheckPort;
|
|
8539
|
+
}
|
|
8540
|
+
if (!tea_util_1.default.isUnset(request.healthCheckProtocol)) {
|
|
8541
|
+
query["HealthCheckProtocol"] = request.healthCheckProtocol;
|
|
8542
|
+
}
|
|
8543
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
8544
|
+
query["ListenerId"] = request.listenerId;
|
|
8545
|
+
}
|
|
8546
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
8547
|
+
query["Name"] = request.name;
|
|
8548
|
+
}
|
|
8549
|
+
if (!tea_util_1.default.isUnset(request.portOverrides)) {
|
|
8550
|
+
query["PortOverrides"] = request.portOverrides;
|
|
8551
|
+
}
|
|
8552
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8553
|
+
query["RegionId"] = request.regionId;
|
|
8554
|
+
}
|
|
8555
|
+
if (!tea_util_1.default.isUnset(request.thresholdCount)) {
|
|
8556
|
+
query["ThresholdCount"] = request.thresholdCount;
|
|
8557
|
+
}
|
|
8558
|
+
if (!tea_util_1.default.isUnset(request.trafficPercentage)) {
|
|
8559
|
+
query["TrafficPercentage"] = request.trafficPercentage;
|
|
8560
|
+
}
|
|
7603
8561
|
let req = new $OpenApi.OpenApiRequest({
|
|
7604
8562
|
query: openapi_util_1.default.query(query),
|
|
7605
|
-
body: tea_util_1.default.toMap(request),
|
|
7606
8563
|
});
|
|
7607
8564
|
let params = new $OpenApi.Params({
|
|
7608
8565
|
action: "CreateEndpointGroup",
|
|
@@ -7612,7 +8569,7 @@ class Client extends openapi_client_1.default {
|
|
|
7612
8569
|
method: "POST",
|
|
7613
8570
|
authType: "AK",
|
|
7614
8571
|
style: "RPC",
|
|
7615
|
-
reqBodyType: "
|
|
8572
|
+
reqBodyType: "formData",
|
|
7616
8573
|
bodyType: "json",
|
|
7617
8574
|
});
|
|
7618
8575
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateEndpointGroupResponse({}));
|
|
@@ -7624,15 +8581,26 @@ class Client extends openapi_client_1.default {
|
|
|
7624
8581
|
async createEndpointGroupsWithOptions(request, runtime) {
|
|
7625
8582
|
tea_util_1.default.validateModel(request);
|
|
7626
8583
|
let query = {};
|
|
7627
|
-
|
|
7628
|
-
|
|
7629
|
-
|
|
7630
|
-
|
|
7631
|
-
|
|
7632
|
-
|
|
8584
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8585
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8586
|
+
}
|
|
8587
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8588
|
+
query["ClientToken"] = request.clientToken;
|
|
8589
|
+
}
|
|
8590
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
8591
|
+
query["DryRun"] = request.dryRun;
|
|
8592
|
+
}
|
|
8593
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupConfigurations)) {
|
|
8594
|
+
query["EndpointGroupConfigurations"] = request.endpointGroupConfigurations;
|
|
8595
|
+
}
|
|
8596
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
8597
|
+
query["ListenerId"] = request.listenerId;
|
|
8598
|
+
}
|
|
8599
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8600
|
+
query["RegionId"] = request.regionId;
|
|
8601
|
+
}
|
|
7633
8602
|
let req = new $OpenApi.OpenApiRequest({
|
|
7634
8603
|
query: openapi_util_1.default.query(query),
|
|
7635
|
-
body: tea_util_1.default.toMap(request),
|
|
7636
8604
|
});
|
|
7637
8605
|
let params = new $OpenApi.Params({
|
|
7638
8606
|
action: "CreateEndpointGroups",
|
|
@@ -7642,7 +8610,7 @@ class Client extends openapi_client_1.default {
|
|
|
7642
8610
|
method: "POST",
|
|
7643
8611
|
authType: "AK",
|
|
7644
8612
|
style: "RPC",
|
|
7645
|
-
reqBodyType: "
|
|
8613
|
+
reqBodyType: "formData",
|
|
7646
8614
|
bodyType: "json",
|
|
7647
8615
|
});
|
|
7648
8616
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateEndpointGroupsResponse({}));
|
|
@@ -7654,14 +8622,23 @@ class Client extends openapi_client_1.default {
|
|
|
7654
8622
|
async createForwardingRulesWithOptions(request, runtime) {
|
|
7655
8623
|
tea_util_1.default.validateModel(request);
|
|
7656
8624
|
let query = {};
|
|
7657
|
-
|
|
7658
|
-
|
|
7659
|
-
|
|
7660
|
-
|
|
7661
|
-
|
|
8625
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8626
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8627
|
+
}
|
|
8628
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8629
|
+
query["ClientToken"] = request.clientToken;
|
|
8630
|
+
}
|
|
8631
|
+
if (!tea_util_1.default.isUnset(request.forwardingRules)) {
|
|
8632
|
+
query["ForwardingRules"] = request.forwardingRules;
|
|
8633
|
+
}
|
|
8634
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
8635
|
+
query["ListenerId"] = request.listenerId;
|
|
8636
|
+
}
|
|
8637
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8638
|
+
query["RegionId"] = request.regionId;
|
|
8639
|
+
}
|
|
7662
8640
|
let req = new $OpenApi.OpenApiRequest({
|
|
7663
8641
|
query: openapi_util_1.default.query(query),
|
|
7664
|
-
body: tea_util_1.default.toMap(request),
|
|
7665
8642
|
});
|
|
7666
8643
|
let params = new $OpenApi.Params({
|
|
7667
8644
|
action: "CreateForwardingRules",
|
|
@@ -7671,7 +8648,7 @@ class Client extends openapi_client_1.default {
|
|
|
7671
8648
|
method: "POST",
|
|
7672
8649
|
authType: "AK",
|
|
7673
8650
|
style: "RPC",
|
|
7674
|
-
reqBodyType: "
|
|
8651
|
+
reqBodyType: "formData",
|
|
7675
8652
|
bodyType: "json",
|
|
7676
8653
|
});
|
|
7677
8654
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateForwardingRulesResponse({}));
|
|
@@ -7683,13 +8660,20 @@ class Client extends openapi_client_1.default {
|
|
|
7683
8660
|
async createIpSetsWithOptions(request, runtime) {
|
|
7684
8661
|
tea_util_1.default.validateModel(request);
|
|
7685
8662
|
let query = {};
|
|
7686
|
-
|
|
7687
|
-
|
|
7688
|
-
|
|
7689
|
-
|
|
8663
|
+
if (!tea_util_1.default.isUnset(request.accelerateRegion)) {
|
|
8664
|
+
query["AccelerateRegion"] = request.accelerateRegion;
|
|
8665
|
+
}
|
|
8666
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8667
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8668
|
+
}
|
|
8669
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8670
|
+
query["ClientToken"] = request.clientToken;
|
|
8671
|
+
}
|
|
8672
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8673
|
+
query["RegionId"] = request.regionId;
|
|
8674
|
+
}
|
|
7690
8675
|
let req = new $OpenApi.OpenApiRequest({
|
|
7691
8676
|
query: openapi_util_1.default.query(query),
|
|
7692
|
-
body: tea_util_1.default.toMap(request),
|
|
7693
8677
|
});
|
|
7694
8678
|
let params = new $OpenApi.Params({
|
|
7695
8679
|
action: "CreateIpSets",
|
|
@@ -7699,7 +8683,7 @@ class Client extends openapi_client_1.default {
|
|
|
7699
8683
|
method: "POST",
|
|
7700
8684
|
authType: "AK",
|
|
7701
8685
|
style: "RPC",
|
|
7702
|
-
reqBodyType: "
|
|
8686
|
+
reqBodyType: "formData",
|
|
7703
8687
|
bodyType: "json",
|
|
7704
8688
|
});
|
|
7705
8689
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateIpSetsResponse({}));
|
|
@@ -7711,21 +8695,44 @@ class Client extends openapi_client_1.default {
|
|
|
7711
8695
|
async createListenerWithOptions(request, runtime) {
|
|
7712
8696
|
tea_util_1.default.validateModel(request);
|
|
7713
8697
|
let query = {};
|
|
7714
|
-
|
|
7715
|
-
|
|
7716
|
-
|
|
7717
|
-
|
|
7718
|
-
|
|
7719
|
-
|
|
7720
|
-
|
|
7721
|
-
|
|
7722
|
-
|
|
7723
|
-
|
|
7724
|
-
|
|
7725
|
-
|
|
8698
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8699
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8700
|
+
}
|
|
8701
|
+
if (!tea_util_1.default.isUnset(request.certificates)) {
|
|
8702
|
+
query["Certificates"] = request.certificates;
|
|
8703
|
+
}
|
|
8704
|
+
if (!tea_util_1.default.isUnset(request.clientAffinity)) {
|
|
8705
|
+
query["ClientAffinity"] = request.clientAffinity;
|
|
8706
|
+
}
|
|
8707
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8708
|
+
query["ClientToken"] = request.clientToken;
|
|
8709
|
+
}
|
|
8710
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
8711
|
+
query["Description"] = request.description;
|
|
8712
|
+
}
|
|
8713
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
8714
|
+
query["Name"] = request.name;
|
|
8715
|
+
}
|
|
8716
|
+
if (!tea_util_1.default.isUnset(request.portRanges)) {
|
|
8717
|
+
query["PortRanges"] = request.portRanges;
|
|
8718
|
+
}
|
|
8719
|
+
if (!tea_util_1.default.isUnset(request.protocol)) {
|
|
8720
|
+
query["Protocol"] = request.protocol;
|
|
8721
|
+
}
|
|
8722
|
+
if (!tea_util_1.default.isUnset(request.proxyProtocol)) {
|
|
8723
|
+
query["ProxyProtocol"] = request.proxyProtocol;
|
|
8724
|
+
}
|
|
8725
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8726
|
+
query["RegionId"] = request.regionId;
|
|
8727
|
+
}
|
|
8728
|
+
if (!tea_util_1.default.isUnset(request.securityPolicyId)) {
|
|
8729
|
+
query["SecurityPolicyId"] = request.securityPolicyId;
|
|
8730
|
+
}
|
|
8731
|
+
if (!tea_util_1.default.isUnset($tea.toMap(request.XForwardedForConfig))) {
|
|
8732
|
+
query["XForwardedForConfig"] = request.XForwardedForConfig;
|
|
8733
|
+
}
|
|
7726
8734
|
let req = new $OpenApi.OpenApiRequest({
|
|
7727
8735
|
query: openapi_util_1.default.query(query),
|
|
7728
|
-
body: tea_util_1.default.toMap(request),
|
|
7729
8736
|
});
|
|
7730
8737
|
let params = new $OpenApi.Params({
|
|
7731
8738
|
action: "CreateListener",
|
|
@@ -7735,7 +8742,7 @@ class Client extends openapi_client_1.default {
|
|
|
7735
8742
|
method: "POST",
|
|
7736
8743
|
authType: "AK",
|
|
7737
8744
|
style: "RPC",
|
|
7738
|
-
reqBodyType: "
|
|
8745
|
+
reqBodyType: "formData",
|
|
7739
8746
|
bodyType: "json",
|
|
7740
8747
|
});
|
|
7741
8748
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateListenerResponse({}));
|
|
@@ -7747,14 +8754,23 @@ class Client extends openapi_client_1.default {
|
|
|
7747
8754
|
async createSpareIpsWithOptions(request, runtime) {
|
|
7748
8755
|
tea_util_1.default.validateModel(request);
|
|
7749
8756
|
let query = {};
|
|
7750
|
-
|
|
7751
|
-
|
|
7752
|
-
|
|
7753
|
-
|
|
7754
|
-
|
|
8757
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8758
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8759
|
+
}
|
|
8760
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8761
|
+
query["ClientToken"] = request.clientToken;
|
|
8762
|
+
}
|
|
8763
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
8764
|
+
query["DryRun"] = request.dryRun;
|
|
8765
|
+
}
|
|
8766
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8767
|
+
query["RegionId"] = request.regionId;
|
|
8768
|
+
}
|
|
8769
|
+
if (!tea_util_1.default.isUnset(request.spareIps)) {
|
|
8770
|
+
query["SpareIps"] = request.spareIps;
|
|
8771
|
+
}
|
|
7755
8772
|
let req = new $OpenApi.OpenApiRequest({
|
|
7756
8773
|
query: openapi_util_1.default.query(query),
|
|
7757
|
-
body: tea_util_1.default.toMap(request),
|
|
7758
8774
|
});
|
|
7759
8775
|
let params = new $OpenApi.Params({
|
|
7760
8776
|
action: "CreateSpareIps",
|
|
@@ -7764,7 +8780,7 @@ class Client extends openapi_client_1.default {
|
|
|
7764
8780
|
method: "POST",
|
|
7765
8781
|
authType: "AK",
|
|
7766
8782
|
style: "RPC",
|
|
7767
|
-
reqBodyType: "
|
|
8783
|
+
reqBodyType: "formData",
|
|
7768
8784
|
bodyType: "json",
|
|
7769
8785
|
});
|
|
7770
8786
|
return $tea.cast(await this.callApi(params, req, runtime), new CreateSpareIpsResponse({}));
|
|
@@ -7776,11 +8792,14 @@ class Client extends openapi_client_1.default {
|
|
|
7776
8792
|
async deleteAcceleratorWithOptions(request, runtime) {
|
|
7777
8793
|
tea_util_1.default.validateModel(request);
|
|
7778
8794
|
let query = {};
|
|
7779
|
-
|
|
7780
|
-
|
|
8795
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8796
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8797
|
+
}
|
|
8798
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8799
|
+
query["RegionId"] = request.regionId;
|
|
8800
|
+
}
|
|
7781
8801
|
let req = new $OpenApi.OpenApiRequest({
|
|
7782
8802
|
query: openapi_util_1.default.query(query),
|
|
7783
|
-
body: tea_util_1.default.toMap(request),
|
|
7784
8803
|
});
|
|
7785
8804
|
let params = new $OpenApi.Params({
|
|
7786
8805
|
action: "DeleteAccelerator",
|
|
@@ -7790,7 +8809,7 @@ class Client extends openapi_client_1.default {
|
|
|
7790
8809
|
method: "POST",
|
|
7791
8810
|
authType: "AK",
|
|
7792
8811
|
style: "RPC",
|
|
7793
|
-
reqBodyType: "
|
|
8812
|
+
reqBodyType: "formData",
|
|
7794
8813
|
bodyType: "json",
|
|
7795
8814
|
});
|
|
7796
8815
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteAcceleratorResponse({}));
|
|
@@ -7802,13 +8821,20 @@ class Client extends openapi_client_1.default {
|
|
|
7802
8821
|
async deleteAclWithOptions(request, runtime) {
|
|
7803
8822
|
tea_util_1.default.validateModel(request);
|
|
7804
8823
|
let query = {};
|
|
7805
|
-
|
|
7806
|
-
|
|
7807
|
-
|
|
7808
|
-
|
|
8824
|
+
if (!tea_util_1.default.isUnset(request.aclId)) {
|
|
8825
|
+
query["AclId"] = request.aclId;
|
|
8826
|
+
}
|
|
8827
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8828
|
+
query["ClientToken"] = request.clientToken;
|
|
8829
|
+
}
|
|
8830
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
8831
|
+
query["DryRun"] = request.dryRun;
|
|
8832
|
+
}
|
|
8833
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8834
|
+
query["RegionId"] = request.regionId;
|
|
8835
|
+
}
|
|
7809
8836
|
let req = new $OpenApi.OpenApiRequest({
|
|
7810
8837
|
query: openapi_util_1.default.query(query),
|
|
7811
|
-
body: tea_util_1.default.toMap(request),
|
|
7812
8838
|
});
|
|
7813
8839
|
let params = new $OpenApi.Params({
|
|
7814
8840
|
action: "DeleteAcl",
|
|
@@ -7818,7 +8844,7 @@ class Client extends openapi_client_1.default {
|
|
|
7818
8844
|
method: "POST",
|
|
7819
8845
|
authType: "AK",
|
|
7820
8846
|
style: "RPC",
|
|
7821
|
-
reqBodyType: "
|
|
8847
|
+
reqBodyType: "formData",
|
|
7822
8848
|
bodyType: "json",
|
|
7823
8849
|
});
|
|
7824
8850
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteAclResponse({}));
|
|
@@ -7827,15 +8853,52 @@ class Client extends openapi_client_1.default {
|
|
|
7827
8853
|
let runtime = new $Util.RuntimeOptions({});
|
|
7828
8854
|
return await this.deleteAclWithOptions(request, runtime);
|
|
7829
8855
|
}
|
|
8856
|
+
async deleteApplicationMonitorWithOptions(request, runtime) {
|
|
8857
|
+
tea_util_1.default.validateModel(request);
|
|
8858
|
+
let query = {};
|
|
8859
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8860
|
+
query["ClientToken"] = request.clientToken;
|
|
8861
|
+
}
|
|
8862
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8863
|
+
query["RegionId"] = request.regionId;
|
|
8864
|
+
}
|
|
8865
|
+
if (!tea_util_1.default.isUnset(request.taskId)) {
|
|
8866
|
+
query["TaskId"] = request.taskId;
|
|
8867
|
+
}
|
|
8868
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
8869
|
+
query: openapi_util_1.default.query(query),
|
|
8870
|
+
});
|
|
8871
|
+
let params = new $OpenApi.Params({
|
|
8872
|
+
action: "DeleteApplicationMonitor",
|
|
8873
|
+
version: "2019-11-20",
|
|
8874
|
+
protocol: "HTTPS",
|
|
8875
|
+
pathname: "/",
|
|
8876
|
+
method: "POST",
|
|
8877
|
+
authType: "AK",
|
|
8878
|
+
style: "RPC",
|
|
8879
|
+
reqBodyType: "formData",
|
|
8880
|
+
bodyType: "json",
|
|
8881
|
+
});
|
|
8882
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DeleteApplicationMonitorResponse({}));
|
|
8883
|
+
}
|
|
8884
|
+
async deleteApplicationMonitor(request) {
|
|
8885
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
8886
|
+
return await this.deleteApplicationMonitorWithOptions(request, runtime);
|
|
8887
|
+
}
|
|
7830
8888
|
async deleteBandwidthPackageWithOptions(request, runtime) {
|
|
7831
8889
|
tea_util_1.default.validateModel(request);
|
|
7832
8890
|
let query = {};
|
|
7833
|
-
|
|
7834
|
-
|
|
7835
|
-
|
|
8891
|
+
if (!tea_util_1.default.isUnset(request.bandwidthPackageId)) {
|
|
8892
|
+
query["BandwidthPackageId"] = request.bandwidthPackageId;
|
|
8893
|
+
}
|
|
8894
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8895
|
+
query["ClientToken"] = request.clientToken;
|
|
8896
|
+
}
|
|
8897
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8898
|
+
query["RegionId"] = request.regionId;
|
|
8899
|
+
}
|
|
7836
8900
|
let req = new $OpenApi.OpenApiRequest({
|
|
7837
8901
|
query: openapi_util_1.default.query(query),
|
|
7838
|
-
body: tea_util_1.default.toMap(request),
|
|
7839
8902
|
});
|
|
7840
8903
|
let params = new $OpenApi.Params({
|
|
7841
8904
|
action: "DeleteBandwidthPackage",
|
|
@@ -7845,7 +8908,7 @@ class Client extends openapi_client_1.default {
|
|
|
7845
8908
|
method: "POST",
|
|
7846
8909
|
authType: "AK",
|
|
7847
8910
|
style: "RPC",
|
|
7848
|
-
reqBodyType: "
|
|
8911
|
+
reqBodyType: "formData",
|
|
7849
8912
|
bodyType: "json",
|
|
7850
8913
|
});
|
|
7851
8914
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteBandwidthPackageResponse({}));
|
|
@@ -7857,11 +8920,14 @@ class Client extends openapi_client_1.default {
|
|
|
7857
8920
|
async deleteBasicAcceleratorWithOptions(request, runtime) {
|
|
7858
8921
|
tea_util_1.default.validateModel(request);
|
|
7859
8922
|
let query = {};
|
|
7860
|
-
|
|
7861
|
-
|
|
8923
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8924
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8925
|
+
}
|
|
8926
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8927
|
+
query["RegionId"] = request.regionId;
|
|
8928
|
+
}
|
|
7862
8929
|
let req = new $OpenApi.OpenApiRequest({
|
|
7863
8930
|
query: openapi_util_1.default.query(query),
|
|
7864
|
-
body: tea_util_1.default.toMap(request),
|
|
7865
8931
|
});
|
|
7866
8932
|
let params = new $OpenApi.Params({
|
|
7867
8933
|
action: "DeleteBasicAccelerator",
|
|
@@ -7871,7 +8937,7 @@ class Client extends openapi_client_1.default {
|
|
|
7871
8937
|
method: "POST",
|
|
7872
8938
|
authType: "AK",
|
|
7873
8939
|
style: "RPC",
|
|
7874
|
-
reqBodyType: "
|
|
8940
|
+
reqBodyType: "formData",
|
|
7875
8941
|
bodyType: "json",
|
|
7876
8942
|
});
|
|
7877
8943
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteBasicAcceleratorResponse({}));
|
|
@@ -7883,11 +8949,14 @@ class Client extends openapi_client_1.default {
|
|
|
7883
8949
|
async deleteBasicEndpointGroupWithOptions(request, runtime) {
|
|
7884
8950
|
tea_util_1.default.validateModel(request);
|
|
7885
8951
|
let query = {};
|
|
7886
|
-
|
|
7887
|
-
|
|
8952
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8953
|
+
query["ClientToken"] = request.clientToken;
|
|
8954
|
+
}
|
|
8955
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupId)) {
|
|
8956
|
+
query["EndpointGroupId"] = request.endpointGroupId;
|
|
8957
|
+
}
|
|
7888
8958
|
let req = new $OpenApi.OpenApiRequest({
|
|
7889
8959
|
query: openapi_util_1.default.query(query),
|
|
7890
|
-
body: tea_util_1.default.toMap(request),
|
|
7891
8960
|
});
|
|
7892
8961
|
let params = new $OpenApi.Params({
|
|
7893
8962
|
action: "DeleteBasicEndpointGroup",
|
|
@@ -7897,7 +8966,7 @@ class Client extends openapi_client_1.default {
|
|
|
7897
8966
|
method: "POST",
|
|
7898
8967
|
authType: "AK",
|
|
7899
8968
|
style: "RPC",
|
|
7900
|
-
reqBodyType: "
|
|
8969
|
+
reqBodyType: "formData",
|
|
7901
8970
|
bodyType: "json",
|
|
7902
8971
|
});
|
|
7903
8972
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteBasicEndpointGroupResponse({}));
|
|
@@ -7909,12 +8978,17 @@ class Client extends openapi_client_1.default {
|
|
|
7909
8978
|
async deleteBasicIpSetWithOptions(request, runtime) {
|
|
7910
8979
|
tea_util_1.default.validateModel(request);
|
|
7911
8980
|
let query = {};
|
|
7912
|
-
|
|
7913
|
-
|
|
7914
|
-
|
|
8981
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8982
|
+
query["ClientToken"] = request.clientToken;
|
|
8983
|
+
}
|
|
8984
|
+
if (!tea_util_1.default.isUnset(request.ipSetId)) {
|
|
8985
|
+
query["IpSetId"] = request.ipSetId;
|
|
8986
|
+
}
|
|
8987
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8988
|
+
query["RegionId"] = request.regionId;
|
|
8989
|
+
}
|
|
7915
8990
|
let req = new $OpenApi.OpenApiRequest({
|
|
7916
8991
|
query: openapi_util_1.default.query(query),
|
|
7917
|
-
body: tea_util_1.default.toMap(request),
|
|
7918
8992
|
});
|
|
7919
8993
|
let params = new $OpenApi.Params({
|
|
7920
8994
|
action: "DeleteBasicIpSet",
|
|
@@ -7924,7 +8998,7 @@ class Client extends openapi_client_1.default {
|
|
|
7924
8998
|
method: "POST",
|
|
7925
8999
|
authType: "AK",
|
|
7926
9000
|
style: "RPC",
|
|
7927
|
-
reqBodyType: "
|
|
9001
|
+
reqBodyType: "formData",
|
|
7928
9002
|
bodyType: "json",
|
|
7929
9003
|
});
|
|
7930
9004
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteBasicIpSetResponse({}));
|
|
@@ -7936,12 +9010,17 @@ class Client extends openapi_client_1.default {
|
|
|
7936
9010
|
async deleteEndpointGroupWithOptions(request, runtime) {
|
|
7937
9011
|
tea_util_1.default.validateModel(request);
|
|
7938
9012
|
let query = {};
|
|
7939
|
-
|
|
7940
|
-
|
|
7941
|
-
|
|
9013
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9014
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9015
|
+
}
|
|
9016
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9017
|
+
query["ClientToken"] = request.clientToken;
|
|
9018
|
+
}
|
|
9019
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupId)) {
|
|
9020
|
+
query["EndpointGroupId"] = request.endpointGroupId;
|
|
9021
|
+
}
|
|
7942
9022
|
let req = new $OpenApi.OpenApiRequest({
|
|
7943
9023
|
query: openapi_util_1.default.query(query),
|
|
7944
|
-
body: tea_util_1.default.toMap(request),
|
|
7945
9024
|
});
|
|
7946
9025
|
let params = new $OpenApi.Params({
|
|
7947
9026
|
action: "DeleteEndpointGroup",
|
|
@@ -7951,7 +9030,7 @@ class Client extends openapi_client_1.default {
|
|
|
7951
9030
|
method: "POST",
|
|
7952
9031
|
authType: "AK",
|
|
7953
9032
|
style: "RPC",
|
|
7954
|
-
reqBodyType: "
|
|
9033
|
+
reqBodyType: "formData",
|
|
7955
9034
|
bodyType: "json",
|
|
7956
9035
|
});
|
|
7957
9036
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteEndpointGroupResponse({}));
|
|
@@ -7963,13 +9042,20 @@ class Client extends openapi_client_1.default {
|
|
|
7963
9042
|
async deleteEndpointGroupsWithOptions(request, runtime) {
|
|
7964
9043
|
tea_util_1.default.validateModel(request);
|
|
7965
9044
|
let query = {};
|
|
7966
|
-
|
|
7967
|
-
|
|
7968
|
-
|
|
7969
|
-
|
|
9045
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9046
|
+
query["ClientToken"] = request.clientToken;
|
|
9047
|
+
}
|
|
9048
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
9049
|
+
query["DryRun"] = request.dryRun;
|
|
9050
|
+
}
|
|
9051
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupIds)) {
|
|
9052
|
+
query["EndpointGroupIds"] = request.endpointGroupIds;
|
|
9053
|
+
}
|
|
9054
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9055
|
+
query["RegionId"] = request.regionId;
|
|
9056
|
+
}
|
|
7970
9057
|
let req = new $OpenApi.OpenApiRequest({
|
|
7971
9058
|
query: openapi_util_1.default.query(query),
|
|
7972
|
-
body: tea_util_1.default.toMap(request),
|
|
7973
9059
|
});
|
|
7974
9060
|
let params = new $OpenApi.Params({
|
|
7975
9061
|
action: "DeleteEndpointGroups",
|
|
@@ -7979,7 +9065,7 @@ class Client extends openapi_client_1.default {
|
|
|
7979
9065
|
method: "POST",
|
|
7980
9066
|
authType: "AK",
|
|
7981
9067
|
style: "RPC",
|
|
7982
|
-
reqBodyType: "
|
|
9068
|
+
reqBodyType: "formData",
|
|
7983
9069
|
bodyType: "json",
|
|
7984
9070
|
});
|
|
7985
9071
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteEndpointGroupsResponse({}));
|
|
@@ -7991,14 +9077,23 @@ class Client extends openapi_client_1.default {
|
|
|
7991
9077
|
async deleteForwardingRulesWithOptions(request, runtime) {
|
|
7992
9078
|
tea_util_1.default.validateModel(request);
|
|
7993
9079
|
let query = {};
|
|
7994
|
-
|
|
7995
|
-
|
|
7996
|
-
|
|
7997
|
-
|
|
7998
|
-
|
|
9080
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9081
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9082
|
+
}
|
|
9083
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9084
|
+
query["ClientToken"] = request.clientToken;
|
|
9085
|
+
}
|
|
9086
|
+
if (!tea_util_1.default.isUnset(request.forwardingRuleIds)) {
|
|
9087
|
+
query["ForwardingRuleIds"] = request.forwardingRuleIds;
|
|
9088
|
+
}
|
|
9089
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
9090
|
+
query["ListenerId"] = request.listenerId;
|
|
9091
|
+
}
|
|
9092
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9093
|
+
query["RegionId"] = request.regionId;
|
|
9094
|
+
}
|
|
7999
9095
|
let req = new $OpenApi.OpenApiRequest({
|
|
8000
9096
|
query: openapi_util_1.default.query(query),
|
|
8001
|
-
body: tea_util_1.default.toMap(request),
|
|
8002
9097
|
});
|
|
8003
9098
|
let params = new $OpenApi.Params({
|
|
8004
9099
|
action: "DeleteForwardingRules",
|
|
@@ -8008,7 +9103,7 @@ class Client extends openapi_client_1.default {
|
|
|
8008
9103
|
method: "POST",
|
|
8009
9104
|
authType: "AK",
|
|
8010
9105
|
style: "RPC",
|
|
8011
|
-
reqBodyType: "
|
|
9106
|
+
reqBodyType: "formData",
|
|
8012
9107
|
bodyType: "json",
|
|
8013
9108
|
});
|
|
8014
9109
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteForwardingRulesResponse({}));
|
|
@@ -8020,13 +9115,20 @@ class Client extends openapi_client_1.default {
|
|
|
8020
9115
|
async deleteIpSetWithOptions(request, runtime) {
|
|
8021
9116
|
tea_util_1.default.validateModel(request);
|
|
8022
9117
|
let query = {};
|
|
8023
|
-
|
|
8024
|
-
|
|
8025
|
-
|
|
8026
|
-
|
|
9118
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9119
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9120
|
+
}
|
|
9121
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9122
|
+
query["ClientToken"] = request.clientToken;
|
|
9123
|
+
}
|
|
9124
|
+
if (!tea_util_1.default.isUnset(request.ipSetId)) {
|
|
9125
|
+
query["IpSetId"] = request.ipSetId;
|
|
9126
|
+
}
|
|
9127
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9128
|
+
query["RegionId"] = request.regionId;
|
|
9129
|
+
}
|
|
8027
9130
|
let req = new $OpenApi.OpenApiRequest({
|
|
8028
9131
|
query: openapi_util_1.default.query(query),
|
|
8029
|
-
body: tea_util_1.default.toMap(request),
|
|
8030
9132
|
});
|
|
8031
9133
|
let params = new $OpenApi.Params({
|
|
8032
9134
|
action: "DeleteIpSet",
|
|
@@ -8036,7 +9138,7 @@ class Client extends openapi_client_1.default {
|
|
|
8036
9138
|
method: "POST",
|
|
8037
9139
|
authType: "AK",
|
|
8038
9140
|
style: "RPC",
|
|
8039
|
-
reqBodyType: "
|
|
9141
|
+
reqBodyType: "formData",
|
|
8040
9142
|
bodyType: "json",
|
|
8041
9143
|
});
|
|
8042
9144
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteIpSetResponse({}));
|
|
@@ -8048,11 +9150,14 @@ class Client extends openapi_client_1.default {
|
|
|
8048
9150
|
async deleteIpSetsWithOptions(request, runtime) {
|
|
8049
9151
|
tea_util_1.default.validateModel(request);
|
|
8050
9152
|
let query = {};
|
|
8051
|
-
|
|
8052
|
-
|
|
9153
|
+
if (!tea_util_1.default.isUnset(request.ipSetIds)) {
|
|
9154
|
+
query["IpSetIds"] = request.ipSetIds;
|
|
9155
|
+
}
|
|
9156
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9157
|
+
query["RegionId"] = request.regionId;
|
|
9158
|
+
}
|
|
8053
9159
|
let req = new $OpenApi.OpenApiRequest({
|
|
8054
9160
|
query: openapi_util_1.default.query(query),
|
|
8055
|
-
body: tea_util_1.default.toMap(request),
|
|
8056
9161
|
});
|
|
8057
9162
|
let params = new $OpenApi.Params({
|
|
8058
9163
|
action: "DeleteIpSets",
|
|
@@ -8062,7 +9167,7 @@ class Client extends openapi_client_1.default {
|
|
|
8062
9167
|
method: "POST",
|
|
8063
9168
|
authType: "AK",
|
|
8064
9169
|
style: "RPC",
|
|
8065
|
-
reqBodyType: "
|
|
9170
|
+
reqBodyType: "formData",
|
|
8066
9171
|
bodyType: "json",
|
|
8067
9172
|
});
|
|
8068
9173
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteIpSetsResponse({}));
|
|
@@ -8074,12 +9179,17 @@ class Client extends openapi_client_1.default {
|
|
|
8074
9179
|
async deleteListenerWithOptions(request, runtime) {
|
|
8075
9180
|
tea_util_1.default.validateModel(request);
|
|
8076
9181
|
let query = {};
|
|
8077
|
-
|
|
8078
|
-
|
|
8079
|
-
|
|
9182
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9183
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9184
|
+
}
|
|
9185
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9186
|
+
query["ClientToken"] = request.clientToken;
|
|
9187
|
+
}
|
|
9188
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
9189
|
+
query["ListenerId"] = request.listenerId;
|
|
9190
|
+
}
|
|
8080
9191
|
let req = new $OpenApi.OpenApiRequest({
|
|
8081
9192
|
query: openapi_util_1.default.query(query),
|
|
8082
|
-
body: tea_util_1.default.toMap(request),
|
|
8083
9193
|
});
|
|
8084
9194
|
let params = new $OpenApi.Params({
|
|
8085
9195
|
action: "DeleteListener",
|
|
@@ -8089,7 +9199,7 @@ class Client extends openapi_client_1.default {
|
|
|
8089
9199
|
method: "POST",
|
|
8090
9200
|
authType: "AK",
|
|
8091
9201
|
style: "RPC",
|
|
8092
|
-
reqBodyType: "
|
|
9202
|
+
reqBodyType: "formData",
|
|
8093
9203
|
bodyType: "json",
|
|
8094
9204
|
});
|
|
8095
9205
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteListenerResponse({}));
|
|
@@ -8101,14 +9211,23 @@ class Client extends openapi_client_1.default {
|
|
|
8101
9211
|
async deleteSpareIpsWithOptions(request, runtime) {
|
|
8102
9212
|
tea_util_1.default.validateModel(request);
|
|
8103
9213
|
let query = {};
|
|
8104
|
-
|
|
8105
|
-
|
|
8106
|
-
|
|
8107
|
-
|
|
8108
|
-
|
|
9214
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9215
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9216
|
+
}
|
|
9217
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9218
|
+
query["ClientToken"] = request.clientToken;
|
|
9219
|
+
}
|
|
9220
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
9221
|
+
query["DryRun"] = request.dryRun;
|
|
9222
|
+
}
|
|
9223
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9224
|
+
query["RegionId"] = request.regionId;
|
|
9225
|
+
}
|
|
9226
|
+
if (!tea_util_1.default.isUnset(request.spareIps)) {
|
|
9227
|
+
query["SpareIps"] = request.spareIps;
|
|
9228
|
+
}
|
|
8109
9229
|
let req = new $OpenApi.OpenApiRequest({
|
|
8110
9230
|
query: openapi_util_1.default.query(query),
|
|
8111
|
-
body: tea_util_1.default.toMap(request),
|
|
8112
9231
|
});
|
|
8113
9232
|
let params = new $OpenApi.Params({
|
|
8114
9233
|
action: "DeleteSpareIps",
|
|
@@ -8118,7 +9237,7 @@ class Client extends openapi_client_1.default {
|
|
|
8118
9237
|
method: "POST",
|
|
8119
9238
|
authType: "AK",
|
|
8120
9239
|
style: "RPC",
|
|
8121
|
-
reqBodyType: "
|
|
9240
|
+
reqBodyType: "formData",
|
|
8122
9241
|
bodyType: "json",
|
|
8123
9242
|
});
|
|
8124
9243
|
return $tea.cast(await this.callApi(params, req, runtime), new DeleteSpareIpsResponse({}));
|
|
@@ -8130,11 +9249,14 @@ class Client extends openapi_client_1.default {
|
|
|
8130
9249
|
async describeAcceleratorWithOptions(request, runtime) {
|
|
8131
9250
|
tea_util_1.default.validateModel(request);
|
|
8132
9251
|
let query = {};
|
|
8133
|
-
|
|
8134
|
-
|
|
9252
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9253
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9254
|
+
}
|
|
9255
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9256
|
+
query["RegionId"] = request.regionId;
|
|
9257
|
+
}
|
|
8135
9258
|
let req = new $OpenApi.OpenApiRequest({
|
|
8136
9259
|
query: openapi_util_1.default.query(query),
|
|
8137
|
-
body: tea_util_1.default.toMap(request),
|
|
8138
9260
|
});
|
|
8139
9261
|
let params = new $OpenApi.Params({
|
|
8140
9262
|
action: "DescribeAccelerator",
|
|
@@ -8144,7 +9266,7 @@ class Client extends openapi_client_1.default {
|
|
|
8144
9266
|
method: "POST",
|
|
8145
9267
|
authType: "AK",
|
|
8146
9268
|
style: "RPC",
|
|
8147
|
-
reqBodyType: "
|
|
9269
|
+
reqBodyType: "formData",
|
|
8148
9270
|
bodyType: "json",
|
|
8149
9271
|
});
|
|
8150
9272
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeAcceleratorResponse({}));
|
|
@@ -8156,11 +9278,14 @@ class Client extends openapi_client_1.default {
|
|
|
8156
9278
|
async describeAcceleratorAutoRenewAttributeWithOptions(request, runtime) {
|
|
8157
9279
|
tea_util_1.default.validateModel(request);
|
|
8158
9280
|
let query = {};
|
|
8159
|
-
|
|
8160
|
-
|
|
9281
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9282
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9283
|
+
}
|
|
9284
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9285
|
+
query["RegionId"] = request.regionId;
|
|
9286
|
+
}
|
|
8161
9287
|
let req = new $OpenApi.OpenApiRequest({
|
|
8162
9288
|
query: openapi_util_1.default.query(query),
|
|
8163
|
-
body: tea_util_1.default.toMap(request),
|
|
8164
9289
|
});
|
|
8165
9290
|
let params = new $OpenApi.Params({
|
|
8166
9291
|
action: "DescribeAcceleratorAutoRenewAttribute",
|
|
@@ -8170,7 +9295,7 @@ class Client extends openapi_client_1.default {
|
|
|
8170
9295
|
method: "POST",
|
|
8171
9296
|
authType: "AK",
|
|
8172
9297
|
style: "RPC",
|
|
8173
|
-
reqBodyType: "
|
|
9298
|
+
reqBodyType: "formData",
|
|
8174
9299
|
bodyType: "json",
|
|
8175
9300
|
});
|
|
8176
9301
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeAcceleratorAutoRenewAttributeResponse({}));
|
|
@@ -8179,14 +9304,49 @@ class Client extends openapi_client_1.default {
|
|
|
8179
9304
|
let runtime = new $Util.RuntimeOptions({});
|
|
8180
9305
|
return await this.describeAcceleratorAutoRenewAttributeWithOptions(request, runtime);
|
|
8181
9306
|
}
|
|
9307
|
+
async describeApplicationMonitorWithOptions(request, runtime) {
|
|
9308
|
+
tea_util_1.default.validateModel(request);
|
|
9309
|
+
let query = {};
|
|
9310
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9311
|
+
query["ClientToken"] = request.clientToken;
|
|
9312
|
+
}
|
|
9313
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9314
|
+
query["RegionId"] = request.regionId;
|
|
9315
|
+
}
|
|
9316
|
+
if (!tea_util_1.default.isUnset(request.taskId)) {
|
|
9317
|
+
query["TaskId"] = request.taskId;
|
|
9318
|
+
}
|
|
9319
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
9320
|
+
query: openapi_util_1.default.query(query),
|
|
9321
|
+
});
|
|
9322
|
+
let params = new $OpenApi.Params({
|
|
9323
|
+
action: "DescribeApplicationMonitor",
|
|
9324
|
+
version: "2019-11-20",
|
|
9325
|
+
protocol: "HTTPS",
|
|
9326
|
+
pathname: "/",
|
|
9327
|
+
method: "POST",
|
|
9328
|
+
authType: "AK",
|
|
9329
|
+
style: "RPC",
|
|
9330
|
+
reqBodyType: "formData",
|
|
9331
|
+
bodyType: "json",
|
|
9332
|
+
});
|
|
9333
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DescribeApplicationMonitorResponse({}));
|
|
9334
|
+
}
|
|
9335
|
+
async describeApplicationMonitor(request) {
|
|
9336
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
9337
|
+
return await this.describeApplicationMonitorWithOptions(request, runtime);
|
|
9338
|
+
}
|
|
8182
9339
|
async describeBandwidthPackageWithOptions(request, runtime) {
|
|
8183
9340
|
tea_util_1.default.validateModel(request);
|
|
8184
9341
|
let query = {};
|
|
8185
|
-
|
|
8186
|
-
|
|
9342
|
+
if (!tea_util_1.default.isUnset(request.bandwidthPackageId)) {
|
|
9343
|
+
query["BandwidthPackageId"] = request.bandwidthPackageId;
|
|
9344
|
+
}
|
|
9345
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9346
|
+
query["RegionId"] = request.regionId;
|
|
9347
|
+
}
|
|
8187
9348
|
let req = new $OpenApi.OpenApiRequest({
|
|
8188
9349
|
query: openapi_util_1.default.query(query),
|
|
8189
|
-
body: tea_util_1.default.toMap(request),
|
|
8190
9350
|
});
|
|
8191
9351
|
let params = new $OpenApi.Params({
|
|
8192
9352
|
action: "DescribeBandwidthPackage",
|
|
@@ -8196,7 +9356,7 @@ class Client extends openapi_client_1.default {
|
|
|
8196
9356
|
method: "POST",
|
|
8197
9357
|
authType: "AK",
|
|
8198
9358
|
style: "RPC",
|
|
8199
|
-
reqBodyType: "
|
|
9359
|
+
reqBodyType: "formData",
|
|
8200
9360
|
bodyType: "json",
|
|
8201
9361
|
});
|
|
8202
9362
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeBandwidthPackageResponse({}));
|
|
@@ -8208,11 +9368,14 @@ class Client extends openapi_client_1.default {
|
|
|
8208
9368
|
async describeEndpointGroupWithOptions(request, runtime) {
|
|
8209
9369
|
tea_util_1.default.validateModel(request);
|
|
8210
9370
|
let query = {};
|
|
8211
|
-
|
|
8212
|
-
|
|
9371
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupId)) {
|
|
9372
|
+
query["EndpointGroupId"] = request.endpointGroupId;
|
|
9373
|
+
}
|
|
9374
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9375
|
+
query["RegionId"] = request.regionId;
|
|
9376
|
+
}
|
|
8213
9377
|
let req = new $OpenApi.OpenApiRequest({
|
|
8214
9378
|
query: openapi_util_1.default.query(query),
|
|
8215
|
-
body: tea_util_1.default.toMap(request),
|
|
8216
9379
|
});
|
|
8217
9380
|
let params = new $OpenApi.Params({
|
|
8218
9381
|
action: "DescribeEndpointGroup",
|
|
@@ -8222,7 +9385,7 @@ class Client extends openapi_client_1.default {
|
|
|
8222
9385
|
method: "POST",
|
|
8223
9386
|
authType: "AK",
|
|
8224
9387
|
style: "RPC",
|
|
8225
|
-
reqBodyType: "
|
|
9388
|
+
reqBodyType: "formData",
|
|
8226
9389
|
bodyType: "json",
|
|
8227
9390
|
});
|
|
8228
9391
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeEndpointGroupResponse({}));
|
|
@@ -8234,11 +9397,14 @@ class Client extends openapi_client_1.default {
|
|
|
8234
9397
|
async describeIpSetWithOptions(request, runtime) {
|
|
8235
9398
|
tea_util_1.default.validateModel(request);
|
|
8236
9399
|
let query = {};
|
|
8237
|
-
|
|
8238
|
-
|
|
9400
|
+
if (!tea_util_1.default.isUnset(request.ipSetId)) {
|
|
9401
|
+
query["IpSetId"] = request.ipSetId;
|
|
9402
|
+
}
|
|
9403
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9404
|
+
query["RegionId"] = request.regionId;
|
|
9405
|
+
}
|
|
8239
9406
|
let req = new $OpenApi.OpenApiRequest({
|
|
8240
9407
|
query: openapi_util_1.default.query(query),
|
|
8241
|
-
body: tea_util_1.default.toMap(request),
|
|
8242
9408
|
});
|
|
8243
9409
|
let params = new $OpenApi.Params({
|
|
8244
9410
|
action: "DescribeIpSet",
|
|
@@ -8248,7 +9414,7 @@ class Client extends openapi_client_1.default {
|
|
|
8248
9414
|
method: "POST",
|
|
8249
9415
|
authType: "AK",
|
|
8250
9416
|
style: "RPC",
|
|
8251
|
-
reqBodyType: "
|
|
9417
|
+
reqBodyType: "formData",
|
|
8252
9418
|
bodyType: "json",
|
|
8253
9419
|
});
|
|
8254
9420
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeIpSetResponse({}));
|
|
@@ -8260,11 +9426,14 @@ class Client extends openapi_client_1.default {
|
|
|
8260
9426
|
async describeListenerWithOptions(request, runtime) {
|
|
8261
9427
|
tea_util_1.default.validateModel(request);
|
|
8262
9428
|
let query = {};
|
|
8263
|
-
|
|
8264
|
-
|
|
9429
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
9430
|
+
query["ListenerId"] = request.listenerId;
|
|
9431
|
+
}
|
|
9432
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9433
|
+
query["RegionId"] = request.regionId;
|
|
9434
|
+
}
|
|
8265
9435
|
let req = new $OpenApi.OpenApiRequest({
|
|
8266
9436
|
query: openapi_util_1.default.query(query),
|
|
8267
|
-
body: tea_util_1.default.toMap(request),
|
|
8268
9437
|
});
|
|
8269
9438
|
let params = new $OpenApi.Params({
|
|
8270
9439
|
action: "DescribeListener",
|
|
@@ -8274,7 +9443,7 @@ class Client extends openapi_client_1.default {
|
|
|
8274
9443
|
method: "POST",
|
|
8275
9444
|
authType: "AK",
|
|
8276
9445
|
style: "RPC",
|
|
8277
|
-
reqBodyType: "
|
|
9446
|
+
reqBodyType: "formData",
|
|
8278
9447
|
bodyType: "json",
|
|
8279
9448
|
});
|
|
8280
9449
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeListenerResponse({}));
|
|
@@ -8286,10 +9455,11 @@ class Client extends openapi_client_1.default {
|
|
|
8286
9455
|
async describeRegionsWithOptions(request, runtime) {
|
|
8287
9456
|
tea_util_1.default.validateModel(request);
|
|
8288
9457
|
let query = {};
|
|
8289
|
-
|
|
9458
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9459
|
+
query["RegionId"] = request.regionId;
|
|
9460
|
+
}
|
|
8290
9461
|
let req = new $OpenApi.OpenApiRequest({
|
|
8291
9462
|
query: openapi_util_1.default.query(query),
|
|
8292
|
-
body: tea_util_1.default.toMap(request),
|
|
8293
9463
|
});
|
|
8294
9464
|
let params = new $OpenApi.Params({
|
|
8295
9465
|
action: "DescribeRegions",
|
|
@@ -8299,7 +9469,7 @@ class Client extends openapi_client_1.default {
|
|
|
8299
9469
|
method: "POST",
|
|
8300
9470
|
authType: "AK",
|
|
8301
9471
|
style: "RPC",
|
|
8302
|
-
reqBodyType: "
|
|
9472
|
+
reqBodyType: "formData",
|
|
8303
9473
|
bodyType: "json",
|
|
8304
9474
|
});
|
|
8305
9475
|
return $tea.cast(await this.callApi(params, req, runtime), new DescribeRegionsResponse({}));
|
|
@@ -8311,11 +9481,14 @@ class Client extends openapi_client_1.default {
|
|
|
8311
9481
|
async detachDdosFromAcceleratorWithOptions(request, runtime) {
|
|
8312
9482
|
tea_util_1.default.validateModel(request);
|
|
8313
9483
|
let query = {};
|
|
8314
|
-
|
|
8315
|
-
|
|
9484
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9485
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9486
|
+
}
|
|
9487
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9488
|
+
query["RegionId"] = request.regionId;
|
|
9489
|
+
}
|
|
8316
9490
|
let req = new $OpenApi.OpenApiRequest({
|
|
8317
9491
|
query: openapi_util_1.default.query(query),
|
|
8318
|
-
body: tea_util_1.default.toMap(request),
|
|
8319
9492
|
});
|
|
8320
9493
|
let params = new $OpenApi.Params({
|
|
8321
9494
|
action: "DetachDdosFromAccelerator",
|
|
@@ -8325,7 +9498,7 @@ class Client extends openapi_client_1.default {
|
|
|
8325
9498
|
method: "POST",
|
|
8326
9499
|
authType: "AK",
|
|
8327
9500
|
style: "RPC",
|
|
8328
|
-
reqBodyType: "
|
|
9501
|
+
reqBodyType: "formData",
|
|
8329
9502
|
bodyType: "json",
|
|
8330
9503
|
});
|
|
8331
9504
|
return $tea.cast(await this.callApi(params, req, runtime), new DetachDdosFromAcceleratorResponse({}));
|
|
@@ -8337,14 +9510,23 @@ class Client extends openapi_client_1.default {
|
|
|
8337
9510
|
async detachLogStoreFromEndpointGroupWithOptions(request, runtime) {
|
|
8338
9511
|
tea_util_1.default.validateModel(request);
|
|
8339
9512
|
let query = {};
|
|
8340
|
-
|
|
8341
|
-
|
|
8342
|
-
|
|
8343
|
-
|
|
8344
|
-
|
|
9513
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9514
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9515
|
+
}
|
|
9516
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9517
|
+
query["ClientToken"] = request.clientToken;
|
|
9518
|
+
}
|
|
9519
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupIds)) {
|
|
9520
|
+
query["EndpointGroupIds"] = request.endpointGroupIds;
|
|
9521
|
+
}
|
|
9522
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
9523
|
+
query["ListenerId"] = request.listenerId;
|
|
9524
|
+
}
|
|
9525
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9526
|
+
query["RegionId"] = request.regionId;
|
|
9527
|
+
}
|
|
8345
9528
|
let req = new $OpenApi.OpenApiRequest({
|
|
8346
9529
|
query: openapi_util_1.default.query(query),
|
|
8347
|
-
body: tea_util_1.default.toMap(request),
|
|
8348
9530
|
});
|
|
8349
9531
|
let params = new $OpenApi.Params({
|
|
8350
9532
|
action: "DetachLogStoreFromEndpointGroup",
|
|
@@ -8354,7 +9536,7 @@ class Client extends openapi_client_1.default {
|
|
|
8354
9536
|
method: "POST",
|
|
8355
9537
|
authType: "AK",
|
|
8356
9538
|
style: "RPC",
|
|
8357
|
-
reqBodyType: "
|
|
9539
|
+
reqBodyType: "formData",
|
|
8358
9540
|
bodyType: "json",
|
|
8359
9541
|
});
|
|
8360
9542
|
return $tea.cast(await this.callApi(params, req, runtime), new DetachLogStoreFromEndpointGroupResponse({}));
|
|
@@ -8363,17 +9545,90 @@ class Client extends openapi_client_1.default {
|
|
|
8363
9545
|
let runtime = new $Util.RuntimeOptions({});
|
|
8364
9546
|
return await this.detachLogStoreFromEndpointGroupWithOptions(request, runtime);
|
|
8365
9547
|
}
|
|
9548
|
+
async detectApplicationMonitorWithOptions(request, runtime) {
|
|
9549
|
+
tea_util_1.default.validateModel(request);
|
|
9550
|
+
let query = {};
|
|
9551
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9552
|
+
query["ClientToken"] = request.clientToken;
|
|
9553
|
+
}
|
|
9554
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9555
|
+
query["RegionId"] = request.regionId;
|
|
9556
|
+
}
|
|
9557
|
+
if (!tea_util_1.default.isUnset(request.taskId)) {
|
|
9558
|
+
query["TaskId"] = request.taskId;
|
|
9559
|
+
}
|
|
9560
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
9561
|
+
query: openapi_util_1.default.query(query),
|
|
9562
|
+
});
|
|
9563
|
+
let params = new $OpenApi.Params({
|
|
9564
|
+
action: "DetectApplicationMonitor",
|
|
9565
|
+
version: "2019-11-20",
|
|
9566
|
+
protocol: "HTTPS",
|
|
9567
|
+
pathname: "/",
|
|
9568
|
+
method: "POST",
|
|
9569
|
+
authType: "AK",
|
|
9570
|
+
style: "RPC",
|
|
9571
|
+
reqBodyType: "formData",
|
|
9572
|
+
bodyType: "json",
|
|
9573
|
+
});
|
|
9574
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DetectApplicationMonitorResponse({}));
|
|
9575
|
+
}
|
|
9576
|
+
async detectApplicationMonitor(request) {
|
|
9577
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
9578
|
+
return await this.detectApplicationMonitorWithOptions(request, runtime);
|
|
9579
|
+
}
|
|
9580
|
+
async disableApplicationMonitorWithOptions(request, runtime) {
|
|
9581
|
+
tea_util_1.default.validateModel(request);
|
|
9582
|
+
let query = {};
|
|
9583
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9584
|
+
query["ClientToken"] = request.clientToken;
|
|
9585
|
+
}
|
|
9586
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9587
|
+
query["RegionId"] = request.regionId;
|
|
9588
|
+
}
|
|
9589
|
+
if (!tea_util_1.default.isUnset(request.taskId)) {
|
|
9590
|
+
query["TaskId"] = request.taskId;
|
|
9591
|
+
}
|
|
9592
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
9593
|
+
query: openapi_util_1.default.query(query),
|
|
9594
|
+
});
|
|
9595
|
+
let params = new $OpenApi.Params({
|
|
9596
|
+
action: "DisableApplicationMonitor",
|
|
9597
|
+
version: "2019-11-20",
|
|
9598
|
+
protocol: "HTTPS",
|
|
9599
|
+
pathname: "/",
|
|
9600
|
+
method: "POST",
|
|
9601
|
+
authType: "AK",
|
|
9602
|
+
style: "RPC",
|
|
9603
|
+
reqBodyType: "formData",
|
|
9604
|
+
bodyType: "json",
|
|
9605
|
+
});
|
|
9606
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DisableApplicationMonitorResponse({}));
|
|
9607
|
+
}
|
|
9608
|
+
async disableApplicationMonitor(request) {
|
|
9609
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
9610
|
+
return await this.disableApplicationMonitorWithOptions(request, runtime);
|
|
9611
|
+
}
|
|
8366
9612
|
async dissociateAclsFromListenerWithOptions(request, runtime) {
|
|
8367
9613
|
tea_util_1.default.validateModel(request);
|
|
8368
9614
|
let query = {};
|
|
8369
|
-
|
|
8370
|
-
|
|
8371
|
-
|
|
8372
|
-
|
|
8373
|
-
|
|
9615
|
+
if (!tea_util_1.default.isUnset(request.aclIds)) {
|
|
9616
|
+
query["AclIds"] = request.aclIds;
|
|
9617
|
+
}
|
|
9618
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9619
|
+
query["ClientToken"] = request.clientToken;
|
|
9620
|
+
}
|
|
9621
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
9622
|
+
query["DryRun"] = request.dryRun;
|
|
9623
|
+
}
|
|
9624
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
9625
|
+
query["ListenerId"] = request.listenerId;
|
|
9626
|
+
}
|
|
9627
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9628
|
+
query["RegionId"] = request.regionId;
|
|
9629
|
+
}
|
|
8374
9630
|
let req = new $OpenApi.OpenApiRequest({
|
|
8375
9631
|
query: openapi_util_1.default.query(query),
|
|
8376
|
-
body: tea_util_1.default.toMap(request),
|
|
8377
9632
|
});
|
|
8378
9633
|
let params = new $OpenApi.Params({
|
|
8379
9634
|
action: "DissociateAclsFromListener",
|
|
@@ -8383,7 +9638,7 @@ class Client extends openapi_client_1.default {
|
|
|
8383
9638
|
method: "POST",
|
|
8384
9639
|
authType: "AK",
|
|
8385
9640
|
style: "RPC",
|
|
8386
|
-
reqBodyType: "
|
|
9641
|
+
reqBodyType: "formData",
|
|
8387
9642
|
bodyType: "json",
|
|
8388
9643
|
});
|
|
8389
9644
|
return $tea.cast(await this.callApi(params, req, runtime), new DissociateAclsFromListenerResponse({}));
|
|
@@ -8395,14 +9650,23 @@ class Client extends openapi_client_1.default {
|
|
|
8395
9650
|
async dissociateAdditionalCertificatesFromListenerWithOptions(request, runtime) {
|
|
8396
9651
|
tea_util_1.default.validateModel(request);
|
|
8397
9652
|
let query = {};
|
|
8398
|
-
|
|
8399
|
-
|
|
8400
|
-
|
|
8401
|
-
|
|
8402
|
-
|
|
9653
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9654
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9655
|
+
}
|
|
9656
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9657
|
+
query["ClientToken"] = request.clientToken;
|
|
9658
|
+
}
|
|
9659
|
+
if (!tea_util_1.default.isUnset(request.domains)) {
|
|
9660
|
+
query["Domains"] = request.domains;
|
|
9661
|
+
}
|
|
9662
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
9663
|
+
query["ListenerId"] = request.listenerId;
|
|
9664
|
+
}
|
|
9665
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9666
|
+
query["RegionId"] = request.regionId;
|
|
9667
|
+
}
|
|
8403
9668
|
let req = new $OpenApi.OpenApiRequest({
|
|
8404
9669
|
query: openapi_util_1.default.query(query),
|
|
8405
|
-
body: tea_util_1.default.toMap(request),
|
|
8406
9670
|
});
|
|
8407
9671
|
let params = new $OpenApi.Params({
|
|
8408
9672
|
action: "DissociateAdditionalCertificatesFromListener",
|
|
@@ -8412,7 +9676,7 @@ class Client extends openapi_client_1.default {
|
|
|
8412
9676
|
method: "POST",
|
|
8413
9677
|
authType: "AK",
|
|
8414
9678
|
style: "RPC",
|
|
8415
|
-
reqBodyType: "
|
|
9679
|
+
reqBodyType: "formData",
|
|
8416
9680
|
bodyType: "json",
|
|
8417
9681
|
});
|
|
8418
9682
|
return $tea.cast(await this.callApi(params, req, runtime), new DissociateAdditionalCertificatesFromListenerResponse({}));
|
|
@@ -8421,14 +9685,49 @@ class Client extends openapi_client_1.default {
|
|
|
8421
9685
|
let runtime = new $Util.RuntimeOptions({});
|
|
8422
9686
|
return await this.dissociateAdditionalCertificatesFromListenerWithOptions(request, runtime);
|
|
8423
9687
|
}
|
|
9688
|
+
async enableApplicationMonitorWithOptions(request, runtime) {
|
|
9689
|
+
tea_util_1.default.validateModel(request);
|
|
9690
|
+
let query = {};
|
|
9691
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9692
|
+
query["ClientToken"] = request.clientToken;
|
|
9693
|
+
}
|
|
9694
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9695
|
+
query["RegionId"] = request.regionId;
|
|
9696
|
+
}
|
|
9697
|
+
if (!tea_util_1.default.isUnset(request.taskId)) {
|
|
9698
|
+
query["TaskId"] = request.taskId;
|
|
9699
|
+
}
|
|
9700
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
9701
|
+
query: openapi_util_1.default.query(query),
|
|
9702
|
+
});
|
|
9703
|
+
let params = new $OpenApi.Params({
|
|
9704
|
+
action: "EnableApplicationMonitor",
|
|
9705
|
+
version: "2019-11-20",
|
|
9706
|
+
protocol: "HTTPS",
|
|
9707
|
+
pathname: "/",
|
|
9708
|
+
method: "POST",
|
|
9709
|
+
authType: "AK",
|
|
9710
|
+
style: "RPC",
|
|
9711
|
+
reqBodyType: "formData",
|
|
9712
|
+
bodyType: "json",
|
|
9713
|
+
});
|
|
9714
|
+
return $tea.cast(await this.callApi(params, req, runtime), new EnableApplicationMonitorResponse({}));
|
|
9715
|
+
}
|
|
9716
|
+
async enableApplicationMonitor(request) {
|
|
9717
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
9718
|
+
return await this.enableApplicationMonitorWithOptions(request, runtime);
|
|
9719
|
+
}
|
|
8424
9720
|
async getAclWithOptions(request, runtime) {
|
|
8425
9721
|
tea_util_1.default.validateModel(request);
|
|
8426
9722
|
let query = {};
|
|
8427
|
-
|
|
8428
|
-
|
|
9723
|
+
if (!tea_util_1.default.isUnset(request.aclId)) {
|
|
9724
|
+
query["AclId"] = request.aclId;
|
|
9725
|
+
}
|
|
9726
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9727
|
+
query["RegionId"] = request.regionId;
|
|
9728
|
+
}
|
|
8429
9729
|
let req = new $OpenApi.OpenApiRequest({
|
|
8430
9730
|
query: openapi_util_1.default.query(query),
|
|
8431
|
-
body: tea_util_1.default.toMap(request),
|
|
8432
9731
|
});
|
|
8433
9732
|
let params = new $OpenApi.Params({
|
|
8434
9733
|
action: "GetAcl",
|
|
@@ -8438,7 +9737,7 @@ class Client extends openapi_client_1.default {
|
|
|
8438
9737
|
method: "POST",
|
|
8439
9738
|
authType: "AK",
|
|
8440
9739
|
style: "RPC",
|
|
8441
|
-
reqBodyType: "
|
|
9740
|
+
reqBodyType: "formData",
|
|
8442
9741
|
bodyType: "json",
|
|
8443
9742
|
});
|
|
8444
9743
|
return $tea.cast(await this.callApi(params, req, runtime), new GetAclResponse({}));
|
|
@@ -8450,11 +9749,14 @@ class Client extends openapi_client_1.default {
|
|
|
8450
9749
|
async getBasicAcceleratorWithOptions(request, runtime) {
|
|
8451
9750
|
tea_util_1.default.validateModel(request);
|
|
8452
9751
|
let query = {};
|
|
8453
|
-
|
|
8454
|
-
|
|
9752
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9753
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9754
|
+
}
|
|
9755
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9756
|
+
query["RegionId"] = request.regionId;
|
|
9757
|
+
}
|
|
8455
9758
|
let req = new $OpenApi.OpenApiRequest({
|
|
8456
9759
|
query: openapi_util_1.default.query(query),
|
|
8457
|
-
body: tea_util_1.default.toMap(request),
|
|
8458
9760
|
});
|
|
8459
9761
|
let params = new $OpenApi.Params({
|
|
8460
9762
|
action: "GetBasicAccelerator",
|
|
@@ -8464,7 +9766,7 @@ class Client extends openapi_client_1.default {
|
|
|
8464
9766
|
method: "POST",
|
|
8465
9767
|
authType: "AK",
|
|
8466
9768
|
style: "RPC",
|
|
8467
|
-
reqBodyType: "
|
|
9769
|
+
reqBodyType: "formData",
|
|
8468
9770
|
bodyType: "json",
|
|
8469
9771
|
});
|
|
8470
9772
|
return $tea.cast(await this.callApi(params, req, runtime), new GetBasicAcceleratorResponse({}));
|
|
@@ -8476,12 +9778,17 @@ class Client extends openapi_client_1.default {
|
|
|
8476
9778
|
async getBasicEndpointGroupWithOptions(request, runtime) {
|
|
8477
9779
|
tea_util_1.default.validateModel(request);
|
|
8478
9780
|
let query = {};
|
|
8479
|
-
|
|
8480
|
-
|
|
8481
|
-
|
|
9781
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9782
|
+
query["ClientToken"] = request.clientToken;
|
|
9783
|
+
}
|
|
9784
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupId)) {
|
|
9785
|
+
query["EndpointGroupId"] = request.endpointGroupId;
|
|
9786
|
+
}
|
|
9787
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9788
|
+
query["RegionId"] = request.regionId;
|
|
9789
|
+
}
|
|
8482
9790
|
let req = new $OpenApi.OpenApiRequest({
|
|
8483
9791
|
query: openapi_util_1.default.query(query),
|
|
8484
|
-
body: tea_util_1.default.toMap(request),
|
|
8485
9792
|
});
|
|
8486
9793
|
let params = new $OpenApi.Params({
|
|
8487
9794
|
action: "GetBasicEndpointGroup",
|
|
@@ -8491,7 +9798,7 @@ class Client extends openapi_client_1.default {
|
|
|
8491
9798
|
method: "POST",
|
|
8492
9799
|
authType: "AK",
|
|
8493
9800
|
style: "RPC",
|
|
8494
|
-
reqBodyType: "
|
|
9801
|
+
reqBodyType: "formData",
|
|
8495
9802
|
bodyType: "json",
|
|
8496
9803
|
});
|
|
8497
9804
|
return $tea.cast(await this.callApi(params, req, runtime), new GetBasicEndpointGroupResponse({}));
|
|
@@ -8503,12 +9810,17 @@ class Client extends openapi_client_1.default {
|
|
|
8503
9810
|
async getBasicIpSetWithOptions(request, runtime) {
|
|
8504
9811
|
tea_util_1.default.validateModel(request);
|
|
8505
9812
|
let query = {};
|
|
8506
|
-
|
|
8507
|
-
|
|
8508
|
-
|
|
9813
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9814
|
+
query["ClientToken"] = request.clientToken;
|
|
9815
|
+
}
|
|
9816
|
+
if (!tea_util_1.default.isUnset(request.ipSetId)) {
|
|
9817
|
+
query["IpSetId"] = request.ipSetId;
|
|
9818
|
+
}
|
|
9819
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9820
|
+
query["RegionId"] = request.regionId;
|
|
9821
|
+
}
|
|
8509
9822
|
let req = new $OpenApi.OpenApiRequest({
|
|
8510
9823
|
query: openapi_util_1.default.query(query),
|
|
8511
|
-
body: tea_util_1.default.toMap(request),
|
|
8512
9824
|
});
|
|
8513
9825
|
let params = new $OpenApi.Params({
|
|
8514
9826
|
action: "GetBasicIpSet",
|
|
@@ -8518,7 +9830,7 @@ class Client extends openapi_client_1.default {
|
|
|
8518
9830
|
method: "POST",
|
|
8519
9831
|
authType: "AK",
|
|
8520
9832
|
style: "RPC",
|
|
8521
|
-
reqBodyType: "
|
|
9833
|
+
reqBodyType: "formData",
|
|
8522
9834
|
bodyType: "json",
|
|
8523
9835
|
});
|
|
8524
9836
|
return $tea.cast(await this.callApi(params, req, runtime), new GetBasicIpSetResponse({}));
|
|
@@ -8530,14 +9842,23 @@ class Client extends openapi_client_1.default {
|
|
|
8530
9842
|
async getHealthStatusWithOptions(request, runtime) {
|
|
8531
9843
|
tea_util_1.default.validateModel(request);
|
|
8532
9844
|
let query = {};
|
|
8533
|
-
|
|
8534
|
-
|
|
8535
|
-
|
|
8536
|
-
|
|
8537
|
-
|
|
9845
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9846
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9847
|
+
}
|
|
9848
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9849
|
+
query["ClientToken"] = request.clientToken;
|
|
9850
|
+
}
|
|
9851
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
9852
|
+
query["DryRun"] = request.dryRun;
|
|
9853
|
+
}
|
|
9854
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
9855
|
+
query["ListenerId"] = request.listenerId;
|
|
9856
|
+
}
|
|
9857
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9858
|
+
query["RegionId"] = request.regionId;
|
|
9859
|
+
}
|
|
8538
9860
|
let req = new $OpenApi.OpenApiRequest({
|
|
8539
9861
|
query: openapi_util_1.default.query(query),
|
|
8540
|
-
body: tea_util_1.default.toMap(request),
|
|
8541
9862
|
});
|
|
8542
9863
|
let params = new $OpenApi.Params({
|
|
8543
9864
|
action: "GetHealthStatus",
|
|
@@ -8547,7 +9868,7 @@ class Client extends openapi_client_1.default {
|
|
|
8547
9868
|
method: "POST",
|
|
8548
9869
|
authType: "AK",
|
|
8549
9870
|
style: "RPC",
|
|
8550
|
-
reqBodyType: "
|
|
9871
|
+
reqBodyType: "formData",
|
|
8551
9872
|
bodyType: "json",
|
|
8552
9873
|
});
|
|
8553
9874
|
return $tea.cast(await this.callApi(params, req, runtime), new GetHealthStatusResponse({}));
|
|
@@ -8559,14 +9880,23 @@ class Client extends openapi_client_1.default {
|
|
|
8559
9880
|
async getSpareIpWithOptions(request, runtime) {
|
|
8560
9881
|
tea_util_1.default.validateModel(request);
|
|
8561
9882
|
let query = {};
|
|
8562
|
-
|
|
8563
|
-
|
|
8564
|
-
|
|
8565
|
-
|
|
8566
|
-
|
|
9883
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9884
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9885
|
+
}
|
|
9886
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9887
|
+
query["ClientToken"] = request.clientToken;
|
|
9888
|
+
}
|
|
9889
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
9890
|
+
query["DryRun"] = request.dryRun;
|
|
9891
|
+
}
|
|
9892
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9893
|
+
query["RegionId"] = request.regionId;
|
|
9894
|
+
}
|
|
9895
|
+
if (!tea_util_1.default.isUnset(request.spareIp)) {
|
|
9896
|
+
query["SpareIp"] = request.spareIp;
|
|
9897
|
+
}
|
|
8567
9898
|
let req = new $OpenApi.OpenApiRequest({
|
|
8568
9899
|
query: openapi_util_1.default.query(query),
|
|
8569
|
-
body: tea_util_1.default.toMap(request),
|
|
8570
9900
|
});
|
|
8571
9901
|
let params = new $OpenApi.Params({
|
|
8572
9902
|
action: "GetSpareIp",
|
|
@@ -8576,7 +9906,7 @@ class Client extends openapi_client_1.default {
|
|
|
8576
9906
|
method: "POST",
|
|
8577
9907
|
authType: "AK",
|
|
8578
9908
|
style: "RPC",
|
|
8579
|
-
reqBodyType: "
|
|
9909
|
+
reqBodyType: "formData",
|
|
8580
9910
|
bodyType: "json",
|
|
8581
9911
|
});
|
|
8582
9912
|
return $tea.cast(await this.callApi(params, req, runtime), new GetSpareIpResponse({}));
|
|
@@ -8588,10 +9918,11 @@ class Client extends openapi_client_1.default {
|
|
|
8588
9918
|
async listAccelerateAreasWithOptions(request, runtime) {
|
|
8589
9919
|
tea_util_1.default.validateModel(request);
|
|
8590
9920
|
let query = {};
|
|
8591
|
-
|
|
9921
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9922
|
+
query["RegionId"] = request.regionId;
|
|
9923
|
+
}
|
|
8592
9924
|
let req = new $OpenApi.OpenApiRequest({
|
|
8593
9925
|
query: openapi_util_1.default.query(query),
|
|
8594
|
-
body: tea_util_1.default.toMap(request),
|
|
8595
9926
|
});
|
|
8596
9927
|
let params = new $OpenApi.Params({
|
|
8597
9928
|
action: "ListAccelerateAreas",
|
|
@@ -8601,7 +9932,7 @@ class Client extends openapi_client_1.default {
|
|
|
8601
9932
|
method: "POST",
|
|
8602
9933
|
authType: "AK",
|
|
8603
9934
|
style: "RPC",
|
|
8604
|
-
reqBodyType: "
|
|
9935
|
+
reqBodyType: "formData",
|
|
8605
9936
|
bodyType: "json",
|
|
8606
9937
|
});
|
|
8607
9938
|
return $tea.cast(await this.callApi(params, req, runtime), new ListAccelerateAreasResponse({}));
|
|
@@ -8613,14 +9944,23 @@ class Client extends openapi_client_1.default {
|
|
|
8613
9944
|
async listAcceleratorsWithOptions(request, runtime) {
|
|
8614
9945
|
tea_util_1.default.validateModel(request);
|
|
8615
9946
|
let query = {};
|
|
8616
|
-
|
|
8617
|
-
|
|
8618
|
-
|
|
8619
|
-
|
|
8620
|
-
|
|
9947
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9948
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9949
|
+
}
|
|
9950
|
+
if (!tea_util_1.default.isUnset(request.pageNumber)) {
|
|
9951
|
+
query["PageNumber"] = request.pageNumber;
|
|
9952
|
+
}
|
|
9953
|
+
if (!tea_util_1.default.isUnset(request.pageSize)) {
|
|
9954
|
+
query["PageSize"] = request.pageSize;
|
|
9955
|
+
}
|
|
9956
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9957
|
+
query["RegionId"] = request.regionId;
|
|
9958
|
+
}
|
|
9959
|
+
if (!tea_util_1.default.isUnset(request.state)) {
|
|
9960
|
+
query["State"] = request.state;
|
|
9961
|
+
}
|
|
8621
9962
|
let req = new $OpenApi.OpenApiRequest({
|
|
8622
9963
|
query: openapi_util_1.default.query(query),
|
|
8623
|
-
body: tea_util_1.default.toMap(request),
|
|
8624
9964
|
});
|
|
8625
9965
|
let params = new $OpenApi.Params({
|
|
8626
9966
|
action: "ListAccelerators",
|
|
@@ -8630,7 +9970,7 @@ class Client extends openapi_client_1.default {
|
|
|
8630
9970
|
method: "POST",
|
|
8631
9971
|
authType: "AK",
|
|
8632
9972
|
style: "RPC",
|
|
8633
|
-
reqBodyType: "
|
|
9973
|
+
reqBodyType: "formData",
|
|
8634
9974
|
bodyType: "json",
|
|
8635
9975
|
});
|
|
8636
9976
|
return $tea.cast(await this.callApi(params, req, runtime), new ListAcceleratorsResponse({}));
|
|
@@ -8642,15 +9982,26 @@ class Client extends openapi_client_1.default {
|
|
|
8642
9982
|
async listAclsWithOptions(request, runtime) {
|
|
8643
9983
|
tea_util_1.default.validateModel(request);
|
|
8644
9984
|
let query = {};
|
|
8645
|
-
|
|
8646
|
-
|
|
8647
|
-
|
|
8648
|
-
|
|
8649
|
-
|
|
8650
|
-
|
|
9985
|
+
if (!tea_util_1.default.isUnset(request.aclIds)) {
|
|
9986
|
+
query["AclIds"] = request.aclIds;
|
|
9987
|
+
}
|
|
9988
|
+
if (!tea_util_1.default.isUnset(request.aclName)) {
|
|
9989
|
+
query["AclName"] = request.aclName;
|
|
9990
|
+
}
|
|
9991
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9992
|
+
query["ClientToken"] = request.clientToken;
|
|
9993
|
+
}
|
|
9994
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
9995
|
+
query["MaxResults"] = request.maxResults;
|
|
9996
|
+
}
|
|
9997
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
9998
|
+
query["NextToken"] = request.nextToken;
|
|
9999
|
+
}
|
|
10000
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10001
|
+
query["RegionId"] = request.regionId;
|
|
10002
|
+
}
|
|
8651
10003
|
let req = new $OpenApi.OpenApiRequest({
|
|
8652
10004
|
query: openapi_util_1.default.query(query),
|
|
8653
|
-
body: tea_util_1.default.toMap(request),
|
|
8654
10005
|
});
|
|
8655
10006
|
let params = new $OpenApi.Params({
|
|
8656
10007
|
action: "ListAcls",
|
|
@@ -8660,7 +10011,7 @@ class Client extends openapi_client_1.default {
|
|
|
8660
10011
|
method: "POST",
|
|
8661
10012
|
authType: "AK",
|
|
8662
10013
|
style: "RPC",
|
|
8663
|
-
reqBodyType: "
|
|
10014
|
+
reqBodyType: "formData",
|
|
8664
10015
|
bodyType: "json",
|
|
8665
10016
|
});
|
|
8666
10017
|
return $tea.cast(await this.callApi(params, req, runtime), new ListAclsResponse({}));
|
|
@@ -8669,14 +10020,93 @@ class Client extends openapi_client_1.default {
|
|
|
8669
10020
|
let runtime = new $Util.RuntimeOptions({});
|
|
8670
10021
|
return await this.listAclsWithOptions(request, runtime);
|
|
8671
10022
|
}
|
|
10023
|
+
async listApplicationMonitorWithOptions(request, runtime) {
|
|
10024
|
+
tea_util_1.default.validateModel(request);
|
|
10025
|
+
let query = {};
|
|
10026
|
+
if (!tea_util_1.default.isUnset(request.pageNumber)) {
|
|
10027
|
+
query["PageNumber"] = request.pageNumber;
|
|
10028
|
+
}
|
|
10029
|
+
if (!tea_util_1.default.isUnset(request.pageSize)) {
|
|
10030
|
+
query["PageSize"] = request.pageSize;
|
|
10031
|
+
}
|
|
10032
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10033
|
+
query["RegionId"] = request.regionId;
|
|
10034
|
+
}
|
|
10035
|
+
if (!tea_util_1.default.isUnset(request.searchValue)) {
|
|
10036
|
+
query["SearchValue"] = request.searchValue;
|
|
10037
|
+
}
|
|
10038
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
10039
|
+
query: openapi_util_1.default.query(query),
|
|
10040
|
+
});
|
|
10041
|
+
let params = new $OpenApi.Params({
|
|
10042
|
+
action: "ListApplicationMonitor",
|
|
10043
|
+
version: "2019-11-20",
|
|
10044
|
+
protocol: "HTTPS",
|
|
10045
|
+
pathname: "/",
|
|
10046
|
+
method: "POST",
|
|
10047
|
+
authType: "AK",
|
|
10048
|
+
style: "RPC",
|
|
10049
|
+
reqBodyType: "formData",
|
|
10050
|
+
bodyType: "json",
|
|
10051
|
+
});
|
|
10052
|
+
return $tea.cast(await this.callApi(params, req, runtime), new ListApplicationMonitorResponse({}));
|
|
10053
|
+
}
|
|
10054
|
+
async listApplicationMonitor(request) {
|
|
10055
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
10056
|
+
return await this.listApplicationMonitorWithOptions(request, runtime);
|
|
10057
|
+
}
|
|
10058
|
+
async listApplicationMonitorDetectResultWithOptions(request, runtime) {
|
|
10059
|
+
tea_util_1.default.validateModel(request);
|
|
10060
|
+
let query = {};
|
|
10061
|
+
if (!tea_util_1.default.isUnset(request.beginTime)) {
|
|
10062
|
+
query["BeginTime"] = request.beginTime;
|
|
10063
|
+
}
|
|
10064
|
+
if (!tea_util_1.default.isUnset(request.endTime)) {
|
|
10065
|
+
query["EndTime"] = request.endTime;
|
|
10066
|
+
}
|
|
10067
|
+
if (!tea_util_1.default.isUnset(request.pageNumber)) {
|
|
10068
|
+
query["PageNumber"] = request.pageNumber;
|
|
10069
|
+
}
|
|
10070
|
+
if (!tea_util_1.default.isUnset(request.pageSize)) {
|
|
10071
|
+
query["PageSize"] = request.pageSize;
|
|
10072
|
+
}
|
|
10073
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10074
|
+
query["RegionId"] = request.regionId;
|
|
10075
|
+
}
|
|
10076
|
+
if (!tea_util_1.default.isUnset(request.taskId)) {
|
|
10077
|
+
query["TaskId"] = request.taskId;
|
|
10078
|
+
}
|
|
10079
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
10080
|
+
query: openapi_util_1.default.query(query),
|
|
10081
|
+
});
|
|
10082
|
+
let params = new $OpenApi.Params({
|
|
10083
|
+
action: "ListApplicationMonitorDetectResult",
|
|
10084
|
+
version: "2019-11-20",
|
|
10085
|
+
protocol: "HTTPS",
|
|
10086
|
+
pathname: "/",
|
|
10087
|
+
method: "POST",
|
|
10088
|
+
authType: "AK",
|
|
10089
|
+
style: "RPC",
|
|
10090
|
+
reqBodyType: "formData",
|
|
10091
|
+
bodyType: "json",
|
|
10092
|
+
});
|
|
10093
|
+
return $tea.cast(await this.callApi(params, req, runtime), new ListApplicationMonitorDetectResultResponse({}));
|
|
10094
|
+
}
|
|
10095
|
+
async listApplicationMonitorDetectResult(request) {
|
|
10096
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
10097
|
+
return await this.listApplicationMonitorDetectResultWithOptions(request, runtime);
|
|
10098
|
+
}
|
|
8672
10099
|
async listAvailableAccelerateAreasWithOptions(request, runtime) {
|
|
8673
10100
|
tea_util_1.default.validateModel(request);
|
|
8674
10101
|
let query = {};
|
|
8675
|
-
|
|
8676
|
-
|
|
10102
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10103
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10104
|
+
}
|
|
10105
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10106
|
+
query["RegionId"] = request.regionId;
|
|
10107
|
+
}
|
|
8677
10108
|
let req = new $OpenApi.OpenApiRequest({
|
|
8678
10109
|
query: openapi_util_1.default.query(query),
|
|
8679
|
-
body: tea_util_1.default.toMap(request),
|
|
8680
10110
|
});
|
|
8681
10111
|
let params = new $OpenApi.Params({
|
|
8682
10112
|
action: "ListAvailableAccelerateAreas",
|
|
@@ -8686,7 +10116,7 @@ class Client extends openapi_client_1.default {
|
|
|
8686
10116
|
method: "POST",
|
|
8687
10117
|
authType: "AK",
|
|
8688
10118
|
style: "RPC",
|
|
8689
|
-
reqBodyType: "
|
|
10119
|
+
reqBodyType: "formData",
|
|
8690
10120
|
bodyType: "json",
|
|
8691
10121
|
});
|
|
8692
10122
|
return $tea.cast(await this.callApi(params, req, runtime), new ListAvailableAccelerateAreasResponse({}));
|
|
@@ -8698,11 +10128,14 @@ class Client extends openapi_client_1.default {
|
|
|
8698
10128
|
async listAvailableBusiRegionsWithOptions(request, runtime) {
|
|
8699
10129
|
tea_util_1.default.validateModel(request);
|
|
8700
10130
|
let query = {};
|
|
8701
|
-
|
|
8702
|
-
|
|
10131
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10132
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10133
|
+
}
|
|
10134
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10135
|
+
query["RegionId"] = request.regionId;
|
|
10136
|
+
}
|
|
8703
10137
|
let req = new $OpenApi.OpenApiRequest({
|
|
8704
10138
|
query: openapi_util_1.default.query(query),
|
|
8705
|
-
body: tea_util_1.default.toMap(request),
|
|
8706
10139
|
});
|
|
8707
10140
|
let params = new $OpenApi.Params({
|
|
8708
10141
|
action: "ListAvailableBusiRegions",
|
|
@@ -8712,7 +10145,7 @@ class Client extends openapi_client_1.default {
|
|
|
8712
10145
|
method: "POST",
|
|
8713
10146
|
authType: "AK",
|
|
8714
10147
|
style: "RPC",
|
|
8715
|
-
reqBodyType: "
|
|
10148
|
+
reqBodyType: "formData",
|
|
8716
10149
|
bodyType: "json",
|
|
8717
10150
|
});
|
|
8718
10151
|
return $tea.cast(await this.callApi(params, req, runtime), new ListAvailableBusiRegionsResponse({}));
|
|
@@ -8724,15 +10157,26 @@ class Client extends openapi_client_1.default {
|
|
|
8724
10157
|
async listBandwidthPackagesWithOptions(request, runtime) {
|
|
8725
10158
|
tea_util_1.default.validateModel(request);
|
|
8726
10159
|
let query = {};
|
|
8727
|
-
|
|
8728
|
-
|
|
8729
|
-
|
|
8730
|
-
|
|
8731
|
-
|
|
8732
|
-
|
|
10160
|
+
if (!tea_util_1.default.isUnset(request.bandwidthPackageId)) {
|
|
10161
|
+
query["BandwidthPackageId"] = request.bandwidthPackageId;
|
|
10162
|
+
}
|
|
10163
|
+
if (!tea_util_1.default.isUnset(request.pageNumber)) {
|
|
10164
|
+
query["PageNumber"] = request.pageNumber;
|
|
10165
|
+
}
|
|
10166
|
+
if (!tea_util_1.default.isUnset(request.pageSize)) {
|
|
10167
|
+
query["PageSize"] = request.pageSize;
|
|
10168
|
+
}
|
|
10169
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10170
|
+
query["RegionId"] = request.regionId;
|
|
10171
|
+
}
|
|
10172
|
+
if (!tea_util_1.default.isUnset(request.state)) {
|
|
10173
|
+
query["State"] = request.state;
|
|
10174
|
+
}
|
|
10175
|
+
if (!tea_util_1.default.isUnset(request.type)) {
|
|
10176
|
+
query["Type"] = request.type;
|
|
10177
|
+
}
|
|
8733
10178
|
let req = new $OpenApi.OpenApiRequest({
|
|
8734
10179
|
query: openapi_util_1.default.query(query),
|
|
8735
|
-
body: tea_util_1.default.toMap(request),
|
|
8736
10180
|
});
|
|
8737
10181
|
let params = new $OpenApi.Params({
|
|
8738
10182
|
action: "ListBandwidthPackages",
|
|
@@ -8742,7 +10186,7 @@ class Client extends openapi_client_1.default {
|
|
|
8742
10186
|
method: "POST",
|
|
8743
10187
|
authType: "AK",
|
|
8744
10188
|
style: "RPC",
|
|
8745
|
-
reqBodyType: "
|
|
10189
|
+
reqBodyType: "formData",
|
|
8746
10190
|
bodyType: "json",
|
|
8747
10191
|
});
|
|
8748
10192
|
return $tea.cast(await this.callApi(params, req, runtime), new ListBandwidthPackagesResponse({}));
|
|
@@ -8754,12 +10198,17 @@ class Client extends openapi_client_1.default {
|
|
|
8754
10198
|
async listBandwidthackagesWithOptions(request, runtime) {
|
|
8755
10199
|
tea_util_1.default.validateModel(request);
|
|
8756
10200
|
let query = {};
|
|
8757
|
-
|
|
8758
|
-
|
|
8759
|
-
|
|
10201
|
+
if (!tea_util_1.default.isUnset(request.pageNumber)) {
|
|
10202
|
+
query["PageNumber"] = request.pageNumber;
|
|
10203
|
+
}
|
|
10204
|
+
if (!tea_util_1.default.isUnset(request.pageSize)) {
|
|
10205
|
+
query["PageSize"] = request.pageSize;
|
|
10206
|
+
}
|
|
10207
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10208
|
+
query["RegionId"] = request.regionId;
|
|
10209
|
+
}
|
|
8760
10210
|
let req = new $OpenApi.OpenApiRequest({
|
|
8761
10211
|
query: openapi_util_1.default.query(query),
|
|
8762
|
-
body: tea_util_1.default.toMap(request),
|
|
8763
10212
|
});
|
|
8764
10213
|
let params = new $OpenApi.Params({
|
|
8765
10214
|
action: "ListBandwidthackages",
|
|
@@ -8769,7 +10218,7 @@ class Client extends openapi_client_1.default {
|
|
|
8769
10218
|
method: "POST",
|
|
8770
10219
|
authType: "AK",
|
|
8771
10220
|
style: "RPC",
|
|
8772
|
-
reqBodyType: "
|
|
10221
|
+
reqBodyType: "formData",
|
|
8773
10222
|
bodyType: "json",
|
|
8774
10223
|
});
|
|
8775
10224
|
return $tea.cast(await this.callApi(params, req, runtime), new ListBandwidthackagesResponse({}));
|
|
@@ -8781,14 +10230,23 @@ class Client extends openapi_client_1.default {
|
|
|
8781
10230
|
async listBasicAcceleratorsWithOptions(request, runtime) {
|
|
8782
10231
|
tea_util_1.default.validateModel(request);
|
|
8783
10232
|
let query = {};
|
|
8784
|
-
|
|
8785
|
-
|
|
8786
|
-
|
|
8787
|
-
|
|
8788
|
-
|
|
10233
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10234
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10235
|
+
}
|
|
10236
|
+
if (!tea_util_1.default.isUnset(request.pageNumber)) {
|
|
10237
|
+
query["PageNumber"] = request.pageNumber;
|
|
10238
|
+
}
|
|
10239
|
+
if (!tea_util_1.default.isUnset(request.pageSize)) {
|
|
10240
|
+
query["PageSize"] = request.pageSize;
|
|
10241
|
+
}
|
|
10242
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10243
|
+
query["RegionId"] = request.regionId;
|
|
10244
|
+
}
|
|
10245
|
+
if (!tea_util_1.default.isUnset(request.state)) {
|
|
10246
|
+
query["State"] = request.state;
|
|
10247
|
+
}
|
|
8789
10248
|
let req = new $OpenApi.OpenApiRequest({
|
|
8790
10249
|
query: openapi_util_1.default.query(query),
|
|
8791
|
-
body: tea_util_1.default.toMap(request),
|
|
8792
10250
|
});
|
|
8793
10251
|
let params = new $OpenApi.Params({
|
|
8794
10252
|
action: "ListBasicAccelerators",
|
|
@@ -8798,7 +10256,7 @@ class Client extends openapi_client_1.default {
|
|
|
8798
10256
|
method: "POST",
|
|
8799
10257
|
authType: "AK",
|
|
8800
10258
|
style: "RPC",
|
|
8801
|
-
reqBodyType: "
|
|
10259
|
+
reqBodyType: "formData",
|
|
8802
10260
|
bodyType: "json",
|
|
8803
10261
|
});
|
|
8804
10262
|
return $tea.cast(await this.callApi(params, req, runtime), new ListBasicAcceleratorsResponse({}));
|
|
@@ -8810,10 +10268,11 @@ class Client extends openapi_client_1.default {
|
|
|
8810
10268
|
async listBusiRegionsWithOptions(request, runtime) {
|
|
8811
10269
|
tea_util_1.default.validateModel(request);
|
|
8812
10270
|
let query = {};
|
|
8813
|
-
|
|
10271
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10272
|
+
query["RegionId"] = request.regionId;
|
|
10273
|
+
}
|
|
8814
10274
|
let req = new $OpenApi.OpenApiRequest({
|
|
8815
10275
|
query: openapi_util_1.default.query(query),
|
|
8816
|
-
body: tea_util_1.default.toMap(request),
|
|
8817
10276
|
});
|
|
8818
10277
|
let params = new $OpenApi.Params({
|
|
8819
10278
|
action: "ListBusiRegions",
|
|
@@ -8823,7 +10282,7 @@ class Client extends openapi_client_1.default {
|
|
|
8823
10282
|
method: "POST",
|
|
8824
10283
|
authType: "AK",
|
|
8825
10284
|
style: "RPC",
|
|
8826
|
-
reqBodyType: "
|
|
10285
|
+
reqBodyType: "formData",
|
|
8827
10286
|
bodyType: "json",
|
|
8828
10287
|
});
|
|
8829
10288
|
return $tea.cast(await this.callApi(params, req, runtime), new ListBusiRegionsResponse({}));
|
|
@@ -8835,17 +10294,32 @@ class Client extends openapi_client_1.default {
|
|
|
8835
10294
|
async listEndpointGroupsWithOptions(request, runtime) {
|
|
8836
10295
|
tea_util_1.default.validateModel(request);
|
|
8837
10296
|
let query = {};
|
|
8838
|
-
|
|
8839
|
-
|
|
8840
|
-
|
|
8841
|
-
|
|
8842
|
-
|
|
8843
|
-
|
|
8844
|
-
|
|
8845
|
-
|
|
10297
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10298
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10299
|
+
}
|
|
10300
|
+
if (!tea_util_1.default.isUnset(request.accessLogSwitch)) {
|
|
10301
|
+
query["AccessLogSwitch"] = request.accessLogSwitch;
|
|
10302
|
+
}
|
|
10303
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupId)) {
|
|
10304
|
+
query["EndpointGroupId"] = request.endpointGroupId;
|
|
10305
|
+
}
|
|
10306
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupType)) {
|
|
10307
|
+
query["EndpointGroupType"] = request.endpointGroupType;
|
|
10308
|
+
}
|
|
10309
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
10310
|
+
query["ListenerId"] = request.listenerId;
|
|
10311
|
+
}
|
|
10312
|
+
if (!tea_util_1.default.isUnset(request.pageNumber)) {
|
|
10313
|
+
query["PageNumber"] = request.pageNumber;
|
|
10314
|
+
}
|
|
10315
|
+
if (!tea_util_1.default.isUnset(request.pageSize)) {
|
|
10316
|
+
query["PageSize"] = request.pageSize;
|
|
10317
|
+
}
|
|
10318
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10319
|
+
query["RegionId"] = request.regionId;
|
|
10320
|
+
}
|
|
8846
10321
|
let req = new $OpenApi.OpenApiRequest({
|
|
8847
10322
|
query: openapi_util_1.default.query(query),
|
|
8848
|
-
body: tea_util_1.default.toMap(request),
|
|
8849
10323
|
});
|
|
8850
10324
|
let params = new $OpenApi.Params({
|
|
8851
10325
|
action: "ListEndpointGroups",
|
|
@@ -8855,7 +10329,7 @@ class Client extends openapi_client_1.default {
|
|
|
8855
10329
|
method: "POST",
|
|
8856
10330
|
authType: "AK",
|
|
8857
10331
|
style: "RPC",
|
|
8858
|
-
reqBodyType: "
|
|
10332
|
+
reqBodyType: "formData",
|
|
8859
10333
|
bodyType: "json",
|
|
8860
10334
|
});
|
|
8861
10335
|
return $tea.cast(await this.callApi(params, req, runtime), new ListEndpointGroupsResponse({}));
|
|
@@ -8867,16 +10341,29 @@ class Client extends openapi_client_1.default {
|
|
|
8867
10341
|
async listForwardingRulesWithOptions(request, runtime) {
|
|
8868
10342
|
tea_util_1.default.validateModel(request);
|
|
8869
10343
|
let query = {};
|
|
8870
|
-
|
|
8871
|
-
|
|
8872
|
-
|
|
8873
|
-
|
|
8874
|
-
|
|
8875
|
-
|
|
8876
|
-
|
|
10344
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10345
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10346
|
+
}
|
|
10347
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10348
|
+
query["ClientToken"] = request.clientToken;
|
|
10349
|
+
}
|
|
10350
|
+
if (!tea_util_1.default.isUnset(request.forwardingRuleId)) {
|
|
10351
|
+
query["ForwardingRuleId"] = request.forwardingRuleId;
|
|
10352
|
+
}
|
|
10353
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
10354
|
+
query["ListenerId"] = request.listenerId;
|
|
10355
|
+
}
|
|
10356
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
10357
|
+
query["MaxResults"] = request.maxResults;
|
|
10358
|
+
}
|
|
10359
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
10360
|
+
query["NextToken"] = request.nextToken;
|
|
10361
|
+
}
|
|
10362
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10363
|
+
query["RegionId"] = request.regionId;
|
|
10364
|
+
}
|
|
8877
10365
|
let req = new $OpenApi.OpenApiRequest({
|
|
8878
10366
|
query: openapi_util_1.default.query(query),
|
|
8879
|
-
body: tea_util_1.default.toMap(request),
|
|
8880
10367
|
});
|
|
8881
10368
|
let params = new $OpenApi.Params({
|
|
8882
10369
|
action: "ListForwardingRules",
|
|
@@ -8886,7 +10373,7 @@ class Client extends openapi_client_1.default {
|
|
|
8886
10373
|
method: "POST",
|
|
8887
10374
|
authType: "AK",
|
|
8888
10375
|
style: "RPC",
|
|
8889
|
-
reqBodyType: "
|
|
10376
|
+
reqBodyType: "formData",
|
|
8890
10377
|
bodyType: "json",
|
|
8891
10378
|
});
|
|
8892
10379
|
return $tea.cast(await this.callApi(params, req, runtime), new ListForwardingRulesResponse({}));
|
|
@@ -8898,13 +10385,20 @@ class Client extends openapi_client_1.default {
|
|
|
8898
10385
|
async listIpSetsWithOptions(request, runtime) {
|
|
8899
10386
|
tea_util_1.default.validateModel(request);
|
|
8900
10387
|
let query = {};
|
|
8901
|
-
|
|
8902
|
-
|
|
8903
|
-
|
|
8904
|
-
|
|
10388
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10389
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10390
|
+
}
|
|
10391
|
+
if (!tea_util_1.default.isUnset(request.pageNumber)) {
|
|
10392
|
+
query["PageNumber"] = request.pageNumber;
|
|
10393
|
+
}
|
|
10394
|
+
if (!tea_util_1.default.isUnset(request.pageSize)) {
|
|
10395
|
+
query["PageSize"] = request.pageSize;
|
|
10396
|
+
}
|
|
10397
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10398
|
+
query["RegionId"] = request.regionId;
|
|
10399
|
+
}
|
|
8905
10400
|
let req = new $OpenApi.OpenApiRequest({
|
|
8906
10401
|
query: openapi_util_1.default.query(query),
|
|
8907
|
-
body: tea_util_1.default.toMap(request),
|
|
8908
10402
|
});
|
|
8909
10403
|
let params = new $OpenApi.Params({
|
|
8910
10404
|
action: "ListIpSets",
|
|
@@ -8914,7 +10408,7 @@ class Client extends openapi_client_1.default {
|
|
|
8914
10408
|
method: "POST",
|
|
8915
10409
|
authType: "AK",
|
|
8916
10410
|
style: "RPC",
|
|
8917
|
-
reqBodyType: "
|
|
10411
|
+
reqBodyType: "formData",
|
|
8918
10412
|
bodyType: "json",
|
|
8919
10413
|
});
|
|
8920
10414
|
return $tea.cast(await this.callApi(params, req, runtime), new ListIpSetsResponse({}));
|
|
@@ -8926,15 +10420,26 @@ class Client extends openapi_client_1.default {
|
|
|
8926
10420
|
async listListenerCertificatesWithOptions(request, runtime) {
|
|
8927
10421
|
tea_util_1.default.validateModel(request);
|
|
8928
10422
|
let query = {};
|
|
8929
|
-
|
|
8930
|
-
|
|
8931
|
-
|
|
8932
|
-
|
|
8933
|
-
|
|
8934
|
-
|
|
10423
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10424
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10425
|
+
}
|
|
10426
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
10427
|
+
query["ListenerId"] = request.listenerId;
|
|
10428
|
+
}
|
|
10429
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
10430
|
+
query["MaxResults"] = request.maxResults;
|
|
10431
|
+
}
|
|
10432
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
10433
|
+
query["NextToken"] = request.nextToken;
|
|
10434
|
+
}
|
|
10435
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10436
|
+
query["RegionId"] = request.regionId;
|
|
10437
|
+
}
|
|
10438
|
+
if (!tea_util_1.default.isUnset(request.role)) {
|
|
10439
|
+
query["Role"] = request.role;
|
|
10440
|
+
}
|
|
8935
10441
|
let req = new $OpenApi.OpenApiRequest({
|
|
8936
10442
|
query: openapi_util_1.default.query(query),
|
|
8937
|
-
body: tea_util_1.default.toMap(request),
|
|
8938
10443
|
});
|
|
8939
10444
|
let params = new $OpenApi.Params({
|
|
8940
10445
|
action: "ListListenerCertificates",
|
|
@@ -8944,7 +10449,7 @@ class Client extends openapi_client_1.default {
|
|
|
8944
10449
|
method: "POST",
|
|
8945
10450
|
authType: "AK",
|
|
8946
10451
|
style: "RPC",
|
|
8947
|
-
reqBodyType: "
|
|
10452
|
+
reqBodyType: "formData",
|
|
8948
10453
|
bodyType: "json",
|
|
8949
10454
|
});
|
|
8950
10455
|
return $tea.cast(await this.callApi(params, req, runtime), new ListListenerCertificatesResponse({}));
|
|
@@ -8956,13 +10461,20 @@ class Client extends openapi_client_1.default {
|
|
|
8956
10461
|
async listListenersWithOptions(request, runtime) {
|
|
8957
10462
|
tea_util_1.default.validateModel(request);
|
|
8958
10463
|
let query = {};
|
|
8959
|
-
|
|
8960
|
-
|
|
8961
|
-
|
|
8962
|
-
|
|
10464
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10465
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10466
|
+
}
|
|
10467
|
+
if (!tea_util_1.default.isUnset(request.pageNumber)) {
|
|
10468
|
+
query["PageNumber"] = request.pageNumber;
|
|
10469
|
+
}
|
|
10470
|
+
if (!tea_util_1.default.isUnset(request.pageSize)) {
|
|
10471
|
+
query["PageSize"] = request.pageSize;
|
|
10472
|
+
}
|
|
10473
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10474
|
+
query["RegionId"] = request.regionId;
|
|
10475
|
+
}
|
|
8963
10476
|
let req = new $OpenApi.OpenApiRequest({
|
|
8964
10477
|
query: openapi_util_1.default.query(query),
|
|
8965
|
-
body: tea_util_1.default.toMap(request),
|
|
8966
10478
|
});
|
|
8967
10479
|
let params = new $OpenApi.Params({
|
|
8968
10480
|
action: "ListListeners",
|
|
@@ -8972,7 +10484,7 @@ class Client extends openapi_client_1.default {
|
|
|
8972
10484
|
method: "POST",
|
|
8973
10485
|
authType: "AK",
|
|
8974
10486
|
style: "RPC",
|
|
8975
|
-
reqBodyType: "
|
|
10487
|
+
reqBodyType: "formData",
|
|
8976
10488
|
bodyType: "json",
|
|
8977
10489
|
});
|
|
8978
10490
|
return $tea.cast(await this.callApi(params, req, runtime), new ListListenersResponse({}));
|
|
@@ -8984,13 +10496,20 @@ class Client extends openapi_client_1.default {
|
|
|
8984
10496
|
async listSpareIpsWithOptions(request, runtime) {
|
|
8985
10497
|
tea_util_1.default.validateModel(request);
|
|
8986
10498
|
let query = {};
|
|
8987
|
-
|
|
8988
|
-
|
|
8989
|
-
|
|
8990
|
-
|
|
10499
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10500
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10501
|
+
}
|
|
10502
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10503
|
+
query["ClientToken"] = request.clientToken;
|
|
10504
|
+
}
|
|
10505
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
10506
|
+
query["DryRun"] = request.dryRun;
|
|
10507
|
+
}
|
|
10508
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10509
|
+
query["RegionId"] = request.regionId;
|
|
10510
|
+
}
|
|
8991
10511
|
let req = new $OpenApi.OpenApiRequest({
|
|
8992
10512
|
query: openapi_util_1.default.query(query),
|
|
8993
|
-
body: tea_util_1.default.toMap(request),
|
|
8994
10513
|
});
|
|
8995
10514
|
let params = new $OpenApi.Params({
|
|
8996
10515
|
action: "ListSpareIps",
|
|
@@ -9000,7 +10519,7 @@ class Client extends openapi_client_1.default {
|
|
|
9000
10519
|
method: "POST",
|
|
9001
10520
|
authType: "AK",
|
|
9002
10521
|
style: "RPC",
|
|
9003
|
-
reqBodyType: "
|
|
10522
|
+
reqBodyType: "formData",
|
|
9004
10523
|
bodyType: "json",
|
|
9005
10524
|
});
|
|
9006
10525
|
return $tea.cast(await this.callApi(params, req, runtime), new ListSpareIpsResponse({}));
|
|
@@ -9012,12 +10531,17 @@ class Client extends openapi_client_1.default {
|
|
|
9012
10531
|
async listSystemSecurityPoliciesWithOptions(request, runtime) {
|
|
9013
10532
|
tea_util_1.default.validateModel(request);
|
|
9014
10533
|
let query = {};
|
|
9015
|
-
|
|
9016
|
-
|
|
9017
|
-
|
|
10534
|
+
if (!tea_util_1.default.isUnset(request.pageNumber)) {
|
|
10535
|
+
query["PageNumber"] = request.pageNumber;
|
|
10536
|
+
}
|
|
10537
|
+
if (!tea_util_1.default.isUnset(request.pageSize)) {
|
|
10538
|
+
query["PageSize"] = request.pageSize;
|
|
10539
|
+
}
|
|
10540
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10541
|
+
query["RegionId"] = request.regionId;
|
|
10542
|
+
}
|
|
9018
10543
|
let req = new $OpenApi.OpenApiRequest({
|
|
9019
10544
|
query: openapi_util_1.default.query(query),
|
|
9020
|
-
body: tea_util_1.default.toMap(request),
|
|
9021
10545
|
});
|
|
9022
10546
|
let params = new $OpenApi.Params({
|
|
9023
10547
|
action: "ListSystemSecurityPolicies",
|
|
@@ -9027,7 +10551,7 @@ class Client extends openapi_client_1.default {
|
|
|
9027
10551
|
method: "POST",
|
|
9028
10552
|
authType: "AK",
|
|
9029
10553
|
style: "RPC",
|
|
9030
|
-
reqBodyType: "
|
|
10554
|
+
reqBodyType: "formData",
|
|
9031
10555
|
bodyType: "json",
|
|
9032
10556
|
});
|
|
9033
10557
|
return $tea.cast(await this.callApi(params, req, runtime), new ListSystemSecurityPoliciesResponse({}));
|
|
@@ -9039,14 +10563,23 @@ class Client extends openapi_client_1.default {
|
|
|
9039
10563
|
async removeEntriesFromAclWithOptions(request, runtime) {
|
|
9040
10564
|
tea_util_1.default.validateModel(request);
|
|
9041
10565
|
let query = {};
|
|
9042
|
-
|
|
9043
|
-
|
|
9044
|
-
|
|
9045
|
-
|
|
9046
|
-
|
|
10566
|
+
if (!tea_util_1.default.isUnset(request.aclEntries)) {
|
|
10567
|
+
query["AclEntries"] = request.aclEntries;
|
|
10568
|
+
}
|
|
10569
|
+
if (!tea_util_1.default.isUnset(request.aclId)) {
|
|
10570
|
+
query["AclId"] = request.aclId;
|
|
10571
|
+
}
|
|
10572
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10573
|
+
query["ClientToken"] = request.clientToken;
|
|
10574
|
+
}
|
|
10575
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
10576
|
+
query["DryRun"] = request.dryRun;
|
|
10577
|
+
}
|
|
10578
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10579
|
+
query["RegionId"] = request.regionId;
|
|
10580
|
+
}
|
|
9047
10581
|
let req = new $OpenApi.OpenApiRequest({
|
|
9048
10582
|
query: openapi_util_1.default.query(query),
|
|
9049
|
-
body: tea_util_1.default.toMap(request),
|
|
9050
10583
|
});
|
|
9051
10584
|
let params = new $OpenApi.Params({
|
|
9052
10585
|
action: "RemoveEntriesFromAcl",
|
|
@@ -9056,7 +10589,7 @@ class Client extends openapi_client_1.default {
|
|
|
9056
10589
|
method: "POST",
|
|
9057
10590
|
authType: "AK",
|
|
9058
10591
|
style: "RPC",
|
|
9059
|
-
reqBodyType: "
|
|
10592
|
+
reqBodyType: "formData",
|
|
9060
10593
|
bodyType: "json",
|
|
9061
10594
|
});
|
|
9062
10595
|
return $tea.cast(await this.callApi(params, req, runtime), new RemoveEntriesFromAclResponse({}));
|
|
@@ -9068,12 +10601,17 @@ class Client extends openapi_client_1.default {
|
|
|
9068
10601
|
async replaceBandwidthPackageWithOptions(request, runtime) {
|
|
9069
10602
|
tea_util_1.default.validateModel(request);
|
|
9070
10603
|
let query = {};
|
|
9071
|
-
|
|
9072
|
-
|
|
9073
|
-
|
|
10604
|
+
if (!tea_util_1.default.isUnset(request.bandwidthPackageId)) {
|
|
10605
|
+
query["BandwidthPackageId"] = request.bandwidthPackageId;
|
|
10606
|
+
}
|
|
10607
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10608
|
+
query["RegionId"] = request.regionId;
|
|
10609
|
+
}
|
|
10610
|
+
if (!tea_util_1.default.isUnset(request.targetBandwidthPackageId)) {
|
|
10611
|
+
query["TargetBandwidthPackageId"] = request.targetBandwidthPackageId;
|
|
10612
|
+
}
|
|
9074
10613
|
let req = new $OpenApi.OpenApiRequest({
|
|
9075
10614
|
query: openapi_util_1.default.query(query),
|
|
9076
|
-
body: tea_util_1.default.toMap(request),
|
|
9077
10615
|
});
|
|
9078
10616
|
let params = new $OpenApi.Params({
|
|
9079
10617
|
action: "ReplaceBandwidthPackage",
|
|
@@ -9083,7 +10621,7 @@ class Client extends openapi_client_1.default {
|
|
|
9083
10621
|
method: "POST",
|
|
9084
10622
|
authType: "AK",
|
|
9085
10623
|
style: "RPC",
|
|
9086
|
-
reqBodyType: "
|
|
10624
|
+
reqBodyType: "formData",
|
|
9087
10625
|
bodyType: "json",
|
|
9088
10626
|
});
|
|
9089
10627
|
return $tea.cast(await this.callApi(params, req, runtime), new ReplaceBandwidthPackageResponse({}));
|
|
@@ -9095,17 +10633,32 @@ class Client extends openapi_client_1.default {
|
|
|
9095
10633
|
async updateAcceleratorWithOptions(request, runtime) {
|
|
9096
10634
|
tea_util_1.default.validateModel(request);
|
|
9097
10635
|
let query = {};
|
|
9098
|
-
|
|
9099
|
-
|
|
9100
|
-
|
|
9101
|
-
|
|
9102
|
-
|
|
9103
|
-
|
|
9104
|
-
|
|
9105
|
-
|
|
10636
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10637
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10638
|
+
}
|
|
10639
|
+
if (!tea_util_1.default.isUnset(request.autoPay)) {
|
|
10640
|
+
query["AutoPay"] = request.autoPay;
|
|
10641
|
+
}
|
|
10642
|
+
if (!tea_util_1.default.isUnset(request.autoUseCoupon)) {
|
|
10643
|
+
query["AutoUseCoupon"] = request.autoUseCoupon;
|
|
10644
|
+
}
|
|
10645
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10646
|
+
query["ClientToken"] = request.clientToken;
|
|
10647
|
+
}
|
|
10648
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
10649
|
+
query["Description"] = request.description;
|
|
10650
|
+
}
|
|
10651
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
10652
|
+
query["Name"] = request.name;
|
|
10653
|
+
}
|
|
10654
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10655
|
+
query["RegionId"] = request.regionId;
|
|
10656
|
+
}
|
|
10657
|
+
if (!tea_util_1.default.isUnset(request.spec)) {
|
|
10658
|
+
query["Spec"] = request.spec;
|
|
10659
|
+
}
|
|
9106
10660
|
let req = new $OpenApi.OpenApiRequest({
|
|
9107
10661
|
query: openapi_util_1.default.query(query),
|
|
9108
|
-
body: tea_util_1.default.toMap(request),
|
|
9109
10662
|
});
|
|
9110
10663
|
let params = new $OpenApi.Params({
|
|
9111
10664
|
action: "UpdateAccelerator",
|
|
@@ -9115,7 +10668,7 @@ class Client extends openapi_client_1.default {
|
|
|
9115
10668
|
method: "POST",
|
|
9116
10669
|
authType: "AK",
|
|
9117
10670
|
style: "RPC",
|
|
9118
|
-
reqBodyType: "
|
|
10671
|
+
reqBodyType: "formData",
|
|
9119
10672
|
bodyType: "json",
|
|
9120
10673
|
});
|
|
9121
10674
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateAcceleratorResponse({}));
|
|
@@ -9127,16 +10680,29 @@ class Client extends openapi_client_1.default {
|
|
|
9127
10680
|
async updateAcceleratorAutoRenewAttributeWithOptions(request, runtime) {
|
|
9128
10681
|
tea_util_1.default.validateModel(request);
|
|
9129
10682
|
let query = {};
|
|
9130
|
-
|
|
9131
|
-
|
|
9132
|
-
|
|
9133
|
-
|
|
9134
|
-
|
|
9135
|
-
|
|
9136
|
-
|
|
10683
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10684
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10685
|
+
}
|
|
10686
|
+
if (!tea_util_1.default.isUnset(request.autoRenew)) {
|
|
10687
|
+
query["AutoRenew"] = request.autoRenew;
|
|
10688
|
+
}
|
|
10689
|
+
if (!tea_util_1.default.isUnset(request.autoRenewDuration)) {
|
|
10690
|
+
query["AutoRenewDuration"] = request.autoRenewDuration;
|
|
10691
|
+
}
|
|
10692
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10693
|
+
query["ClientToken"] = request.clientToken;
|
|
10694
|
+
}
|
|
10695
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
10696
|
+
query["Name"] = request.name;
|
|
10697
|
+
}
|
|
10698
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10699
|
+
query["RegionId"] = request.regionId;
|
|
10700
|
+
}
|
|
10701
|
+
if (!tea_util_1.default.isUnset(request.renewalStatus)) {
|
|
10702
|
+
query["RenewalStatus"] = request.renewalStatus;
|
|
10703
|
+
}
|
|
9137
10704
|
let req = new $OpenApi.OpenApiRequest({
|
|
9138
10705
|
query: openapi_util_1.default.query(query),
|
|
9139
|
-
body: tea_util_1.default.toMap(request),
|
|
9140
10706
|
});
|
|
9141
10707
|
let params = new $OpenApi.Params({
|
|
9142
10708
|
action: "UpdateAcceleratorAutoRenewAttribute",
|
|
@@ -9146,7 +10712,7 @@ class Client extends openapi_client_1.default {
|
|
|
9146
10712
|
method: "POST",
|
|
9147
10713
|
authType: "AK",
|
|
9148
10714
|
style: "RPC",
|
|
9149
|
-
reqBodyType: "
|
|
10715
|
+
reqBodyType: "formData",
|
|
9150
10716
|
bodyType: "json",
|
|
9151
10717
|
});
|
|
9152
10718
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateAcceleratorAutoRenewAttributeResponse({}));
|
|
@@ -9158,11 +10724,14 @@ class Client extends openapi_client_1.default {
|
|
|
9158
10724
|
async updateAcceleratorConfirmWithOptions(request, runtime) {
|
|
9159
10725
|
tea_util_1.default.validateModel(request);
|
|
9160
10726
|
let query = {};
|
|
9161
|
-
|
|
9162
|
-
|
|
10727
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10728
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10729
|
+
}
|
|
10730
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10731
|
+
query["RegionId"] = request.regionId;
|
|
10732
|
+
}
|
|
9163
10733
|
let req = new $OpenApi.OpenApiRequest({
|
|
9164
10734
|
query: openapi_util_1.default.query(query),
|
|
9165
|
-
body: tea_util_1.default.toMap(request),
|
|
9166
10735
|
});
|
|
9167
10736
|
let params = new $OpenApi.Params({
|
|
9168
10737
|
action: "UpdateAcceleratorConfirm",
|
|
@@ -9172,7 +10741,7 @@ class Client extends openapi_client_1.default {
|
|
|
9172
10741
|
method: "POST",
|
|
9173
10742
|
authType: "AK",
|
|
9174
10743
|
style: "RPC",
|
|
9175
|
-
reqBodyType: "
|
|
10744
|
+
reqBodyType: "formData",
|
|
9176
10745
|
bodyType: "json",
|
|
9177
10746
|
});
|
|
9178
10747
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateAcceleratorConfirmResponse({}));
|
|
@@ -9184,14 +10753,23 @@ class Client extends openapi_client_1.default {
|
|
|
9184
10753
|
async updateAclAttributeWithOptions(request, runtime) {
|
|
9185
10754
|
tea_util_1.default.validateModel(request);
|
|
9186
10755
|
let query = {};
|
|
9187
|
-
|
|
9188
|
-
|
|
9189
|
-
|
|
9190
|
-
|
|
9191
|
-
|
|
10756
|
+
if (!tea_util_1.default.isUnset(request.aclId)) {
|
|
10757
|
+
query["AclId"] = request.aclId;
|
|
10758
|
+
}
|
|
10759
|
+
if (!tea_util_1.default.isUnset(request.aclName)) {
|
|
10760
|
+
query["AclName"] = request.aclName;
|
|
10761
|
+
}
|
|
10762
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10763
|
+
query["ClientToken"] = request.clientToken;
|
|
10764
|
+
}
|
|
10765
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
10766
|
+
query["DryRun"] = request.dryRun;
|
|
10767
|
+
}
|
|
10768
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10769
|
+
query["RegionId"] = request.regionId;
|
|
10770
|
+
}
|
|
9192
10771
|
let req = new $OpenApi.OpenApiRequest({
|
|
9193
10772
|
query: openapi_util_1.default.query(query),
|
|
9194
|
-
body: tea_util_1.default.toMap(request),
|
|
9195
10773
|
});
|
|
9196
10774
|
let params = new $OpenApi.Params({
|
|
9197
10775
|
action: "UpdateAclAttribute",
|
|
@@ -9201,7 +10779,7 @@ class Client extends openapi_client_1.default {
|
|
|
9201
10779
|
method: "POST",
|
|
9202
10780
|
authType: "AK",
|
|
9203
10781
|
style: "RPC",
|
|
9204
|
-
reqBodyType: "
|
|
10782
|
+
reqBodyType: "formData",
|
|
9205
10783
|
bodyType: "json",
|
|
9206
10784
|
});
|
|
9207
10785
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateAclAttributeResponse({}));
|
|
@@ -9210,20 +10788,82 @@ class Client extends openapi_client_1.default {
|
|
|
9210
10788
|
let runtime = new $Util.RuntimeOptions({});
|
|
9211
10789
|
return await this.updateAclAttributeWithOptions(request, runtime);
|
|
9212
10790
|
}
|
|
10791
|
+
async updateApplicationMonitorWithOptions(request, runtime) {
|
|
10792
|
+
tea_util_1.default.validateModel(request);
|
|
10793
|
+
let query = {};
|
|
10794
|
+
if (!tea_util_1.default.isUnset(request.address)) {
|
|
10795
|
+
query["Address"] = request.address;
|
|
10796
|
+
}
|
|
10797
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10798
|
+
query["ClientToken"] = request.clientToken;
|
|
10799
|
+
}
|
|
10800
|
+
if (!tea_util_1.default.isUnset(request.detectThreshold)) {
|
|
10801
|
+
query["DetectThreshold"] = request.detectThreshold;
|
|
10802
|
+
}
|
|
10803
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
10804
|
+
query["ListenerId"] = request.listenerId;
|
|
10805
|
+
}
|
|
10806
|
+
if (!tea_util_1.default.isUnset(request.optionsJson)) {
|
|
10807
|
+
query["OptionsJson"] = request.optionsJson;
|
|
10808
|
+
}
|
|
10809
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10810
|
+
query["RegionId"] = request.regionId;
|
|
10811
|
+
}
|
|
10812
|
+
if (!tea_util_1.default.isUnset(request.taskId)) {
|
|
10813
|
+
query["TaskId"] = request.taskId;
|
|
10814
|
+
}
|
|
10815
|
+
if (!tea_util_1.default.isUnset(request.taskName)) {
|
|
10816
|
+
query["TaskName"] = request.taskName;
|
|
10817
|
+
}
|
|
10818
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
10819
|
+
query: openapi_util_1.default.query(query),
|
|
10820
|
+
});
|
|
10821
|
+
let params = new $OpenApi.Params({
|
|
10822
|
+
action: "UpdateApplicationMonitor",
|
|
10823
|
+
version: "2019-11-20",
|
|
10824
|
+
protocol: "HTTPS",
|
|
10825
|
+
pathname: "/",
|
|
10826
|
+
method: "POST",
|
|
10827
|
+
authType: "AK",
|
|
10828
|
+
style: "RPC",
|
|
10829
|
+
reqBodyType: "formData",
|
|
10830
|
+
bodyType: "json",
|
|
10831
|
+
});
|
|
10832
|
+
return $tea.cast(await this.callApi(params, req, runtime), new UpdateApplicationMonitorResponse({}));
|
|
10833
|
+
}
|
|
10834
|
+
async updateApplicationMonitor(request) {
|
|
10835
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
10836
|
+
return await this.updateApplicationMonitorWithOptions(request, runtime);
|
|
10837
|
+
}
|
|
9213
10838
|
async updateBandwidthPackageWithOptions(request, runtime) {
|
|
9214
10839
|
tea_util_1.default.validateModel(request);
|
|
9215
10840
|
let query = {};
|
|
9216
|
-
|
|
9217
|
-
|
|
9218
|
-
|
|
9219
|
-
|
|
9220
|
-
|
|
9221
|
-
|
|
9222
|
-
|
|
9223
|
-
|
|
10841
|
+
if (!tea_util_1.default.isUnset(request.autoPay)) {
|
|
10842
|
+
query["AutoPay"] = request.autoPay;
|
|
10843
|
+
}
|
|
10844
|
+
if (!tea_util_1.default.isUnset(request.autoUseCoupon)) {
|
|
10845
|
+
query["AutoUseCoupon"] = request.autoUseCoupon;
|
|
10846
|
+
}
|
|
10847
|
+
if (!tea_util_1.default.isUnset(request.bandwidth)) {
|
|
10848
|
+
query["Bandwidth"] = request.bandwidth;
|
|
10849
|
+
}
|
|
10850
|
+
if (!tea_util_1.default.isUnset(request.bandwidthPackageId)) {
|
|
10851
|
+
query["BandwidthPackageId"] = request.bandwidthPackageId;
|
|
10852
|
+
}
|
|
10853
|
+
if (!tea_util_1.default.isUnset(request.bandwidthType)) {
|
|
10854
|
+
query["BandwidthType"] = request.bandwidthType;
|
|
10855
|
+
}
|
|
10856
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
10857
|
+
query["Description"] = request.description;
|
|
10858
|
+
}
|
|
10859
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
10860
|
+
query["Name"] = request.name;
|
|
10861
|
+
}
|
|
10862
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10863
|
+
query["RegionId"] = request.regionId;
|
|
10864
|
+
}
|
|
9224
10865
|
let req = new $OpenApi.OpenApiRequest({
|
|
9225
10866
|
query: openapi_util_1.default.query(query),
|
|
9226
|
-
body: tea_util_1.default.toMap(request),
|
|
9227
10867
|
});
|
|
9228
10868
|
let params = new $OpenApi.Params({
|
|
9229
10869
|
action: "UpdateBandwidthPackage",
|
|
@@ -9233,7 +10873,7 @@ class Client extends openapi_client_1.default {
|
|
|
9233
10873
|
method: "POST",
|
|
9234
10874
|
authType: "AK",
|
|
9235
10875
|
style: "RPC",
|
|
9236
|
-
reqBodyType: "
|
|
10876
|
+
reqBodyType: "formData",
|
|
9237
10877
|
bodyType: "json",
|
|
9238
10878
|
});
|
|
9239
10879
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateBandwidthPackageResponse({}));
|
|
@@ -9245,14 +10885,23 @@ class Client extends openapi_client_1.default {
|
|
|
9245
10885
|
async updateBasicAcceleratorWithOptions(request, runtime) {
|
|
9246
10886
|
tea_util_1.default.validateModel(request);
|
|
9247
10887
|
let query = {};
|
|
9248
|
-
|
|
9249
|
-
|
|
9250
|
-
|
|
9251
|
-
|
|
9252
|
-
|
|
10888
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10889
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10890
|
+
}
|
|
10891
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10892
|
+
query["ClientToken"] = request.clientToken;
|
|
10893
|
+
}
|
|
10894
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
10895
|
+
query["Description"] = request.description;
|
|
10896
|
+
}
|
|
10897
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
10898
|
+
query["Name"] = request.name;
|
|
10899
|
+
}
|
|
10900
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10901
|
+
query["RegionId"] = request.regionId;
|
|
10902
|
+
}
|
|
9253
10903
|
let req = new $OpenApi.OpenApiRequest({
|
|
9254
10904
|
query: openapi_util_1.default.query(query),
|
|
9255
|
-
body: tea_util_1.default.toMap(request),
|
|
9256
10905
|
});
|
|
9257
10906
|
let params = new $OpenApi.Params({
|
|
9258
10907
|
action: "UpdateBasicAccelerator",
|
|
@@ -9262,7 +10911,7 @@ class Client extends openapi_client_1.default {
|
|
|
9262
10911
|
method: "POST",
|
|
9263
10912
|
authType: "AK",
|
|
9264
10913
|
style: "RPC",
|
|
9265
|
-
reqBodyType: "
|
|
10914
|
+
reqBodyType: "formData",
|
|
9266
10915
|
bodyType: "json",
|
|
9267
10916
|
});
|
|
9268
10917
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateBasicAcceleratorResponse({}));
|
|
@@ -9274,16 +10923,29 @@ class Client extends openapi_client_1.default {
|
|
|
9274
10923
|
async updateBasicEndpointGroupWithOptions(request, runtime) {
|
|
9275
10924
|
tea_util_1.default.validateModel(request);
|
|
9276
10925
|
let query = {};
|
|
9277
|
-
|
|
9278
|
-
|
|
9279
|
-
|
|
9280
|
-
|
|
9281
|
-
|
|
9282
|
-
|
|
9283
|
-
|
|
10926
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10927
|
+
query["ClientToken"] = request.clientToken;
|
|
10928
|
+
}
|
|
10929
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
10930
|
+
query["Description"] = request.description;
|
|
10931
|
+
}
|
|
10932
|
+
if (!tea_util_1.default.isUnset(request.endpointAddress)) {
|
|
10933
|
+
query["EndpointAddress"] = request.endpointAddress;
|
|
10934
|
+
}
|
|
10935
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupId)) {
|
|
10936
|
+
query["EndpointGroupId"] = request.endpointGroupId;
|
|
10937
|
+
}
|
|
10938
|
+
if (!tea_util_1.default.isUnset(request.endpointType)) {
|
|
10939
|
+
query["EndpointType"] = request.endpointType;
|
|
10940
|
+
}
|
|
10941
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
10942
|
+
query["Name"] = request.name;
|
|
10943
|
+
}
|
|
10944
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10945
|
+
query["RegionId"] = request.regionId;
|
|
10946
|
+
}
|
|
9284
10947
|
let req = new $OpenApi.OpenApiRequest({
|
|
9285
10948
|
query: openapi_util_1.default.query(query),
|
|
9286
|
-
body: tea_util_1.default.toMap(request),
|
|
9287
10949
|
});
|
|
9288
10950
|
let params = new $OpenApi.Params({
|
|
9289
10951
|
action: "UpdateBasicEndpointGroup",
|
|
@@ -9293,7 +10955,7 @@ class Client extends openapi_client_1.default {
|
|
|
9293
10955
|
method: "POST",
|
|
9294
10956
|
authType: "AK",
|
|
9295
10957
|
style: "RPC",
|
|
9296
|
-
reqBodyType: "
|
|
10958
|
+
reqBodyType: "formData",
|
|
9297
10959
|
bodyType: "json",
|
|
9298
10960
|
});
|
|
9299
10961
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateBasicEndpointGroupResponse({}));
|
|
@@ -9305,25 +10967,56 @@ class Client extends openapi_client_1.default {
|
|
|
9305
10967
|
async updateEndpointGroupWithOptions(request, runtime) {
|
|
9306
10968
|
tea_util_1.default.validateModel(request);
|
|
9307
10969
|
let query = {};
|
|
9308
|
-
|
|
9309
|
-
|
|
9310
|
-
|
|
9311
|
-
|
|
9312
|
-
|
|
9313
|
-
|
|
9314
|
-
|
|
9315
|
-
|
|
9316
|
-
|
|
9317
|
-
|
|
9318
|
-
|
|
9319
|
-
|
|
9320
|
-
|
|
9321
|
-
|
|
9322
|
-
|
|
9323
|
-
|
|
10970
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10971
|
+
query["ClientToken"] = request.clientToken;
|
|
10972
|
+
}
|
|
10973
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
10974
|
+
query["Description"] = request.description;
|
|
10975
|
+
}
|
|
10976
|
+
if (!tea_util_1.default.isUnset(request.endpointConfigurations)) {
|
|
10977
|
+
query["EndpointConfigurations"] = request.endpointConfigurations;
|
|
10978
|
+
}
|
|
10979
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupId)) {
|
|
10980
|
+
query["EndpointGroupId"] = request.endpointGroupId;
|
|
10981
|
+
}
|
|
10982
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupRegion)) {
|
|
10983
|
+
query["EndpointGroupRegion"] = request.endpointGroupRegion;
|
|
10984
|
+
}
|
|
10985
|
+
if (!tea_util_1.default.isUnset(request.endpointRequestProtocol)) {
|
|
10986
|
+
query["EndpointRequestProtocol"] = request.endpointRequestProtocol;
|
|
10987
|
+
}
|
|
10988
|
+
if (!tea_util_1.default.isUnset(request.healthCheckEnabled)) {
|
|
10989
|
+
query["HealthCheckEnabled"] = request.healthCheckEnabled;
|
|
10990
|
+
}
|
|
10991
|
+
if (!tea_util_1.default.isUnset(request.healthCheckIntervalSeconds)) {
|
|
10992
|
+
query["HealthCheckIntervalSeconds"] = request.healthCheckIntervalSeconds;
|
|
10993
|
+
}
|
|
10994
|
+
if (!tea_util_1.default.isUnset(request.healthCheckPath)) {
|
|
10995
|
+
query["HealthCheckPath"] = request.healthCheckPath;
|
|
10996
|
+
}
|
|
10997
|
+
if (!tea_util_1.default.isUnset(request.healthCheckPort)) {
|
|
10998
|
+
query["HealthCheckPort"] = request.healthCheckPort;
|
|
10999
|
+
}
|
|
11000
|
+
if (!tea_util_1.default.isUnset(request.healthCheckProtocol)) {
|
|
11001
|
+
query["HealthCheckProtocol"] = request.healthCheckProtocol;
|
|
11002
|
+
}
|
|
11003
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
11004
|
+
query["Name"] = request.name;
|
|
11005
|
+
}
|
|
11006
|
+
if (!tea_util_1.default.isUnset(request.portOverrides)) {
|
|
11007
|
+
query["PortOverrides"] = request.portOverrides;
|
|
11008
|
+
}
|
|
11009
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
11010
|
+
query["RegionId"] = request.regionId;
|
|
11011
|
+
}
|
|
11012
|
+
if (!tea_util_1.default.isUnset(request.thresholdCount)) {
|
|
11013
|
+
query["ThresholdCount"] = request.thresholdCount;
|
|
11014
|
+
}
|
|
11015
|
+
if (!tea_util_1.default.isUnset(request.trafficPercentage)) {
|
|
11016
|
+
query["TrafficPercentage"] = request.trafficPercentage;
|
|
11017
|
+
}
|
|
9324
11018
|
let req = new $OpenApi.OpenApiRequest({
|
|
9325
11019
|
query: openapi_util_1.default.query(query),
|
|
9326
|
-
body: tea_util_1.default.toMap(request),
|
|
9327
11020
|
});
|
|
9328
11021
|
let params = new $OpenApi.Params({
|
|
9329
11022
|
action: "UpdateEndpointGroup",
|
|
@@ -9333,7 +11026,7 @@ class Client extends openapi_client_1.default {
|
|
|
9333
11026
|
method: "POST",
|
|
9334
11027
|
authType: "AK",
|
|
9335
11028
|
style: "RPC",
|
|
9336
|
-
reqBodyType: "
|
|
11029
|
+
reqBodyType: "formData",
|
|
9337
11030
|
bodyType: "json",
|
|
9338
11031
|
});
|
|
9339
11032
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateEndpointGroupResponse({}));
|
|
@@ -9345,14 +11038,23 @@ class Client extends openapi_client_1.default {
|
|
|
9345
11038
|
async updateEndpointGroupAttributeWithOptions(request, runtime) {
|
|
9346
11039
|
tea_util_1.default.validateModel(request);
|
|
9347
11040
|
let query = {};
|
|
9348
|
-
|
|
9349
|
-
|
|
9350
|
-
|
|
9351
|
-
|
|
9352
|
-
|
|
11041
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
11042
|
+
query["ClientToken"] = request.clientToken;
|
|
11043
|
+
}
|
|
11044
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
11045
|
+
query["Description"] = request.description;
|
|
11046
|
+
}
|
|
11047
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupId)) {
|
|
11048
|
+
query["EndpointGroupId"] = request.endpointGroupId;
|
|
11049
|
+
}
|
|
11050
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
11051
|
+
query["Name"] = request.name;
|
|
11052
|
+
}
|
|
11053
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
11054
|
+
query["RegionId"] = request.regionId;
|
|
11055
|
+
}
|
|
9353
11056
|
let req = new $OpenApi.OpenApiRequest({
|
|
9354
11057
|
query: openapi_util_1.default.query(query),
|
|
9355
|
-
body: tea_util_1.default.toMap(request),
|
|
9356
11058
|
});
|
|
9357
11059
|
let params = new $OpenApi.Params({
|
|
9358
11060
|
action: "UpdateEndpointGroupAttribute",
|
|
@@ -9362,7 +11064,7 @@ class Client extends openapi_client_1.default {
|
|
|
9362
11064
|
method: "POST",
|
|
9363
11065
|
authType: "AK",
|
|
9364
11066
|
style: "RPC",
|
|
9365
|
-
reqBodyType: "
|
|
11067
|
+
reqBodyType: "formData",
|
|
9366
11068
|
bodyType: "json",
|
|
9367
11069
|
});
|
|
9368
11070
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateEndpointGroupAttributeResponse({}));
|
|
@@ -9374,14 +11076,23 @@ class Client extends openapi_client_1.default {
|
|
|
9374
11076
|
async updateEndpointGroupsWithOptions(request, runtime) {
|
|
9375
11077
|
tea_util_1.default.validateModel(request);
|
|
9376
11078
|
let query = {};
|
|
9377
|
-
|
|
9378
|
-
|
|
9379
|
-
|
|
9380
|
-
|
|
9381
|
-
|
|
11079
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
11080
|
+
query["ClientToken"] = request.clientToken;
|
|
11081
|
+
}
|
|
11082
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
11083
|
+
query["DryRun"] = request.dryRun;
|
|
11084
|
+
}
|
|
11085
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupConfigurations)) {
|
|
11086
|
+
query["EndpointGroupConfigurations"] = request.endpointGroupConfigurations;
|
|
11087
|
+
}
|
|
11088
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
11089
|
+
query["ListenerId"] = request.listenerId;
|
|
11090
|
+
}
|
|
11091
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
11092
|
+
query["RegionId"] = request.regionId;
|
|
11093
|
+
}
|
|
9382
11094
|
let req = new $OpenApi.OpenApiRequest({
|
|
9383
11095
|
query: openapi_util_1.default.query(query),
|
|
9384
|
-
body: tea_util_1.default.toMap(request),
|
|
9385
11096
|
});
|
|
9386
11097
|
let params = new $OpenApi.Params({
|
|
9387
11098
|
action: "UpdateEndpointGroups",
|
|
@@ -9391,7 +11102,7 @@ class Client extends openapi_client_1.default {
|
|
|
9391
11102
|
method: "POST",
|
|
9392
11103
|
authType: "AK",
|
|
9393
11104
|
style: "RPC",
|
|
9394
|
-
reqBodyType: "
|
|
11105
|
+
reqBodyType: "formData",
|
|
9395
11106
|
bodyType: "json",
|
|
9396
11107
|
});
|
|
9397
11108
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateEndpointGroupsResponse({}));
|
|
@@ -9403,14 +11114,23 @@ class Client extends openapi_client_1.default {
|
|
|
9403
11114
|
async updateForwardingRulesWithOptions(request, runtime) {
|
|
9404
11115
|
tea_util_1.default.validateModel(request);
|
|
9405
11116
|
let query = {};
|
|
9406
|
-
|
|
9407
|
-
|
|
9408
|
-
|
|
9409
|
-
|
|
9410
|
-
|
|
11117
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
11118
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
11119
|
+
}
|
|
11120
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
11121
|
+
query["ClientToken"] = request.clientToken;
|
|
11122
|
+
}
|
|
11123
|
+
if (!tea_util_1.default.isUnset(request.forwardingRules)) {
|
|
11124
|
+
query["ForwardingRules"] = request.forwardingRules;
|
|
11125
|
+
}
|
|
11126
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
11127
|
+
query["ListenerId"] = request.listenerId;
|
|
11128
|
+
}
|
|
11129
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
11130
|
+
query["RegionId"] = request.regionId;
|
|
11131
|
+
}
|
|
9411
11132
|
let req = new $OpenApi.OpenApiRequest({
|
|
9412
11133
|
query: openapi_util_1.default.query(query),
|
|
9413
|
-
body: tea_util_1.default.toMap(request),
|
|
9414
11134
|
});
|
|
9415
11135
|
let params = new $OpenApi.Params({
|
|
9416
11136
|
action: "UpdateForwardingRules",
|
|
@@ -9420,7 +11140,7 @@ class Client extends openapi_client_1.default {
|
|
|
9420
11140
|
method: "POST",
|
|
9421
11141
|
authType: "AK",
|
|
9422
11142
|
style: "RPC",
|
|
9423
|
-
reqBodyType: "
|
|
11143
|
+
reqBodyType: "formData",
|
|
9424
11144
|
bodyType: "json",
|
|
9425
11145
|
});
|
|
9426
11146
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateForwardingRulesResponse({}));
|
|
@@ -9432,13 +11152,20 @@ class Client extends openapi_client_1.default {
|
|
|
9432
11152
|
async updateIpSetWithOptions(request, runtime) {
|
|
9433
11153
|
tea_util_1.default.validateModel(request);
|
|
9434
11154
|
let query = {};
|
|
9435
|
-
|
|
9436
|
-
|
|
9437
|
-
|
|
9438
|
-
|
|
11155
|
+
if (!tea_util_1.default.isUnset(request.bandwidth)) {
|
|
11156
|
+
query["Bandwidth"] = request.bandwidth;
|
|
11157
|
+
}
|
|
11158
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
11159
|
+
query["ClientToken"] = request.clientToken;
|
|
11160
|
+
}
|
|
11161
|
+
if (!tea_util_1.default.isUnset(request.ipSetId)) {
|
|
11162
|
+
query["IpSetId"] = request.ipSetId;
|
|
11163
|
+
}
|
|
11164
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
11165
|
+
query["RegionId"] = request.regionId;
|
|
11166
|
+
}
|
|
9439
11167
|
let req = new $OpenApi.OpenApiRequest({
|
|
9440
11168
|
query: openapi_util_1.default.query(query),
|
|
9441
|
-
body: tea_util_1.default.toMap(request),
|
|
9442
11169
|
});
|
|
9443
11170
|
let params = new $OpenApi.Params({
|
|
9444
11171
|
action: "UpdateIpSet",
|
|
@@ -9448,7 +11175,7 @@ class Client extends openapi_client_1.default {
|
|
|
9448
11175
|
method: "POST",
|
|
9449
11176
|
authType: "AK",
|
|
9450
11177
|
style: "RPC",
|
|
9451
|
-
reqBodyType: "
|
|
11178
|
+
reqBodyType: "formData",
|
|
9452
11179
|
bodyType: "json",
|
|
9453
11180
|
});
|
|
9454
11181
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateIpSetResponse({}));
|
|
@@ -9460,11 +11187,14 @@ class Client extends openapi_client_1.default {
|
|
|
9460
11187
|
async updateIpSetsWithOptions(request, runtime) {
|
|
9461
11188
|
tea_util_1.default.validateModel(request);
|
|
9462
11189
|
let query = {};
|
|
9463
|
-
|
|
9464
|
-
|
|
11190
|
+
if (!tea_util_1.default.isUnset(request.ipSets)) {
|
|
11191
|
+
query["IpSets"] = request.ipSets;
|
|
11192
|
+
}
|
|
11193
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
11194
|
+
query["RegionId"] = request.regionId;
|
|
11195
|
+
}
|
|
9465
11196
|
let req = new $OpenApi.OpenApiRequest({
|
|
9466
11197
|
query: openapi_util_1.default.query(query),
|
|
9467
|
-
body: tea_util_1.default.toMap(request),
|
|
9468
11198
|
});
|
|
9469
11199
|
let params = new $OpenApi.Params({
|
|
9470
11200
|
action: "UpdateIpSets",
|
|
@@ -9474,7 +11204,7 @@ class Client extends openapi_client_1.default {
|
|
|
9474
11204
|
method: "POST",
|
|
9475
11205
|
authType: "AK",
|
|
9476
11206
|
style: "RPC",
|
|
9477
|
-
reqBodyType: "
|
|
11207
|
+
reqBodyType: "formData",
|
|
9478
11208
|
bodyType: "json",
|
|
9479
11209
|
});
|
|
9480
11210
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateIpSetsResponse({}));
|
|
@@ -9486,22 +11216,47 @@ class Client extends openapi_client_1.default {
|
|
|
9486
11216
|
async updateListenerWithOptions(request, runtime) {
|
|
9487
11217
|
tea_util_1.default.validateModel(request);
|
|
9488
11218
|
let query = {};
|
|
9489
|
-
|
|
9490
|
-
|
|
9491
|
-
|
|
9492
|
-
|
|
9493
|
-
|
|
9494
|
-
|
|
9495
|
-
|
|
9496
|
-
|
|
9497
|
-
|
|
9498
|
-
|
|
9499
|
-
|
|
9500
|
-
|
|
9501
|
-
|
|
11219
|
+
if (!tea_util_1.default.isUnset(request.backendPorts)) {
|
|
11220
|
+
query["BackendPorts"] = request.backendPorts;
|
|
11221
|
+
}
|
|
11222
|
+
if (!tea_util_1.default.isUnset(request.certificates)) {
|
|
11223
|
+
query["Certificates"] = request.certificates;
|
|
11224
|
+
}
|
|
11225
|
+
if (!tea_util_1.default.isUnset(request.clientAffinity)) {
|
|
11226
|
+
query["ClientAffinity"] = request.clientAffinity;
|
|
11227
|
+
}
|
|
11228
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
11229
|
+
query["ClientToken"] = request.clientToken;
|
|
11230
|
+
}
|
|
11231
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
11232
|
+
query["Description"] = request.description;
|
|
11233
|
+
}
|
|
11234
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
11235
|
+
query["ListenerId"] = request.listenerId;
|
|
11236
|
+
}
|
|
11237
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
11238
|
+
query["Name"] = request.name;
|
|
11239
|
+
}
|
|
11240
|
+
if (!tea_util_1.default.isUnset(request.portRanges)) {
|
|
11241
|
+
query["PortRanges"] = request.portRanges;
|
|
11242
|
+
}
|
|
11243
|
+
if (!tea_util_1.default.isUnset(request.protocol)) {
|
|
11244
|
+
query["Protocol"] = request.protocol;
|
|
11245
|
+
}
|
|
11246
|
+
if (!tea_util_1.default.isUnset(request.proxyProtocol)) {
|
|
11247
|
+
query["ProxyProtocol"] = request.proxyProtocol;
|
|
11248
|
+
}
|
|
11249
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
11250
|
+
query["RegionId"] = request.regionId;
|
|
11251
|
+
}
|
|
11252
|
+
if (!tea_util_1.default.isUnset(request.securityPolicyId)) {
|
|
11253
|
+
query["SecurityPolicyId"] = request.securityPolicyId;
|
|
11254
|
+
}
|
|
11255
|
+
if (!tea_util_1.default.isUnset($tea.toMap(request.XForwardedForConfig))) {
|
|
11256
|
+
query["XForwardedForConfig"] = request.XForwardedForConfig;
|
|
11257
|
+
}
|
|
9502
11258
|
let req = new $OpenApi.OpenApiRequest({
|
|
9503
11259
|
query: openapi_util_1.default.query(query),
|
|
9504
|
-
body: tea_util_1.default.toMap(request),
|
|
9505
11260
|
});
|
|
9506
11261
|
let params = new $OpenApi.Params({
|
|
9507
11262
|
action: "UpdateListener",
|
|
@@ -9511,7 +11266,7 @@ class Client extends openapi_client_1.default {
|
|
|
9511
11266
|
method: "POST",
|
|
9512
11267
|
authType: "AK",
|
|
9513
11268
|
style: "RPC",
|
|
9514
|
-
reqBodyType: "
|
|
11269
|
+
reqBodyType: "formData",
|
|
9515
11270
|
bodyType: "json",
|
|
9516
11271
|
});
|
|
9517
11272
|
return $tea.cast(await this.callApi(params, req, runtime), new UpdateListenerResponse({}));
|