@alicloud/ga20191120 1.0.7 → 1.0.8
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/client.d.ts +471 -0
- package/dist/client.js +2242 -480
- package/dist/client.js.map +1 -1
- package/package.json +2 -2
- package/src/client.ts +2906 -519
package/dist/client.js
CHANGED
|
@@ -641,6 +641,72 @@ class CreateAclResponse extends $tea.Model {
|
|
|
641
641
|
}
|
|
642
642
|
}
|
|
643
643
|
exports.CreateAclResponse = CreateAclResponse;
|
|
644
|
+
class CreateApplicationMonitorRequest extends $tea.Model {
|
|
645
|
+
constructor(map) {
|
|
646
|
+
super(map);
|
|
647
|
+
}
|
|
648
|
+
static names() {
|
|
649
|
+
return {
|
|
650
|
+
acceleratorId: 'AcceleratorId',
|
|
651
|
+
address: 'Address',
|
|
652
|
+
clientToken: 'ClientToken',
|
|
653
|
+
detectThreshold: 'DetectThreshold',
|
|
654
|
+
listenerId: 'ListenerId',
|
|
655
|
+
optionsJson: 'OptionsJson',
|
|
656
|
+
regionId: 'RegionId',
|
|
657
|
+
taskName: 'TaskName',
|
|
658
|
+
};
|
|
659
|
+
}
|
|
660
|
+
static types() {
|
|
661
|
+
return {
|
|
662
|
+
acceleratorId: 'string',
|
|
663
|
+
address: 'string',
|
|
664
|
+
clientToken: 'string',
|
|
665
|
+
detectThreshold: 'number',
|
|
666
|
+
listenerId: 'string',
|
|
667
|
+
optionsJson: 'string',
|
|
668
|
+
regionId: 'string',
|
|
669
|
+
taskName: 'string',
|
|
670
|
+
};
|
|
671
|
+
}
|
|
672
|
+
}
|
|
673
|
+
exports.CreateApplicationMonitorRequest = CreateApplicationMonitorRequest;
|
|
674
|
+
class CreateApplicationMonitorResponseBody extends $tea.Model {
|
|
675
|
+
constructor(map) {
|
|
676
|
+
super(map);
|
|
677
|
+
}
|
|
678
|
+
static names() {
|
|
679
|
+
return {
|
|
680
|
+
requestId: 'RequestId',
|
|
681
|
+
taskId: 'TaskId',
|
|
682
|
+
};
|
|
683
|
+
}
|
|
684
|
+
static types() {
|
|
685
|
+
return {
|
|
686
|
+
requestId: 'string',
|
|
687
|
+
taskId: 'string',
|
|
688
|
+
};
|
|
689
|
+
}
|
|
690
|
+
}
|
|
691
|
+
exports.CreateApplicationMonitorResponseBody = CreateApplicationMonitorResponseBody;
|
|
692
|
+
class CreateApplicationMonitorResponse extends $tea.Model {
|
|
693
|
+
constructor(map) {
|
|
694
|
+
super(map);
|
|
695
|
+
}
|
|
696
|
+
static names() {
|
|
697
|
+
return {
|
|
698
|
+
headers: 'headers',
|
|
699
|
+
body: 'body',
|
|
700
|
+
};
|
|
701
|
+
}
|
|
702
|
+
static types() {
|
|
703
|
+
return {
|
|
704
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
705
|
+
body: CreateApplicationMonitorResponseBody,
|
|
706
|
+
};
|
|
707
|
+
}
|
|
708
|
+
}
|
|
709
|
+
exports.CreateApplicationMonitorResponse = CreateApplicationMonitorResponse;
|
|
644
710
|
class CreateBandwidthPackageRequest extends $tea.Model {
|
|
645
711
|
constructor(map) {
|
|
646
712
|
super(map);
|
|
@@ -1425,6 +1491,60 @@ class DeleteAclResponse extends $tea.Model {
|
|
|
1425
1491
|
}
|
|
1426
1492
|
}
|
|
1427
1493
|
exports.DeleteAclResponse = DeleteAclResponse;
|
|
1494
|
+
class DeleteApplicationMonitorRequest extends $tea.Model {
|
|
1495
|
+
constructor(map) {
|
|
1496
|
+
super(map);
|
|
1497
|
+
}
|
|
1498
|
+
static names() {
|
|
1499
|
+
return {
|
|
1500
|
+
clientToken: 'ClientToken',
|
|
1501
|
+
regionId: 'RegionId',
|
|
1502
|
+
taskId: 'TaskId',
|
|
1503
|
+
};
|
|
1504
|
+
}
|
|
1505
|
+
static types() {
|
|
1506
|
+
return {
|
|
1507
|
+
clientToken: 'string',
|
|
1508
|
+
regionId: 'string',
|
|
1509
|
+
taskId: 'string',
|
|
1510
|
+
};
|
|
1511
|
+
}
|
|
1512
|
+
}
|
|
1513
|
+
exports.DeleteApplicationMonitorRequest = DeleteApplicationMonitorRequest;
|
|
1514
|
+
class DeleteApplicationMonitorResponseBody extends $tea.Model {
|
|
1515
|
+
constructor(map) {
|
|
1516
|
+
super(map);
|
|
1517
|
+
}
|
|
1518
|
+
static names() {
|
|
1519
|
+
return {
|
|
1520
|
+
requestId: 'RequestId',
|
|
1521
|
+
};
|
|
1522
|
+
}
|
|
1523
|
+
static types() {
|
|
1524
|
+
return {
|
|
1525
|
+
requestId: 'string',
|
|
1526
|
+
};
|
|
1527
|
+
}
|
|
1528
|
+
}
|
|
1529
|
+
exports.DeleteApplicationMonitorResponseBody = DeleteApplicationMonitorResponseBody;
|
|
1530
|
+
class DeleteApplicationMonitorResponse extends $tea.Model {
|
|
1531
|
+
constructor(map) {
|
|
1532
|
+
super(map);
|
|
1533
|
+
}
|
|
1534
|
+
static names() {
|
|
1535
|
+
return {
|
|
1536
|
+
headers: 'headers',
|
|
1537
|
+
body: 'body',
|
|
1538
|
+
};
|
|
1539
|
+
}
|
|
1540
|
+
static types() {
|
|
1541
|
+
return {
|
|
1542
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
1543
|
+
body: DeleteApplicationMonitorResponseBody,
|
|
1544
|
+
};
|
|
1545
|
+
}
|
|
1546
|
+
}
|
|
1547
|
+
exports.DeleteApplicationMonitorResponse = DeleteApplicationMonitorResponse;
|
|
1428
1548
|
class DeleteBandwidthPackageRequest extends $tea.Model {
|
|
1429
1549
|
constructor(map) {
|
|
1430
1550
|
super(map);
|
|
@@ -2173,6 +2293,78 @@ class DescribeAcceleratorAutoRenewAttributeResponse extends $tea.Model {
|
|
|
2173
2293
|
}
|
|
2174
2294
|
}
|
|
2175
2295
|
exports.DescribeAcceleratorAutoRenewAttributeResponse = DescribeAcceleratorAutoRenewAttributeResponse;
|
|
2296
|
+
class DescribeApplicationMonitorRequest extends $tea.Model {
|
|
2297
|
+
constructor(map) {
|
|
2298
|
+
super(map);
|
|
2299
|
+
}
|
|
2300
|
+
static names() {
|
|
2301
|
+
return {
|
|
2302
|
+
clientToken: 'ClientToken',
|
|
2303
|
+
regionId: 'RegionId',
|
|
2304
|
+
taskId: 'TaskId',
|
|
2305
|
+
};
|
|
2306
|
+
}
|
|
2307
|
+
static types() {
|
|
2308
|
+
return {
|
|
2309
|
+
clientToken: 'string',
|
|
2310
|
+
regionId: 'string',
|
|
2311
|
+
taskId: 'string',
|
|
2312
|
+
};
|
|
2313
|
+
}
|
|
2314
|
+
}
|
|
2315
|
+
exports.DescribeApplicationMonitorRequest = DescribeApplicationMonitorRequest;
|
|
2316
|
+
class DescribeApplicationMonitorResponseBody extends $tea.Model {
|
|
2317
|
+
constructor(map) {
|
|
2318
|
+
super(map);
|
|
2319
|
+
}
|
|
2320
|
+
static names() {
|
|
2321
|
+
return {
|
|
2322
|
+
acceleratorId: 'AcceleratorId',
|
|
2323
|
+
address: 'Address',
|
|
2324
|
+
detectThreshold: 'DetectThreshold',
|
|
2325
|
+
ispCityList: 'IspCityList',
|
|
2326
|
+
listenerId: 'ListenerId',
|
|
2327
|
+
optionsJson: 'OptionsJson',
|
|
2328
|
+
regionId: 'RegionId',
|
|
2329
|
+
requestId: 'RequestId',
|
|
2330
|
+
taskId: 'TaskId',
|
|
2331
|
+
taskName: 'TaskName',
|
|
2332
|
+
};
|
|
2333
|
+
}
|
|
2334
|
+
static types() {
|
|
2335
|
+
return {
|
|
2336
|
+
acceleratorId: 'string',
|
|
2337
|
+
address: 'string',
|
|
2338
|
+
detectThreshold: 'string',
|
|
2339
|
+
ispCityList: { 'type': 'array', 'itemType': DescribeApplicationMonitorResponseBodyIspCityList },
|
|
2340
|
+
listenerId: 'string',
|
|
2341
|
+
optionsJson: 'string',
|
|
2342
|
+
regionId: 'string',
|
|
2343
|
+
requestId: 'string',
|
|
2344
|
+
taskId: 'string',
|
|
2345
|
+
taskName: 'string',
|
|
2346
|
+
};
|
|
2347
|
+
}
|
|
2348
|
+
}
|
|
2349
|
+
exports.DescribeApplicationMonitorResponseBody = DescribeApplicationMonitorResponseBody;
|
|
2350
|
+
class DescribeApplicationMonitorResponse extends $tea.Model {
|
|
2351
|
+
constructor(map) {
|
|
2352
|
+
super(map);
|
|
2353
|
+
}
|
|
2354
|
+
static names() {
|
|
2355
|
+
return {
|
|
2356
|
+
headers: 'headers',
|
|
2357
|
+
body: 'body',
|
|
2358
|
+
};
|
|
2359
|
+
}
|
|
2360
|
+
static types() {
|
|
2361
|
+
return {
|
|
2362
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2363
|
+
body: DescribeApplicationMonitorResponseBody,
|
|
2364
|
+
};
|
|
2365
|
+
}
|
|
2366
|
+
}
|
|
2367
|
+
exports.DescribeApplicationMonitorResponse = DescribeApplicationMonitorResponse;
|
|
2176
2368
|
class DescribeBandwidthPackageRequest extends $tea.Model {
|
|
2177
2369
|
constructor(map) {
|
|
2178
2370
|
super(map);
|
|
@@ -2677,51 +2869,43 @@ class DetachLogStoreFromEndpointGroupResponse extends $tea.Model {
|
|
|
2677
2869
|
}
|
|
2678
2870
|
}
|
|
2679
2871
|
exports.DetachLogStoreFromEndpointGroupResponse = DetachLogStoreFromEndpointGroupResponse;
|
|
2680
|
-
class
|
|
2872
|
+
class DetectApplicationMonitorRequest extends $tea.Model {
|
|
2681
2873
|
constructor(map) {
|
|
2682
2874
|
super(map);
|
|
2683
2875
|
}
|
|
2684
2876
|
static names() {
|
|
2685
2877
|
return {
|
|
2686
|
-
aclIds: 'AclIds',
|
|
2687
2878
|
clientToken: 'ClientToken',
|
|
2688
|
-
dryRun: 'DryRun',
|
|
2689
|
-
listenerId: 'ListenerId',
|
|
2690
2879
|
regionId: 'RegionId',
|
|
2880
|
+
taskId: 'TaskId',
|
|
2691
2881
|
};
|
|
2692
2882
|
}
|
|
2693
2883
|
static types() {
|
|
2694
2884
|
return {
|
|
2695
|
-
aclIds: { 'type': 'array', 'itemType': 'string' },
|
|
2696
2885
|
clientToken: 'string',
|
|
2697
|
-
dryRun: 'boolean',
|
|
2698
|
-
listenerId: 'string',
|
|
2699
2886
|
regionId: 'string',
|
|
2887
|
+
taskId: 'string',
|
|
2700
2888
|
};
|
|
2701
2889
|
}
|
|
2702
2890
|
}
|
|
2703
|
-
exports.
|
|
2704
|
-
class
|
|
2891
|
+
exports.DetectApplicationMonitorRequest = DetectApplicationMonitorRequest;
|
|
2892
|
+
class DetectApplicationMonitorResponseBody extends $tea.Model {
|
|
2705
2893
|
constructor(map) {
|
|
2706
2894
|
super(map);
|
|
2707
2895
|
}
|
|
2708
2896
|
static names() {
|
|
2709
2897
|
return {
|
|
2710
|
-
aclIds: 'AclIds',
|
|
2711
|
-
listenerId: 'ListenerId',
|
|
2712
2898
|
requestId: 'RequestId',
|
|
2713
2899
|
};
|
|
2714
2900
|
}
|
|
2715
2901
|
static types() {
|
|
2716
2902
|
return {
|
|
2717
|
-
aclIds: { 'type': 'array', 'itemType': 'string' },
|
|
2718
|
-
listenerId: 'string',
|
|
2719
2903
|
requestId: 'string',
|
|
2720
2904
|
};
|
|
2721
2905
|
}
|
|
2722
2906
|
}
|
|
2723
|
-
exports.
|
|
2724
|
-
class
|
|
2907
|
+
exports.DetectApplicationMonitorResponseBody = DetectApplicationMonitorResponseBody;
|
|
2908
|
+
class DetectApplicationMonitorResponse extends $tea.Model {
|
|
2725
2909
|
constructor(map) {
|
|
2726
2910
|
super(map);
|
|
2727
2911
|
}
|
|
@@ -2734,36 +2918,32 @@ class DissociateAclsFromListenerResponse extends $tea.Model {
|
|
|
2734
2918
|
static types() {
|
|
2735
2919
|
return {
|
|
2736
2920
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2737
|
-
body:
|
|
2921
|
+
body: DetectApplicationMonitorResponseBody,
|
|
2738
2922
|
};
|
|
2739
2923
|
}
|
|
2740
2924
|
}
|
|
2741
|
-
exports.
|
|
2742
|
-
class
|
|
2925
|
+
exports.DetectApplicationMonitorResponse = DetectApplicationMonitorResponse;
|
|
2926
|
+
class DisableApplicationMonitorRequest extends $tea.Model {
|
|
2743
2927
|
constructor(map) {
|
|
2744
2928
|
super(map);
|
|
2745
2929
|
}
|
|
2746
2930
|
static names() {
|
|
2747
2931
|
return {
|
|
2748
|
-
acceleratorId: 'AcceleratorId',
|
|
2749
2932
|
clientToken: 'ClientToken',
|
|
2750
|
-
domains: 'Domains',
|
|
2751
|
-
listenerId: 'ListenerId',
|
|
2752
2933
|
regionId: 'RegionId',
|
|
2934
|
+
taskId: 'TaskId',
|
|
2753
2935
|
};
|
|
2754
2936
|
}
|
|
2755
2937
|
static types() {
|
|
2756
2938
|
return {
|
|
2757
|
-
acceleratorId: 'string',
|
|
2758
2939
|
clientToken: 'string',
|
|
2759
|
-
domains: { 'type': 'array', 'itemType': 'string' },
|
|
2760
|
-
listenerId: 'string',
|
|
2761
2940
|
regionId: 'string',
|
|
2941
|
+
taskId: 'string',
|
|
2762
2942
|
};
|
|
2763
2943
|
}
|
|
2764
2944
|
}
|
|
2765
|
-
exports.
|
|
2766
|
-
class
|
|
2945
|
+
exports.DisableApplicationMonitorRequest = DisableApplicationMonitorRequest;
|
|
2946
|
+
class DisableApplicationMonitorResponseBody extends $tea.Model {
|
|
2767
2947
|
constructor(map) {
|
|
2768
2948
|
super(map);
|
|
2769
2949
|
}
|
|
@@ -2778,8 +2958,8 @@ class DissociateAdditionalCertificatesFromListenerResponseBody extends $tea.Mode
|
|
|
2778
2958
|
};
|
|
2779
2959
|
}
|
|
2780
2960
|
}
|
|
2781
|
-
exports.
|
|
2782
|
-
class
|
|
2961
|
+
exports.DisableApplicationMonitorResponseBody = DisableApplicationMonitorResponseBody;
|
|
2962
|
+
class DisableApplicationMonitorResponse extends $tea.Model {
|
|
2783
2963
|
constructor(map) {
|
|
2784
2964
|
super(map);
|
|
2785
2965
|
}
|
|
@@ -2792,58 +2972,56 @@ class DissociateAdditionalCertificatesFromListenerResponse extends $tea.Model {
|
|
|
2792
2972
|
static types() {
|
|
2793
2973
|
return {
|
|
2794
2974
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2795
|
-
body:
|
|
2975
|
+
body: DisableApplicationMonitorResponseBody,
|
|
2796
2976
|
};
|
|
2797
2977
|
}
|
|
2798
2978
|
}
|
|
2799
|
-
exports.
|
|
2800
|
-
class
|
|
2979
|
+
exports.DisableApplicationMonitorResponse = DisableApplicationMonitorResponse;
|
|
2980
|
+
class DissociateAclsFromListenerRequest extends $tea.Model {
|
|
2801
2981
|
constructor(map) {
|
|
2802
2982
|
super(map);
|
|
2803
2983
|
}
|
|
2804
2984
|
static names() {
|
|
2805
2985
|
return {
|
|
2806
|
-
|
|
2986
|
+
aclIds: 'AclIds',
|
|
2987
|
+
clientToken: 'ClientToken',
|
|
2988
|
+
dryRun: 'DryRun',
|
|
2989
|
+
listenerId: 'ListenerId',
|
|
2807
2990
|
regionId: 'RegionId',
|
|
2808
2991
|
};
|
|
2809
2992
|
}
|
|
2810
2993
|
static types() {
|
|
2811
2994
|
return {
|
|
2812
|
-
|
|
2995
|
+
aclIds: { 'type': 'array', 'itemType': 'string' },
|
|
2996
|
+
clientToken: 'string',
|
|
2997
|
+
dryRun: 'boolean',
|
|
2998
|
+
listenerId: 'string',
|
|
2813
2999
|
regionId: 'string',
|
|
2814
3000
|
};
|
|
2815
3001
|
}
|
|
2816
3002
|
}
|
|
2817
|
-
exports.
|
|
2818
|
-
class
|
|
3003
|
+
exports.DissociateAclsFromListenerRequest = DissociateAclsFromListenerRequest;
|
|
3004
|
+
class DissociateAclsFromListenerResponseBody extends $tea.Model {
|
|
2819
3005
|
constructor(map) {
|
|
2820
3006
|
super(map);
|
|
2821
3007
|
}
|
|
2822
3008
|
static names() {
|
|
2823
3009
|
return {
|
|
2824
|
-
|
|
2825
|
-
|
|
2826
|
-
aclName: 'AclName',
|
|
2827
|
-
aclStatus: 'AclStatus',
|
|
2828
|
-
addressIPVersion: 'AddressIPVersion',
|
|
2829
|
-
relatedListeners: 'RelatedListeners',
|
|
3010
|
+
aclIds: 'AclIds',
|
|
3011
|
+
listenerId: 'ListenerId',
|
|
2830
3012
|
requestId: 'RequestId',
|
|
2831
3013
|
};
|
|
2832
3014
|
}
|
|
2833
3015
|
static types() {
|
|
2834
3016
|
return {
|
|
2835
|
-
|
|
2836
|
-
|
|
2837
|
-
aclName: 'string',
|
|
2838
|
-
aclStatus: 'string',
|
|
2839
|
-
addressIPVersion: 'string',
|
|
2840
|
-
relatedListeners: { 'type': 'array', 'itemType': GetAclResponseBodyRelatedListeners },
|
|
3017
|
+
aclIds: { 'type': 'array', 'itemType': 'string' },
|
|
3018
|
+
listenerId: 'string',
|
|
2841
3019
|
requestId: 'string',
|
|
2842
3020
|
};
|
|
2843
3021
|
}
|
|
2844
3022
|
}
|
|
2845
|
-
exports.
|
|
2846
|
-
class
|
|
3023
|
+
exports.DissociateAclsFromListenerResponseBody = DissociateAclsFromListenerResponseBody;
|
|
3024
|
+
class DissociateAclsFromListenerResponse extends $tea.Model {
|
|
2847
3025
|
constructor(map) {
|
|
2848
3026
|
super(map);
|
|
2849
3027
|
}
|
|
@@ -2856,65 +3034,241 @@ class GetAclResponse extends $tea.Model {
|
|
|
2856
3034
|
static types() {
|
|
2857
3035
|
return {
|
|
2858
3036
|
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
2859
|
-
body:
|
|
3037
|
+
body: DissociateAclsFromListenerResponseBody,
|
|
2860
3038
|
};
|
|
2861
3039
|
}
|
|
2862
3040
|
}
|
|
2863
|
-
exports.
|
|
2864
|
-
class
|
|
3041
|
+
exports.DissociateAclsFromListenerResponse = DissociateAclsFromListenerResponse;
|
|
3042
|
+
class DissociateAdditionalCertificatesFromListenerRequest extends $tea.Model {
|
|
2865
3043
|
constructor(map) {
|
|
2866
3044
|
super(map);
|
|
2867
3045
|
}
|
|
2868
3046
|
static names() {
|
|
2869
3047
|
return {
|
|
2870
3048
|
acceleratorId: 'AcceleratorId',
|
|
3049
|
+
clientToken: 'ClientToken',
|
|
3050
|
+
domains: 'Domains',
|
|
3051
|
+
listenerId: 'ListenerId',
|
|
2871
3052
|
regionId: 'RegionId',
|
|
2872
3053
|
};
|
|
2873
3054
|
}
|
|
2874
3055
|
static types() {
|
|
2875
3056
|
return {
|
|
2876
3057
|
acceleratorId: 'string',
|
|
3058
|
+
clientToken: 'string',
|
|
3059
|
+
domains: { 'type': 'array', 'itemType': 'string' },
|
|
3060
|
+
listenerId: 'string',
|
|
2877
3061
|
regionId: 'string',
|
|
2878
3062
|
};
|
|
2879
3063
|
}
|
|
2880
3064
|
}
|
|
2881
|
-
exports.
|
|
2882
|
-
class
|
|
3065
|
+
exports.DissociateAdditionalCertificatesFromListenerRequest = DissociateAdditionalCertificatesFromListenerRequest;
|
|
3066
|
+
class DissociateAdditionalCertificatesFromListenerResponseBody extends $tea.Model {
|
|
2883
3067
|
constructor(map) {
|
|
2884
3068
|
super(map);
|
|
2885
3069
|
}
|
|
2886
3070
|
static names() {
|
|
2887
3071
|
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
3072
|
requestId: 'RequestId',
|
|
2901
|
-
state: 'State',
|
|
2902
3073
|
};
|
|
2903
3074
|
}
|
|
2904
3075
|
static types() {
|
|
2905
3076
|
return {
|
|
2906
|
-
|
|
2907
|
-
|
|
2908
|
-
|
|
2909
|
-
|
|
2910
|
-
|
|
2911
|
-
|
|
2912
|
-
|
|
2913
|
-
|
|
2914
|
-
|
|
2915
|
-
|
|
2916
|
-
|
|
2917
|
-
|
|
3077
|
+
requestId: 'string',
|
|
3078
|
+
};
|
|
3079
|
+
}
|
|
3080
|
+
}
|
|
3081
|
+
exports.DissociateAdditionalCertificatesFromListenerResponseBody = DissociateAdditionalCertificatesFromListenerResponseBody;
|
|
3082
|
+
class DissociateAdditionalCertificatesFromListenerResponse extends $tea.Model {
|
|
3083
|
+
constructor(map) {
|
|
3084
|
+
super(map);
|
|
3085
|
+
}
|
|
3086
|
+
static names() {
|
|
3087
|
+
return {
|
|
3088
|
+
headers: 'headers',
|
|
3089
|
+
body: 'body',
|
|
3090
|
+
};
|
|
3091
|
+
}
|
|
3092
|
+
static types() {
|
|
3093
|
+
return {
|
|
3094
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3095
|
+
body: DissociateAdditionalCertificatesFromListenerResponseBody,
|
|
3096
|
+
};
|
|
3097
|
+
}
|
|
3098
|
+
}
|
|
3099
|
+
exports.DissociateAdditionalCertificatesFromListenerResponse = DissociateAdditionalCertificatesFromListenerResponse;
|
|
3100
|
+
class EnableApplicationMonitorRequest extends $tea.Model {
|
|
3101
|
+
constructor(map) {
|
|
3102
|
+
super(map);
|
|
3103
|
+
}
|
|
3104
|
+
static names() {
|
|
3105
|
+
return {
|
|
3106
|
+
clientToken: 'ClientToken',
|
|
3107
|
+
regionId: 'RegionId',
|
|
3108
|
+
taskId: 'TaskId',
|
|
3109
|
+
};
|
|
3110
|
+
}
|
|
3111
|
+
static types() {
|
|
3112
|
+
return {
|
|
3113
|
+
clientToken: 'string',
|
|
3114
|
+
regionId: 'string',
|
|
3115
|
+
taskId: 'string',
|
|
3116
|
+
};
|
|
3117
|
+
}
|
|
3118
|
+
}
|
|
3119
|
+
exports.EnableApplicationMonitorRequest = EnableApplicationMonitorRequest;
|
|
3120
|
+
class EnableApplicationMonitorResponseBody extends $tea.Model {
|
|
3121
|
+
constructor(map) {
|
|
3122
|
+
super(map);
|
|
3123
|
+
}
|
|
3124
|
+
static names() {
|
|
3125
|
+
return {
|
|
3126
|
+
requestId: 'RequestId',
|
|
3127
|
+
};
|
|
3128
|
+
}
|
|
3129
|
+
static types() {
|
|
3130
|
+
return {
|
|
3131
|
+
requestId: 'string',
|
|
3132
|
+
};
|
|
3133
|
+
}
|
|
3134
|
+
}
|
|
3135
|
+
exports.EnableApplicationMonitorResponseBody = EnableApplicationMonitorResponseBody;
|
|
3136
|
+
class EnableApplicationMonitorResponse extends $tea.Model {
|
|
3137
|
+
constructor(map) {
|
|
3138
|
+
super(map);
|
|
3139
|
+
}
|
|
3140
|
+
static names() {
|
|
3141
|
+
return {
|
|
3142
|
+
headers: 'headers',
|
|
3143
|
+
body: 'body',
|
|
3144
|
+
};
|
|
3145
|
+
}
|
|
3146
|
+
static types() {
|
|
3147
|
+
return {
|
|
3148
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3149
|
+
body: EnableApplicationMonitorResponseBody,
|
|
3150
|
+
};
|
|
3151
|
+
}
|
|
3152
|
+
}
|
|
3153
|
+
exports.EnableApplicationMonitorResponse = EnableApplicationMonitorResponse;
|
|
3154
|
+
class GetAclRequest extends $tea.Model {
|
|
3155
|
+
constructor(map) {
|
|
3156
|
+
super(map);
|
|
3157
|
+
}
|
|
3158
|
+
static names() {
|
|
3159
|
+
return {
|
|
3160
|
+
aclId: 'AclId',
|
|
3161
|
+
regionId: 'RegionId',
|
|
3162
|
+
};
|
|
3163
|
+
}
|
|
3164
|
+
static types() {
|
|
3165
|
+
return {
|
|
3166
|
+
aclId: 'string',
|
|
3167
|
+
regionId: 'string',
|
|
3168
|
+
};
|
|
3169
|
+
}
|
|
3170
|
+
}
|
|
3171
|
+
exports.GetAclRequest = GetAclRequest;
|
|
3172
|
+
class GetAclResponseBody extends $tea.Model {
|
|
3173
|
+
constructor(map) {
|
|
3174
|
+
super(map);
|
|
3175
|
+
}
|
|
3176
|
+
static names() {
|
|
3177
|
+
return {
|
|
3178
|
+
aclEntries: 'AclEntries',
|
|
3179
|
+
aclId: 'AclId',
|
|
3180
|
+
aclName: 'AclName',
|
|
3181
|
+
aclStatus: 'AclStatus',
|
|
3182
|
+
addressIPVersion: 'AddressIPVersion',
|
|
3183
|
+
relatedListeners: 'RelatedListeners',
|
|
3184
|
+
requestId: 'RequestId',
|
|
3185
|
+
};
|
|
3186
|
+
}
|
|
3187
|
+
static types() {
|
|
3188
|
+
return {
|
|
3189
|
+
aclEntries: { 'type': 'array', 'itemType': GetAclResponseBodyAclEntries },
|
|
3190
|
+
aclId: 'string',
|
|
3191
|
+
aclName: 'string',
|
|
3192
|
+
aclStatus: 'string',
|
|
3193
|
+
addressIPVersion: 'string',
|
|
3194
|
+
relatedListeners: { 'type': 'array', 'itemType': GetAclResponseBodyRelatedListeners },
|
|
3195
|
+
requestId: 'string',
|
|
3196
|
+
};
|
|
3197
|
+
}
|
|
3198
|
+
}
|
|
3199
|
+
exports.GetAclResponseBody = GetAclResponseBody;
|
|
3200
|
+
class GetAclResponse extends $tea.Model {
|
|
3201
|
+
constructor(map) {
|
|
3202
|
+
super(map);
|
|
3203
|
+
}
|
|
3204
|
+
static names() {
|
|
3205
|
+
return {
|
|
3206
|
+
headers: 'headers',
|
|
3207
|
+
body: 'body',
|
|
3208
|
+
};
|
|
3209
|
+
}
|
|
3210
|
+
static types() {
|
|
3211
|
+
return {
|
|
3212
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3213
|
+
body: GetAclResponseBody,
|
|
3214
|
+
};
|
|
3215
|
+
}
|
|
3216
|
+
}
|
|
3217
|
+
exports.GetAclResponse = GetAclResponse;
|
|
3218
|
+
class GetBasicAcceleratorRequest extends $tea.Model {
|
|
3219
|
+
constructor(map) {
|
|
3220
|
+
super(map);
|
|
3221
|
+
}
|
|
3222
|
+
static names() {
|
|
3223
|
+
return {
|
|
3224
|
+
acceleratorId: 'AcceleratorId',
|
|
3225
|
+
regionId: 'RegionId',
|
|
3226
|
+
};
|
|
3227
|
+
}
|
|
3228
|
+
static types() {
|
|
3229
|
+
return {
|
|
3230
|
+
acceleratorId: 'string',
|
|
3231
|
+
regionId: 'string',
|
|
3232
|
+
};
|
|
3233
|
+
}
|
|
3234
|
+
}
|
|
3235
|
+
exports.GetBasicAcceleratorRequest = GetBasicAcceleratorRequest;
|
|
3236
|
+
class GetBasicAcceleratorResponseBody extends $tea.Model {
|
|
3237
|
+
constructor(map) {
|
|
3238
|
+
super(map);
|
|
3239
|
+
}
|
|
3240
|
+
static names() {
|
|
3241
|
+
return {
|
|
3242
|
+
acceleratorId: 'AcceleratorId',
|
|
3243
|
+
basicBandwidthPackage: 'BasicBandwidthPackage',
|
|
3244
|
+
basicEndpointGroupId: 'BasicEndpointGroupId',
|
|
3245
|
+
basicIpSetId: 'BasicIpSetId',
|
|
3246
|
+
cenId: 'CenId',
|
|
3247
|
+
createTime: 'CreateTime',
|
|
3248
|
+
crossDomainBandwidthPackage: 'CrossDomainBandwidthPackage',
|
|
3249
|
+
description: 'Description',
|
|
3250
|
+
expiredTime: 'ExpiredTime',
|
|
3251
|
+
instanceChargeType: 'InstanceChargeType',
|
|
3252
|
+
name: 'Name',
|
|
3253
|
+
regionId: 'RegionId',
|
|
3254
|
+
requestId: 'RequestId',
|
|
3255
|
+
state: 'State',
|
|
3256
|
+
};
|
|
3257
|
+
}
|
|
3258
|
+
static types() {
|
|
3259
|
+
return {
|
|
3260
|
+
acceleratorId: 'string',
|
|
3261
|
+
basicBandwidthPackage: GetBasicAcceleratorResponseBodyBasicBandwidthPackage,
|
|
3262
|
+
basicEndpointGroupId: 'string',
|
|
3263
|
+
basicIpSetId: 'string',
|
|
3264
|
+
cenId: 'string',
|
|
3265
|
+
createTime: 'number',
|
|
3266
|
+
crossDomainBandwidthPackage: GetBasicAcceleratorResponseBodyCrossDomainBandwidthPackage,
|
|
3267
|
+
description: 'string',
|
|
3268
|
+
expiredTime: 'number',
|
|
3269
|
+
instanceChargeType: 'string',
|
|
3270
|
+
name: 'string',
|
|
3271
|
+
regionId: 'string',
|
|
2918
3272
|
requestId: 'string',
|
|
2919
3273
|
state: 'string',
|
|
2920
3274
|
};
|
|
@@ -3387,6 +3741,138 @@ class ListAclsResponse extends $tea.Model {
|
|
|
3387
3741
|
}
|
|
3388
3742
|
}
|
|
3389
3743
|
exports.ListAclsResponse = ListAclsResponse;
|
|
3744
|
+
class ListApplicationMonitorRequest extends $tea.Model {
|
|
3745
|
+
constructor(map) {
|
|
3746
|
+
super(map);
|
|
3747
|
+
}
|
|
3748
|
+
static names() {
|
|
3749
|
+
return {
|
|
3750
|
+
pageNumber: 'PageNumber',
|
|
3751
|
+
pageSize: 'PageSize',
|
|
3752
|
+
regionId: 'RegionId',
|
|
3753
|
+
searchValue: 'SearchValue',
|
|
3754
|
+
};
|
|
3755
|
+
}
|
|
3756
|
+
static types() {
|
|
3757
|
+
return {
|
|
3758
|
+
pageNumber: 'number',
|
|
3759
|
+
pageSize: 'number',
|
|
3760
|
+
regionId: 'string',
|
|
3761
|
+
searchValue: 'string',
|
|
3762
|
+
};
|
|
3763
|
+
}
|
|
3764
|
+
}
|
|
3765
|
+
exports.ListApplicationMonitorRequest = ListApplicationMonitorRequest;
|
|
3766
|
+
class ListApplicationMonitorResponseBody extends $tea.Model {
|
|
3767
|
+
constructor(map) {
|
|
3768
|
+
super(map);
|
|
3769
|
+
}
|
|
3770
|
+
static names() {
|
|
3771
|
+
return {
|
|
3772
|
+
applicationMonitors: 'ApplicationMonitors',
|
|
3773
|
+
pageNumber: 'PageNumber',
|
|
3774
|
+
pageSize: 'PageSize',
|
|
3775
|
+
requestId: 'RequestId',
|
|
3776
|
+
totalCount: 'TotalCount',
|
|
3777
|
+
};
|
|
3778
|
+
}
|
|
3779
|
+
static types() {
|
|
3780
|
+
return {
|
|
3781
|
+
applicationMonitors: { 'type': 'array', 'itemType': ListApplicationMonitorResponseBodyApplicationMonitors },
|
|
3782
|
+
pageNumber: 'number',
|
|
3783
|
+
pageSize: 'number',
|
|
3784
|
+
requestId: 'string',
|
|
3785
|
+
totalCount: 'number',
|
|
3786
|
+
};
|
|
3787
|
+
}
|
|
3788
|
+
}
|
|
3789
|
+
exports.ListApplicationMonitorResponseBody = ListApplicationMonitorResponseBody;
|
|
3790
|
+
class ListApplicationMonitorResponse extends $tea.Model {
|
|
3791
|
+
constructor(map) {
|
|
3792
|
+
super(map);
|
|
3793
|
+
}
|
|
3794
|
+
static names() {
|
|
3795
|
+
return {
|
|
3796
|
+
headers: 'headers',
|
|
3797
|
+
body: 'body',
|
|
3798
|
+
};
|
|
3799
|
+
}
|
|
3800
|
+
static types() {
|
|
3801
|
+
return {
|
|
3802
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3803
|
+
body: ListApplicationMonitorResponseBody,
|
|
3804
|
+
};
|
|
3805
|
+
}
|
|
3806
|
+
}
|
|
3807
|
+
exports.ListApplicationMonitorResponse = ListApplicationMonitorResponse;
|
|
3808
|
+
class ListApplicationMonitorDetectResultRequest extends $tea.Model {
|
|
3809
|
+
constructor(map) {
|
|
3810
|
+
super(map);
|
|
3811
|
+
}
|
|
3812
|
+
static names() {
|
|
3813
|
+
return {
|
|
3814
|
+
beginTime: 'BeginTime',
|
|
3815
|
+
endTime: 'EndTime',
|
|
3816
|
+
pageNumber: 'PageNumber',
|
|
3817
|
+
pageSize: 'PageSize',
|
|
3818
|
+
regionId: 'RegionId',
|
|
3819
|
+
taskId: 'TaskId',
|
|
3820
|
+
};
|
|
3821
|
+
}
|
|
3822
|
+
static types() {
|
|
3823
|
+
return {
|
|
3824
|
+
beginTime: 'number',
|
|
3825
|
+
endTime: 'number',
|
|
3826
|
+
pageNumber: 'number',
|
|
3827
|
+
pageSize: 'number',
|
|
3828
|
+
regionId: 'string',
|
|
3829
|
+
taskId: 'string',
|
|
3830
|
+
};
|
|
3831
|
+
}
|
|
3832
|
+
}
|
|
3833
|
+
exports.ListApplicationMonitorDetectResultRequest = ListApplicationMonitorDetectResultRequest;
|
|
3834
|
+
class ListApplicationMonitorDetectResultResponseBody extends $tea.Model {
|
|
3835
|
+
constructor(map) {
|
|
3836
|
+
super(map);
|
|
3837
|
+
}
|
|
3838
|
+
static names() {
|
|
3839
|
+
return {
|
|
3840
|
+
applicationMonitorDetectResultList: 'ApplicationMonitorDetectResultList',
|
|
3841
|
+
pageNumber: 'PageNumber',
|
|
3842
|
+
pageSize: 'PageSize',
|
|
3843
|
+
requestId: 'RequestId',
|
|
3844
|
+
totalCount: 'TotalCount',
|
|
3845
|
+
};
|
|
3846
|
+
}
|
|
3847
|
+
static types() {
|
|
3848
|
+
return {
|
|
3849
|
+
applicationMonitorDetectResultList: { 'type': 'array', 'itemType': ListApplicationMonitorDetectResultResponseBodyApplicationMonitorDetectResultList },
|
|
3850
|
+
pageNumber: 'number',
|
|
3851
|
+
pageSize: 'number',
|
|
3852
|
+
requestId: 'string',
|
|
3853
|
+
totalCount: 'number',
|
|
3854
|
+
};
|
|
3855
|
+
}
|
|
3856
|
+
}
|
|
3857
|
+
exports.ListApplicationMonitorDetectResultResponseBody = ListApplicationMonitorDetectResultResponseBody;
|
|
3858
|
+
class ListApplicationMonitorDetectResultResponse extends $tea.Model {
|
|
3859
|
+
constructor(map) {
|
|
3860
|
+
super(map);
|
|
3861
|
+
}
|
|
3862
|
+
static names() {
|
|
3863
|
+
return {
|
|
3864
|
+
headers: 'headers',
|
|
3865
|
+
body: 'body',
|
|
3866
|
+
};
|
|
3867
|
+
}
|
|
3868
|
+
static types() {
|
|
3869
|
+
return {
|
|
3870
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
3871
|
+
body: ListApplicationMonitorDetectResultResponseBody,
|
|
3872
|
+
};
|
|
3873
|
+
}
|
|
3874
|
+
}
|
|
3875
|
+
exports.ListApplicationMonitorDetectResultResponse = ListApplicationMonitorDetectResultResponse;
|
|
3390
3876
|
class ListAvailableAccelerateAreasRequest extends $tea.Model {
|
|
3391
3877
|
constructor(map) {
|
|
3392
3878
|
super(map);
|
|
@@ -4555,6 +5041,70 @@ class UpdateAclAttributeResponse extends $tea.Model {
|
|
|
4555
5041
|
}
|
|
4556
5042
|
}
|
|
4557
5043
|
exports.UpdateAclAttributeResponse = UpdateAclAttributeResponse;
|
|
5044
|
+
class UpdateApplicationMonitorRequest extends $tea.Model {
|
|
5045
|
+
constructor(map) {
|
|
5046
|
+
super(map);
|
|
5047
|
+
}
|
|
5048
|
+
static names() {
|
|
5049
|
+
return {
|
|
5050
|
+
address: 'Address',
|
|
5051
|
+
clientToken: 'ClientToken',
|
|
5052
|
+
detectThreshold: 'DetectThreshold',
|
|
5053
|
+
listenerId: 'ListenerId',
|
|
5054
|
+
optionsJson: 'OptionsJson',
|
|
5055
|
+
regionId: 'RegionId',
|
|
5056
|
+
taskId: 'TaskId',
|
|
5057
|
+
taskName: 'TaskName',
|
|
5058
|
+
};
|
|
5059
|
+
}
|
|
5060
|
+
static types() {
|
|
5061
|
+
return {
|
|
5062
|
+
address: 'string',
|
|
5063
|
+
clientToken: 'string',
|
|
5064
|
+
detectThreshold: 'number',
|
|
5065
|
+
listenerId: 'string',
|
|
5066
|
+
optionsJson: 'string',
|
|
5067
|
+
regionId: 'string',
|
|
5068
|
+
taskId: 'string',
|
|
5069
|
+
taskName: 'string',
|
|
5070
|
+
};
|
|
5071
|
+
}
|
|
5072
|
+
}
|
|
5073
|
+
exports.UpdateApplicationMonitorRequest = UpdateApplicationMonitorRequest;
|
|
5074
|
+
class UpdateApplicationMonitorResponseBody extends $tea.Model {
|
|
5075
|
+
constructor(map) {
|
|
5076
|
+
super(map);
|
|
5077
|
+
}
|
|
5078
|
+
static names() {
|
|
5079
|
+
return {
|
|
5080
|
+
requestId: 'RequestId',
|
|
5081
|
+
};
|
|
5082
|
+
}
|
|
5083
|
+
static types() {
|
|
5084
|
+
return {
|
|
5085
|
+
requestId: 'string',
|
|
5086
|
+
};
|
|
5087
|
+
}
|
|
5088
|
+
}
|
|
5089
|
+
exports.UpdateApplicationMonitorResponseBody = UpdateApplicationMonitorResponseBody;
|
|
5090
|
+
class UpdateApplicationMonitorResponse extends $tea.Model {
|
|
5091
|
+
constructor(map) {
|
|
5092
|
+
super(map);
|
|
5093
|
+
}
|
|
5094
|
+
static names() {
|
|
5095
|
+
return {
|
|
5096
|
+
headers: 'headers',
|
|
5097
|
+
body: 'body',
|
|
5098
|
+
};
|
|
5099
|
+
}
|
|
5100
|
+
static types() {
|
|
5101
|
+
return {
|
|
5102
|
+
headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
|
|
5103
|
+
body: UpdateApplicationMonitorResponseBody,
|
|
5104
|
+
};
|
|
5105
|
+
}
|
|
5106
|
+
}
|
|
5107
|
+
exports.UpdateApplicationMonitorResponse = UpdateApplicationMonitorResponse;
|
|
4558
5108
|
class UpdateBandwidthPackageRequest extends $tea.Model {
|
|
4559
5109
|
constructor(map) {
|
|
4560
5110
|
super(map);
|
|
@@ -5657,6 +6207,28 @@ class DescribeAcceleratorResponseBodyCrossDomainBandwidthPackage extends $tea.Mo
|
|
|
5657
6207
|
}
|
|
5658
6208
|
}
|
|
5659
6209
|
exports.DescribeAcceleratorResponseBodyCrossDomainBandwidthPackage = DescribeAcceleratorResponseBodyCrossDomainBandwidthPackage;
|
|
6210
|
+
class DescribeApplicationMonitorResponseBodyIspCityList extends $tea.Model {
|
|
6211
|
+
constructor(map) {
|
|
6212
|
+
super(map);
|
|
6213
|
+
}
|
|
6214
|
+
static names() {
|
|
6215
|
+
return {
|
|
6216
|
+
city: 'City',
|
|
6217
|
+
cityName: 'CityName',
|
|
6218
|
+
isp: 'Isp',
|
|
6219
|
+
ispName: 'IspName',
|
|
6220
|
+
};
|
|
6221
|
+
}
|
|
6222
|
+
static types() {
|
|
6223
|
+
return {
|
|
6224
|
+
city: 'string',
|
|
6225
|
+
cityName: 'string',
|
|
6226
|
+
isp: 'string',
|
|
6227
|
+
ispName: 'string',
|
|
6228
|
+
};
|
|
6229
|
+
}
|
|
6230
|
+
}
|
|
6231
|
+
exports.DescribeApplicationMonitorResponseBodyIspCityList = DescribeApplicationMonitorResponseBodyIspCityList;
|
|
5660
6232
|
class DescribeEndpointGroupResponseBodyEndpointConfigurations extends $tea.Model {
|
|
5661
6233
|
constructor(map) {
|
|
5662
6234
|
super(map);
|
|
@@ -6087,6 +6659,64 @@ class ListAclsResponseBodyAcls extends $tea.Model {
|
|
|
6087
6659
|
}
|
|
6088
6660
|
}
|
|
6089
6661
|
exports.ListAclsResponseBodyAcls = ListAclsResponseBodyAcls;
|
|
6662
|
+
class ListApplicationMonitorResponseBodyApplicationMonitors extends $tea.Model {
|
|
6663
|
+
constructor(map) {
|
|
6664
|
+
super(map);
|
|
6665
|
+
}
|
|
6666
|
+
static names() {
|
|
6667
|
+
return {
|
|
6668
|
+
acceleratorId: 'AcceleratorId',
|
|
6669
|
+
address: 'Address',
|
|
6670
|
+
detectThreshold: 'DetectThreshold',
|
|
6671
|
+
listenerId: 'ListenerId',
|
|
6672
|
+
optionsJson: 'OptionsJson',
|
|
6673
|
+
state: 'State',
|
|
6674
|
+
taskId: 'TaskId',
|
|
6675
|
+
taskName: 'TaskName',
|
|
6676
|
+
};
|
|
6677
|
+
}
|
|
6678
|
+
static types() {
|
|
6679
|
+
return {
|
|
6680
|
+
acceleratorId: 'string',
|
|
6681
|
+
address: 'string',
|
|
6682
|
+
detectThreshold: 'number',
|
|
6683
|
+
listenerId: 'string',
|
|
6684
|
+
optionsJson: 'string',
|
|
6685
|
+
state: 'string',
|
|
6686
|
+
taskId: 'string',
|
|
6687
|
+
taskName: 'string',
|
|
6688
|
+
};
|
|
6689
|
+
}
|
|
6690
|
+
}
|
|
6691
|
+
exports.ListApplicationMonitorResponseBodyApplicationMonitors = ListApplicationMonitorResponseBodyApplicationMonitors;
|
|
6692
|
+
class ListApplicationMonitorDetectResultResponseBodyApplicationMonitorDetectResultList extends $tea.Model {
|
|
6693
|
+
constructor(map) {
|
|
6694
|
+
super(map);
|
|
6695
|
+
}
|
|
6696
|
+
static names() {
|
|
6697
|
+
return {
|
|
6698
|
+
acceleratorId: 'AcceleratorId',
|
|
6699
|
+
detail: 'Detail',
|
|
6700
|
+
diagStatus: 'DiagStatus',
|
|
6701
|
+
listenerId: 'ListenerId',
|
|
6702
|
+
port: 'Port',
|
|
6703
|
+
protocol: 'Protocol',
|
|
6704
|
+
taskId: 'TaskId',
|
|
6705
|
+
};
|
|
6706
|
+
}
|
|
6707
|
+
static types() {
|
|
6708
|
+
return {
|
|
6709
|
+
acceleratorId: 'string',
|
|
6710
|
+
detail: 'string',
|
|
6711
|
+
diagStatus: 'string',
|
|
6712
|
+
listenerId: 'string',
|
|
6713
|
+
port: 'string',
|
|
6714
|
+
protocol: 'string',
|
|
6715
|
+
taskId: 'string',
|
|
6716
|
+
};
|
|
6717
|
+
}
|
|
6718
|
+
}
|
|
6719
|
+
exports.ListApplicationMonitorDetectResultResponseBodyApplicationMonitorDetectResultList = ListApplicationMonitorDetectResultResponseBodyApplicationMonitorDetectResultList;
|
|
6090
6720
|
class ListAvailableAccelerateAreasResponseBodyAreasRegionList extends $tea.Model {
|
|
6091
6721
|
constructor(map) {
|
|
6092
6722
|
super(map);
|
|
@@ -7154,11 +7784,21 @@ class Client extends openapi_client_1.default {
|
|
|
7154
7784
|
async addEntriesToAclWithOptions(request, runtime) {
|
|
7155
7785
|
tea_util_1.default.validateModel(request);
|
|
7156
7786
|
let query = {};
|
|
7157
|
-
|
|
7158
|
-
|
|
7159
|
-
|
|
7160
|
-
|
|
7161
|
-
|
|
7787
|
+
if (!tea_util_1.default.isUnset(request.aclEntries)) {
|
|
7788
|
+
query["AclEntries"] = request.aclEntries;
|
|
7789
|
+
}
|
|
7790
|
+
if (!tea_util_1.default.isUnset(request.aclId)) {
|
|
7791
|
+
query["AclId"] = request.aclId;
|
|
7792
|
+
}
|
|
7793
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
7794
|
+
query["ClientToken"] = request.clientToken;
|
|
7795
|
+
}
|
|
7796
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
7797
|
+
query["DryRun"] = request.dryRun;
|
|
7798
|
+
}
|
|
7799
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
7800
|
+
query["RegionId"] = request.regionId;
|
|
7801
|
+
}
|
|
7162
7802
|
let req = new $OpenApi.OpenApiRequest({
|
|
7163
7803
|
query: openapi_util_1.default.query(query),
|
|
7164
7804
|
});
|
|
@@ -7182,12 +7822,24 @@ class Client extends openapi_client_1.default {
|
|
|
7182
7822
|
async associateAclsWithListenerWithOptions(request, runtime) {
|
|
7183
7823
|
tea_util_1.default.validateModel(request);
|
|
7184
7824
|
let query = {};
|
|
7185
|
-
|
|
7186
|
-
|
|
7187
|
-
|
|
7188
|
-
|
|
7189
|
-
|
|
7190
|
-
|
|
7825
|
+
if (!tea_util_1.default.isUnset(request.aclIds)) {
|
|
7826
|
+
query["AclIds"] = request.aclIds;
|
|
7827
|
+
}
|
|
7828
|
+
if (!tea_util_1.default.isUnset(request.aclType)) {
|
|
7829
|
+
query["AclType"] = request.aclType;
|
|
7830
|
+
}
|
|
7831
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
7832
|
+
query["ClientToken"] = request.clientToken;
|
|
7833
|
+
}
|
|
7834
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
7835
|
+
query["DryRun"] = request.dryRun;
|
|
7836
|
+
}
|
|
7837
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
7838
|
+
query["ListenerId"] = request.listenerId;
|
|
7839
|
+
}
|
|
7840
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
7841
|
+
query["RegionId"] = request.regionId;
|
|
7842
|
+
}
|
|
7191
7843
|
let req = new $OpenApi.OpenApiRequest({
|
|
7192
7844
|
query: openapi_util_1.default.query(query),
|
|
7193
7845
|
});
|
|
@@ -7211,11 +7863,21 @@ class Client extends openapi_client_1.default {
|
|
|
7211
7863
|
async associateAdditionalCertificatesWithListenerWithOptions(request, runtime) {
|
|
7212
7864
|
tea_util_1.default.validateModel(request);
|
|
7213
7865
|
let query = {};
|
|
7214
|
-
|
|
7215
|
-
|
|
7216
|
-
|
|
7217
|
-
|
|
7218
|
-
|
|
7866
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
7867
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
7868
|
+
}
|
|
7869
|
+
if (!tea_util_1.default.isUnset(request.certificates)) {
|
|
7870
|
+
query["Certificates"] = request.certificates;
|
|
7871
|
+
}
|
|
7872
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
7873
|
+
query["ClientToken"] = request.clientToken;
|
|
7874
|
+
}
|
|
7875
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
7876
|
+
query["ListenerId"] = request.listenerId;
|
|
7877
|
+
}
|
|
7878
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
7879
|
+
query["RegionId"] = request.regionId;
|
|
7880
|
+
}
|
|
7219
7881
|
let req = new $OpenApi.OpenApiRequest({
|
|
7220
7882
|
query: openapi_util_1.default.query(query),
|
|
7221
7883
|
});
|
|
@@ -7239,10 +7901,18 @@ class Client extends openapi_client_1.default {
|
|
|
7239
7901
|
async attachDdosToAcceleratorWithOptions(request, runtime) {
|
|
7240
7902
|
tea_util_1.default.validateModel(request);
|
|
7241
7903
|
let query = {};
|
|
7242
|
-
|
|
7243
|
-
|
|
7244
|
-
|
|
7245
|
-
|
|
7904
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
7905
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
7906
|
+
}
|
|
7907
|
+
if (!tea_util_1.default.isUnset(request.ddosId)) {
|
|
7908
|
+
query["DdosId"] = request.ddosId;
|
|
7909
|
+
}
|
|
7910
|
+
if (!tea_util_1.default.isUnset(request.ddosRegionId)) {
|
|
7911
|
+
query["DdosRegionId"] = request.ddosRegionId;
|
|
7912
|
+
}
|
|
7913
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
7914
|
+
query["RegionId"] = request.regionId;
|
|
7915
|
+
}
|
|
7246
7916
|
let req = new $OpenApi.OpenApiRequest({
|
|
7247
7917
|
query: openapi_util_1.default.query(query),
|
|
7248
7918
|
});
|
|
@@ -7266,14 +7936,30 @@ class Client extends openapi_client_1.default {
|
|
|
7266
7936
|
async attachLogStoreToEndpointGroupWithOptions(request, runtime) {
|
|
7267
7937
|
tea_util_1.default.validateModel(request);
|
|
7268
7938
|
let query = {};
|
|
7269
|
-
|
|
7270
|
-
|
|
7271
|
-
|
|
7272
|
-
|
|
7273
|
-
|
|
7274
|
-
|
|
7275
|
-
|
|
7276
|
-
|
|
7939
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
7940
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
7941
|
+
}
|
|
7942
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
7943
|
+
query["ClientToken"] = request.clientToken;
|
|
7944
|
+
}
|
|
7945
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupIds)) {
|
|
7946
|
+
query["EndpointGroupIds"] = request.endpointGroupIds;
|
|
7947
|
+
}
|
|
7948
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
7949
|
+
query["ListenerId"] = request.listenerId;
|
|
7950
|
+
}
|
|
7951
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
7952
|
+
query["RegionId"] = request.regionId;
|
|
7953
|
+
}
|
|
7954
|
+
if (!tea_util_1.default.isUnset(request.slsLogStoreName)) {
|
|
7955
|
+
query["SlsLogStoreName"] = request.slsLogStoreName;
|
|
7956
|
+
}
|
|
7957
|
+
if (!tea_util_1.default.isUnset(request.slsProjectName)) {
|
|
7958
|
+
query["SlsProjectName"] = request.slsProjectName;
|
|
7959
|
+
}
|
|
7960
|
+
if (!tea_util_1.default.isUnset(request.slsRegionId)) {
|
|
7961
|
+
query["SlsRegionId"] = request.slsRegionId;
|
|
7962
|
+
}
|
|
7277
7963
|
let req = new $OpenApi.OpenApiRequest({
|
|
7278
7964
|
query: openapi_util_1.default.query(query),
|
|
7279
7965
|
});
|
|
@@ -7297,9 +7983,15 @@ class Client extends openapi_client_1.default {
|
|
|
7297
7983
|
async bandwidthPackageAddAcceleratorWithOptions(request, runtime) {
|
|
7298
7984
|
tea_util_1.default.validateModel(request);
|
|
7299
7985
|
let query = {};
|
|
7300
|
-
|
|
7301
|
-
|
|
7302
|
-
|
|
7986
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
7987
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
7988
|
+
}
|
|
7989
|
+
if (!tea_util_1.default.isUnset(request.bandwidthPackageId)) {
|
|
7990
|
+
query["BandwidthPackageId"] = request.bandwidthPackageId;
|
|
7991
|
+
}
|
|
7992
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
7993
|
+
query["RegionId"] = request.regionId;
|
|
7994
|
+
}
|
|
7303
7995
|
let req = new $OpenApi.OpenApiRequest({
|
|
7304
7996
|
query: openapi_util_1.default.query(query),
|
|
7305
7997
|
});
|
|
@@ -7323,9 +8015,15 @@ class Client extends openapi_client_1.default {
|
|
|
7323
8015
|
async bandwidthPackageRemoveAcceleratorWithOptions(request, runtime) {
|
|
7324
8016
|
tea_util_1.default.validateModel(request);
|
|
7325
8017
|
let query = {};
|
|
7326
|
-
|
|
7327
|
-
|
|
7328
|
-
|
|
8018
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8019
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8020
|
+
}
|
|
8021
|
+
if (!tea_util_1.default.isUnset(request.bandwidthPackageId)) {
|
|
8022
|
+
query["BandwidthPackageId"] = request.bandwidthPackageId;
|
|
8023
|
+
}
|
|
8024
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8025
|
+
query["RegionId"] = request.regionId;
|
|
8026
|
+
}
|
|
7329
8027
|
let req = new $OpenApi.OpenApiRequest({
|
|
7330
8028
|
query: openapi_util_1.default.query(query),
|
|
7331
8029
|
});
|
|
@@ -7349,14 +8047,30 @@ class Client extends openapi_client_1.default {
|
|
|
7349
8047
|
async configEndpointProbeWithOptions(request, runtime) {
|
|
7350
8048
|
tea_util_1.default.validateModel(request);
|
|
7351
8049
|
let query = {};
|
|
7352
|
-
|
|
7353
|
-
|
|
7354
|
-
|
|
7355
|
-
|
|
7356
|
-
|
|
7357
|
-
|
|
7358
|
-
|
|
7359
|
-
|
|
8050
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8051
|
+
query["ClientToken"] = request.clientToken;
|
|
8052
|
+
}
|
|
8053
|
+
if (!tea_util_1.default.isUnset(request.enable)) {
|
|
8054
|
+
query["Enable"] = request.enable;
|
|
8055
|
+
}
|
|
8056
|
+
if (!tea_util_1.default.isUnset(request.endpoint)) {
|
|
8057
|
+
query["Endpoint"] = request.endpoint;
|
|
8058
|
+
}
|
|
8059
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupId)) {
|
|
8060
|
+
query["EndpointGroupId"] = request.endpointGroupId;
|
|
8061
|
+
}
|
|
8062
|
+
if (!tea_util_1.default.isUnset(request.endpointType)) {
|
|
8063
|
+
query["EndpointType"] = request.endpointType;
|
|
8064
|
+
}
|
|
8065
|
+
if (!tea_util_1.default.isUnset(request.probePort)) {
|
|
8066
|
+
query["ProbePort"] = request.probePort;
|
|
8067
|
+
}
|
|
8068
|
+
if (!tea_util_1.default.isUnset(request.probeProtocol)) {
|
|
8069
|
+
query["ProbeProtocol"] = request.probeProtocol;
|
|
8070
|
+
}
|
|
8071
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8072
|
+
query["RegionId"] = request.regionId;
|
|
8073
|
+
}
|
|
7360
8074
|
let req = new $OpenApi.OpenApiRequest({
|
|
7361
8075
|
query: openapi_util_1.default.query(query),
|
|
7362
8076
|
});
|
|
@@ -7380,16 +8094,36 @@ class Client extends openapi_client_1.default {
|
|
|
7380
8094
|
async createAcceleratorWithOptions(request, runtime) {
|
|
7381
8095
|
tea_util_1.default.validateModel(request);
|
|
7382
8096
|
let query = {};
|
|
7383
|
-
|
|
7384
|
-
|
|
7385
|
-
|
|
7386
|
-
|
|
7387
|
-
|
|
7388
|
-
|
|
7389
|
-
|
|
7390
|
-
|
|
7391
|
-
|
|
7392
|
-
|
|
8097
|
+
if (!tea_util_1.default.isUnset(request.autoPay)) {
|
|
8098
|
+
query["AutoPay"] = request.autoPay;
|
|
8099
|
+
}
|
|
8100
|
+
if (!tea_util_1.default.isUnset(request.autoRenew)) {
|
|
8101
|
+
query["AutoRenew"] = request.autoRenew;
|
|
8102
|
+
}
|
|
8103
|
+
if (!tea_util_1.default.isUnset(request.autoRenewDuration)) {
|
|
8104
|
+
query["AutoRenewDuration"] = request.autoRenewDuration;
|
|
8105
|
+
}
|
|
8106
|
+
if (!tea_util_1.default.isUnset(request.autoUseCoupon)) {
|
|
8107
|
+
query["AutoUseCoupon"] = request.autoUseCoupon;
|
|
8108
|
+
}
|
|
8109
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8110
|
+
query["ClientToken"] = request.clientToken;
|
|
8111
|
+
}
|
|
8112
|
+
if (!tea_util_1.default.isUnset(request.duration)) {
|
|
8113
|
+
query["Duration"] = request.duration;
|
|
8114
|
+
}
|
|
8115
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
8116
|
+
query["Name"] = request.name;
|
|
8117
|
+
}
|
|
8118
|
+
if (!tea_util_1.default.isUnset(request.pricingCycle)) {
|
|
8119
|
+
query["PricingCycle"] = request.pricingCycle;
|
|
8120
|
+
}
|
|
8121
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8122
|
+
query["RegionId"] = request.regionId;
|
|
8123
|
+
}
|
|
8124
|
+
if (!tea_util_1.default.isUnset(request.spec)) {
|
|
8125
|
+
query["Spec"] = request.spec;
|
|
8126
|
+
}
|
|
7393
8127
|
let req = new $OpenApi.OpenApiRequest({
|
|
7394
8128
|
query: openapi_util_1.default.query(query),
|
|
7395
8129
|
});
|
|
@@ -7413,12 +8147,24 @@ class Client extends openapi_client_1.default {
|
|
|
7413
8147
|
async createAclWithOptions(request, runtime) {
|
|
7414
8148
|
tea_util_1.default.validateModel(request);
|
|
7415
8149
|
let query = {};
|
|
7416
|
-
|
|
7417
|
-
|
|
7418
|
-
|
|
7419
|
-
|
|
7420
|
-
|
|
7421
|
-
|
|
8150
|
+
if (!tea_util_1.default.isUnset(request.aclEntries)) {
|
|
8151
|
+
query["AclEntries"] = request.aclEntries;
|
|
8152
|
+
}
|
|
8153
|
+
if (!tea_util_1.default.isUnset(request.aclName)) {
|
|
8154
|
+
query["AclName"] = request.aclName;
|
|
8155
|
+
}
|
|
8156
|
+
if (!tea_util_1.default.isUnset(request.addressIPVersion)) {
|
|
8157
|
+
query["AddressIPVersion"] = request.addressIPVersion;
|
|
8158
|
+
}
|
|
8159
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8160
|
+
query["ClientToken"] = request.clientToken;
|
|
8161
|
+
}
|
|
8162
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
8163
|
+
query["DryRun"] = request.dryRun;
|
|
8164
|
+
}
|
|
8165
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8166
|
+
query["RegionId"] = request.regionId;
|
|
8167
|
+
}
|
|
7422
8168
|
let req = new $OpenApi.OpenApiRequest({
|
|
7423
8169
|
query: openapi_util_1.default.query(query),
|
|
7424
8170
|
});
|
|
@@ -7439,23 +8185,98 @@ class Client extends openapi_client_1.default {
|
|
|
7439
8185
|
let runtime = new $Util.RuntimeOptions({});
|
|
7440
8186
|
return await this.createAclWithOptions(request, runtime);
|
|
7441
8187
|
}
|
|
8188
|
+
async createApplicationMonitorWithOptions(request, runtime) {
|
|
8189
|
+
tea_util_1.default.validateModel(request);
|
|
8190
|
+
let query = {};
|
|
8191
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8192
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8193
|
+
}
|
|
8194
|
+
if (!tea_util_1.default.isUnset(request.address)) {
|
|
8195
|
+
query["Address"] = request.address;
|
|
8196
|
+
}
|
|
8197
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8198
|
+
query["ClientToken"] = request.clientToken;
|
|
8199
|
+
}
|
|
8200
|
+
if (!tea_util_1.default.isUnset(request.detectThreshold)) {
|
|
8201
|
+
query["DetectThreshold"] = request.detectThreshold;
|
|
8202
|
+
}
|
|
8203
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
8204
|
+
query["ListenerId"] = request.listenerId;
|
|
8205
|
+
}
|
|
8206
|
+
if (!tea_util_1.default.isUnset(request.optionsJson)) {
|
|
8207
|
+
query["OptionsJson"] = request.optionsJson;
|
|
8208
|
+
}
|
|
8209
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8210
|
+
query["RegionId"] = request.regionId;
|
|
8211
|
+
}
|
|
8212
|
+
if (!tea_util_1.default.isUnset(request.taskName)) {
|
|
8213
|
+
query["TaskName"] = request.taskName;
|
|
8214
|
+
}
|
|
8215
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
8216
|
+
query: openapi_util_1.default.query(query),
|
|
8217
|
+
});
|
|
8218
|
+
let params = new $OpenApi.Params({
|
|
8219
|
+
action: "CreateApplicationMonitor",
|
|
8220
|
+
version: "2019-11-20",
|
|
8221
|
+
protocol: "HTTPS",
|
|
8222
|
+
pathname: "/",
|
|
8223
|
+
method: "POST",
|
|
8224
|
+
authType: "AK",
|
|
8225
|
+
style: "RPC",
|
|
8226
|
+
reqBodyType: "formData",
|
|
8227
|
+
bodyType: "json",
|
|
8228
|
+
});
|
|
8229
|
+
return $tea.cast(await this.callApi(params, req, runtime), new CreateApplicationMonitorResponse({}));
|
|
8230
|
+
}
|
|
8231
|
+
async createApplicationMonitor(request) {
|
|
8232
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
8233
|
+
return await this.createApplicationMonitorWithOptions(request, runtime);
|
|
8234
|
+
}
|
|
7442
8235
|
async createBandwidthPackageWithOptions(request, runtime) {
|
|
7443
8236
|
tea_util_1.default.validateModel(request);
|
|
7444
8237
|
let query = {};
|
|
7445
|
-
|
|
7446
|
-
|
|
7447
|
-
|
|
7448
|
-
|
|
7449
|
-
|
|
7450
|
-
|
|
7451
|
-
|
|
7452
|
-
|
|
7453
|
-
|
|
7454
|
-
|
|
7455
|
-
|
|
7456
|
-
|
|
7457
|
-
|
|
7458
|
-
|
|
8238
|
+
if (!tea_util_1.default.isUnset(request.autoPay)) {
|
|
8239
|
+
query["AutoPay"] = request.autoPay;
|
|
8240
|
+
}
|
|
8241
|
+
if (!tea_util_1.default.isUnset(request.autoUseCoupon)) {
|
|
8242
|
+
query["AutoUseCoupon"] = request.autoUseCoupon;
|
|
8243
|
+
}
|
|
8244
|
+
if (!tea_util_1.default.isUnset(request.bandwidth)) {
|
|
8245
|
+
query["Bandwidth"] = request.bandwidth;
|
|
8246
|
+
}
|
|
8247
|
+
if (!tea_util_1.default.isUnset(request.bandwidthType)) {
|
|
8248
|
+
query["BandwidthType"] = request.bandwidthType;
|
|
8249
|
+
}
|
|
8250
|
+
if (!tea_util_1.default.isUnset(request.billingType)) {
|
|
8251
|
+
query["BillingType"] = request.billingType;
|
|
8252
|
+
}
|
|
8253
|
+
if (!tea_util_1.default.isUnset(request.cbnGeographicRegionIdA)) {
|
|
8254
|
+
query["CbnGeographicRegionIdA"] = request.cbnGeographicRegionIdA;
|
|
8255
|
+
}
|
|
8256
|
+
if (!tea_util_1.default.isUnset(request.cbnGeographicRegionIdB)) {
|
|
8257
|
+
query["CbnGeographicRegionIdB"] = request.cbnGeographicRegionIdB;
|
|
8258
|
+
}
|
|
8259
|
+
if (!tea_util_1.default.isUnset(request.chargeType)) {
|
|
8260
|
+
query["ChargeType"] = request.chargeType;
|
|
8261
|
+
}
|
|
8262
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8263
|
+
query["ClientToken"] = request.clientToken;
|
|
8264
|
+
}
|
|
8265
|
+
if (!tea_util_1.default.isUnset(request.duration)) {
|
|
8266
|
+
query["Duration"] = request.duration;
|
|
8267
|
+
}
|
|
8268
|
+
if (!tea_util_1.default.isUnset(request.pricingCycle)) {
|
|
8269
|
+
query["PricingCycle"] = request.pricingCycle;
|
|
8270
|
+
}
|
|
8271
|
+
if (!tea_util_1.default.isUnset(request.ratio)) {
|
|
8272
|
+
query["Ratio"] = request.ratio;
|
|
8273
|
+
}
|
|
8274
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8275
|
+
query["RegionId"] = request.regionId;
|
|
8276
|
+
}
|
|
8277
|
+
if (!tea_util_1.default.isUnset(request.type)) {
|
|
8278
|
+
query["Type"] = request.type;
|
|
8279
|
+
}
|
|
7459
8280
|
let req = new $OpenApi.OpenApiRequest({
|
|
7460
8281
|
query: openapi_util_1.default.query(query),
|
|
7461
8282
|
});
|
|
@@ -7479,14 +8300,30 @@ class Client extends openapi_client_1.default {
|
|
|
7479
8300
|
async createBasicAcceleratorWithOptions(request, runtime) {
|
|
7480
8301
|
tea_util_1.default.validateModel(request);
|
|
7481
8302
|
let query = {};
|
|
7482
|
-
|
|
7483
|
-
|
|
7484
|
-
|
|
7485
|
-
|
|
7486
|
-
|
|
7487
|
-
|
|
7488
|
-
|
|
7489
|
-
|
|
8303
|
+
if (!tea_util_1.default.isUnset(request.autoPay)) {
|
|
8304
|
+
query["AutoPay"] = request.autoPay;
|
|
8305
|
+
}
|
|
8306
|
+
if (!tea_util_1.default.isUnset(request.autoRenew)) {
|
|
8307
|
+
query["AutoRenew"] = request.autoRenew;
|
|
8308
|
+
}
|
|
8309
|
+
if (!tea_util_1.default.isUnset(request.autoRenewDuration)) {
|
|
8310
|
+
query["AutoRenewDuration"] = request.autoRenewDuration;
|
|
8311
|
+
}
|
|
8312
|
+
if (!tea_util_1.default.isUnset(request.autoUseCoupon)) {
|
|
8313
|
+
query["AutoUseCoupon"] = request.autoUseCoupon;
|
|
8314
|
+
}
|
|
8315
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8316
|
+
query["ClientToken"] = request.clientToken;
|
|
8317
|
+
}
|
|
8318
|
+
if (!tea_util_1.default.isUnset(request.duration)) {
|
|
8319
|
+
query["Duration"] = request.duration;
|
|
8320
|
+
}
|
|
8321
|
+
if (!tea_util_1.default.isUnset(request.pricingCycle)) {
|
|
8322
|
+
query["PricingCycle"] = request.pricingCycle;
|
|
8323
|
+
}
|
|
8324
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8325
|
+
query["RegionId"] = request.regionId;
|
|
8326
|
+
}
|
|
7490
8327
|
let req = new $OpenApi.OpenApiRequest({
|
|
7491
8328
|
query: openapi_util_1.default.query(query),
|
|
7492
8329
|
});
|
|
@@ -7510,14 +8347,30 @@ class Client extends openapi_client_1.default {
|
|
|
7510
8347
|
async createBasicEndpointGroupWithOptions(request, runtime) {
|
|
7511
8348
|
tea_util_1.default.validateModel(request);
|
|
7512
8349
|
let query = {};
|
|
7513
|
-
|
|
7514
|
-
|
|
7515
|
-
|
|
7516
|
-
|
|
7517
|
-
|
|
7518
|
-
|
|
7519
|
-
|
|
7520
|
-
|
|
8350
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8351
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8352
|
+
}
|
|
8353
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8354
|
+
query["ClientToken"] = request.clientToken;
|
|
8355
|
+
}
|
|
8356
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
8357
|
+
query["Description"] = request.description;
|
|
8358
|
+
}
|
|
8359
|
+
if (!tea_util_1.default.isUnset(request.endpointAddress)) {
|
|
8360
|
+
query["EndpointAddress"] = request.endpointAddress;
|
|
8361
|
+
}
|
|
8362
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupRegion)) {
|
|
8363
|
+
query["EndpointGroupRegion"] = request.endpointGroupRegion;
|
|
8364
|
+
}
|
|
8365
|
+
if (!tea_util_1.default.isUnset(request.endpointType)) {
|
|
8366
|
+
query["EndpointType"] = request.endpointType;
|
|
8367
|
+
}
|
|
8368
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
8369
|
+
query["Name"] = request.name;
|
|
8370
|
+
}
|
|
8371
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8372
|
+
query["RegionId"] = request.regionId;
|
|
8373
|
+
}
|
|
7521
8374
|
let req = new $OpenApi.OpenApiRequest({
|
|
7522
8375
|
query: openapi_util_1.default.query(query),
|
|
7523
8376
|
});
|
|
@@ -7541,10 +8394,18 @@ class Client extends openapi_client_1.default {
|
|
|
7541
8394
|
async createBasicIpSetWithOptions(request, runtime) {
|
|
7542
8395
|
tea_util_1.default.validateModel(request);
|
|
7543
8396
|
let query = {};
|
|
7544
|
-
|
|
7545
|
-
|
|
7546
|
-
|
|
7547
|
-
|
|
8397
|
+
if (!tea_util_1.default.isUnset(request.accelerateRegionId)) {
|
|
8398
|
+
query["AccelerateRegionId"] = request.accelerateRegionId;
|
|
8399
|
+
}
|
|
8400
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8401
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8402
|
+
}
|
|
8403
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8404
|
+
query["ClientToken"] = request.clientToken;
|
|
8405
|
+
}
|
|
8406
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8407
|
+
query["RegionId"] = request.regionId;
|
|
8408
|
+
}
|
|
7548
8409
|
let req = new $OpenApi.OpenApiRequest({
|
|
7549
8410
|
query: openapi_util_1.default.query(query),
|
|
7550
8411
|
});
|
|
@@ -7568,24 +8429,60 @@ class Client extends openapi_client_1.default {
|
|
|
7568
8429
|
async createEndpointGroupWithOptions(request, runtime) {
|
|
7569
8430
|
tea_util_1.default.validateModel(request);
|
|
7570
8431
|
let query = {};
|
|
7571
|
-
|
|
7572
|
-
|
|
7573
|
-
|
|
7574
|
-
|
|
7575
|
-
|
|
7576
|
-
|
|
7577
|
-
|
|
7578
|
-
|
|
7579
|
-
|
|
7580
|
-
|
|
7581
|
-
|
|
7582
|
-
|
|
7583
|
-
|
|
7584
|
-
|
|
7585
|
-
|
|
7586
|
-
|
|
7587
|
-
|
|
7588
|
-
|
|
8432
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8433
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8434
|
+
}
|
|
8435
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8436
|
+
query["ClientToken"] = request.clientToken;
|
|
8437
|
+
}
|
|
8438
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
8439
|
+
query["Description"] = request.description;
|
|
8440
|
+
}
|
|
8441
|
+
if (!tea_util_1.default.isUnset(request.endpointConfigurations)) {
|
|
8442
|
+
query["EndpointConfigurations"] = request.endpointConfigurations;
|
|
8443
|
+
}
|
|
8444
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupRegion)) {
|
|
8445
|
+
query["EndpointGroupRegion"] = request.endpointGroupRegion;
|
|
8446
|
+
}
|
|
8447
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupType)) {
|
|
8448
|
+
query["EndpointGroupType"] = request.endpointGroupType;
|
|
8449
|
+
}
|
|
8450
|
+
if (!tea_util_1.default.isUnset(request.endpointRequestProtocol)) {
|
|
8451
|
+
query["EndpointRequestProtocol"] = request.endpointRequestProtocol;
|
|
8452
|
+
}
|
|
8453
|
+
if (!tea_util_1.default.isUnset(request.healthCheckEnabled)) {
|
|
8454
|
+
query["HealthCheckEnabled"] = request.healthCheckEnabled;
|
|
8455
|
+
}
|
|
8456
|
+
if (!tea_util_1.default.isUnset(request.healthCheckIntervalSeconds)) {
|
|
8457
|
+
query["HealthCheckIntervalSeconds"] = request.healthCheckIntervalSeconds;
|
|
8458
|
+
}
|
|
8459
|
+
if (!tea_util_1.default.isUnset(request.healthCheckPath)) {
|
|
8460
|
+
query["HealthCheckPath"] = request.healthCheckPath;
|
|
8461
|
+
}
|
|
8462
|
+
if (!tea_util_1.default.isUnset(request.healthCheckPort)) {
|
|
8463
|
+
query["HealthCheckPort"] = request.healthCheckPort;
|
|
8464
|
+
}
|
|
8465
|
+
if (!tea_util_1.default.isUnset(request.healthCheckProtocol)) {
|
|
8466
|
+
query["HealthCheckProtocol"] = request.healthCheckProtocol;
|
|
8467
|
+
}
|
|
8468
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
8469
|
+
query["ListenerId"] = request.listenerId;
|
|
8470
|
+
}
|
|
8471
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
8472
|
+
query["Name"] = request.name;
|
|
8473
|
+
}
|
|
8474
|
+
if (!tea_util_1.default.isUnset(request.portOverrides)) {
|
|
8475
|
+
query["PortOverrides"] = request.portOverrides;
|
|
8476
|
+
}
|
|
8477
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8478
|
+
query["RegionId"] = request.regionId;
|
|
8479
|
+
}
|
|
8480
|
+
if (!tea_util_1.default.isUnset(request.thresholdCount)) {
|
|
8481
|
+
query["ThresholdCount"] = request.thresholdCount;
|
|
8482
|
+
}
|
|
8483
|
+
if (!tea_util_1.default.isUnset(request.trafficPercentage)) {
|
|
8484
|
+
query["TrafficPercentage"] = request.trafficPercentage;
|
|
8485
|
+
}
|
|
7589
8486
|
let req = new $OpenApi.OpenApiRequest({
|
|
7590
8487
|
query: openapi_util_1.default.query(query),
|
|
7591
8488
|
});
|
|
@@ -7609,12 +8506,24 @@ class Client extends openapi_client_1.default {
|
|
|
7609
8506
|
async createEndpointGroupsWithOptions(request, runtime) {
|
|
7610
8507
|
tea_util_1.default.validateModel(request);
|
|
7611
8508
|
let query = {};
|
|
7612
|
-
|
|
7613
|
-
|
|
7614
|
-
|
|
7615
|
-
|
|
7616
|
-
|
|
7617
|
-
|
|
8509
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8510
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8511
|
+
}
|
|
8512
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8513
|
+
query["ClientToken"] = request.clientToken;
|
|
8514
|
+
}
|
|
8515
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
8516
|
+
query["DryRun"] = request.dryRun;
|
|
8517
|
+
}
|
|
8518
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupConfigurations)) {
|
|
8519
|
+
query["EndpointGroupConfigurations"] = request.endpointGroupConfigurations;
|
|
8520
|
+
}
|
|
8521
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
8522
|
+
query["ListenerId"] = request.listenerId;
|
|
8523
|
+
}
|
|
8524
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8525
|
+
query["RegionId"] = request.regionId;
|
|
8526
|
+
}
|
|
7618
8527
|
let req = new $OpenApi.OpenApiRequest({
|
|
7619
8528
|
query: openapi_util_1.default.query(query),
|
|
7620
8529
|
});
|
|
@@ -7638,11 +8547,21 @@ class Client extends openapi_client_1.default {
|
|
|
7638
8547
|
async createForwardingRulesWithOptions(request, runtime) {
|
|
7639
8548
|
tea_util_1.default.validateModel(request);
|
|
7640
8549
|
let query = {};
|
|
7641
|
-
|
|
7642
|
-
|
|
7643
|
-
|
|
7644
|
-
|
|
7645
|
-
|
|
8550
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8551
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8552
|
+
}
|
|
8553
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8554
|
+
query["ClientToken"] = request.clientToken;
|
|
8555
|
+
}
|
|
8556
|
+
if (!tea_util_1.default.isUnset(request.forwardingRules)) {
|
|
8557
|
+
query["ForwardingRules"] = request.forwardingRules;
|
|
8558
|
+
}
|
|
8559
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
8560
|
+
query["ListenerId"] = request.listenerId;
|
|
8561
|
+
}
|
|
8562
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8563
|
+
query["RegionId"] = request.regionId;
|
|
8564
|
+
}
|
|
7646
8565
|
let req = new $OpenApi.OpenApiRequest({
|
|
7647
8566
|
query: openapi_util_1.default.query(query),
|
|
7648
8567
|
});
|
|
@@ -7666,10 +8585,18 @@ class Client extends openapi_client_1.default {
|
|
|
7666
8585
|
async createIpSetsWithOptions(request, runtime) {
|
|
7667
8586
|
tea_util_1.default.validateModel(request);
|
|
7668
8587
|
let query = {};
|
|
7669
|
-
|
|
7670
|
-
|
|
7671
|
-
|
|
7672
|
-
|
|
8588
|
+
if (!tea_util_1.default.isUnset(request.accelerateRegion)) {
|
|
8589
|
+
query["AccelerateRegion"] = request.accelerateRegion;
|
|
8590
|
+
}
|
|
8591
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8592
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8593
|
+
}
|
|
8594
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8595
|
+
query["ClientToken"] = request.clientToken;
|
|
8596
|
+
}
|
|
8597
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8598
|
+
query["RegionId"] = request.regionId;
|
|
8599
|
+
}
|
|
7673
8600
|
let req = new $OpenApi.OpenApiRequest({
|
|
7674
8601
|
query: openapi_util_1.default.query(query),
|
|
7675
8602
|
});
|
|
@@ -7693,18 +8620,42 @@ class Client extends openapi_client_1.default {
|
|
|
7693
8620
|
async createListenerWithOptions(request, runtime) {
|
|
7694
8621
|
tea_util_1.default.validateModel(request);
|
|
7695
8622
|
let query = {};
|
|
7696
|
-
|
|
7697
|
-
|
|
7698
|
-
|
|
7699
|
-
|
|
7700
|
-
|
|
7701
|
-
|
|
7702
|
-
|
|
7703
|
-
|
|
7704
|
-
|
|
7705
|
-
|
|
7706
|
-
|
|
7707
|
-
|
|
8623
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8624
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8625
|
+
}
|
|
8626
|
+
if (!tea_util_1.default.isUnset(request.certificates)) {
|
|
8627
|
+
query["Certificates"] = request.certificates;
|
|
8628
|
+
}
|
|
8629
|
+
if (!tea_util_1.default.isUnset(request.clientAffinity)) {
|
|
8630
|
+
query["ClientAffinity"] = request.clientAffinity;
|
|
8631
|
+
}
|
|
8632
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8633
|
+
query["ClientToken"] = request.clientToken;
|
|
8634
|
+
}
|
|
8635
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
8636
|
+
query["Description"] = request.description;
|
|
8637
|
+
}
|
|
8638
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
8639
|
+
query["Name"] = request.name;
|
|
8640
|
+
}
|
|
8641
|
+
if (!tea_util_1.default.isUnset(request.portRanges)) {
|
|
8642
|
+
query["PortRanges"] = request.portRanges;
|
|
8643
|
+
}
|
|
8644
|
+
if (!tea_util_1.default.isUnset(request.protocol)) {
|
|
8645
|
+
query["Protocol"] = request.protocol;
|
|
8646
|
+
}
|
|
8647
|
+
if (!tea_util_1.default.isUnset(request.proxyProtocol)) {
|
|
8648
|
+
query["ProxyProtocol"] = request.proxyProtocol;
|
|
8649
|
+
}
|
|
8650
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8651
|
+
query["RegionId"] = request.regionId;
|
|
8652
|
+
}
|
|
8653
|
+
if (!tea_util_1.default.isUnset(request.securityPolicyId)) {
|
|
8654
|
+
query["SecurityPolicyId"] = request.securityPolicyId;
|
|
8655
|
+
}
|
|
8656
|
+
if (!tea_util_1.default.isUnset($tea.toMap(request.XForwardedForConfig))) {
|
|
8657
|
+
query["XForwardedForConfig"] = request.XForwardedForConfig;
|
|
8658
|
+
}
|
|
7708
8659
|
let req = new $OpenApi.OpenApiRequest({
|
|
7709
8660
|
query: openapi_util_1.default.query(query),
|
|
7710
8661
|
});
|
|
@@ -7728,11 +8679,21 @@ class Client extends openapi_client_1.default {
|
|
|
7728
8679
|
async createSpareIpsWithOptions(request, runtime) {
|
|
7729
8680
|
tea_util_1.default.validateModel(request);
|
|
7730
8681
|
let query = {};
|
|
7731
|
-
|
|
7732
|
-
|
|
7733
|
-
|
|
7734
|
-
|
|
7735
|
-
|
|
8682
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8683
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8684
|
+
}
|
|
8685
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8686
|
+
query["ClientToken"] = request.clientToken;
|
|
8687
|
+
}
|
|
8688
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
8689
|
+
query["DryRun"] = request.dryRun;
|
|
8690
|
+
}
|
|
8691
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8692
|
+
query["RegionId"] = request.regionId;
|
|
8693
|
+
}
|
|
8694
|
+
if (!tea_util_1.default.isUnset(request.spareIps)) {
|
|
8695
|
+
query["SpareIps"] = request.spareIps;
|
|
8696
|
+
}
|
|
7736
8697
|
let req = new $OpenApi.OpenApiRequest({
|
|
7737
8698
|
query: openapi_util_1.default.query(query),
|
|
7738
8699
|
});
|
|
@@ -7756,8 +8717,12 @@ class Client extends openapi_client_1.default {
|
|
|
7756
8717
|
async deleteAcceleratorWithOptions(request, runtime) {
|
|
7757
8718
|
tea_util_1.default.validateModel(request);
|
|
7758
8719
|
let query = {};
|
|
7759
|
-
|
|
7760
|
-
|
|
8720
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8721
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8722
|
+
}
|
|
8723
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8724
|
+
query["RegionId"] = request.regionId;
|
|
8725
|
+
}
|
|
7761
8726
|
let req = new $OpenApi.OpenApiRequest({
|
|
7762
8727
|
query: openapi_util_1.default.query(query),
|
|
7763
8728
|
});
|
|
@@ -7781,10 +8746,18 @@ class Client extends openapi_client_1.default {
|
|
|
7781
8746
|
async deleteAclWithOptions(request, runtime) {
|
|
7782
8747
|
tea_util_1.default.validateModel(request);
|
|
7783
8748
|
let query = {};
|
|
7784
|
-
|
|
7785
|
-
|
|
7786
|
-
|
|
7787
|
-
|
|
8749
|
+
if (!tea_util_1.default.isUnset(request.aclId)) {
|
|
8750
|
+
query["AclId"] = request.aclId;
|
|
8751
|
+
}
|
|
8752
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8753
|
+
query["ClientToken"] = request.clientToken;
|
|
8754
|
+
}
|
|
8755
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
8756
|
+
query["DryRun"] = request.dryRun;
|
|
8757
|
+
}
|
|
8758
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8759
|
+
query["RegionId"] = request.regionId;
|
|
8760
|
+
}
|
|
7788
8761
|
let req = new $OpenApi.OpenApiRequest({
|
|
7789
8762
|
query: openapi_util_1.default.query(query),
|
|
7790
8763
|
});
|
|
@@ -7805,12 +8778,50 @@ class Client extends openapi_client_1.default {
|
|
|
7805
8778
|
let runtime = new $Util.RuntimeOptions({});
|
|
7806
8779
|
return await this.deleteAclWithOptions(request, runtime);
|
|
7807
8780
|
}
|
|
8781
|
+
async deleteApplicationMonitorWithOptions(request, runtime) {
|
|
8782
|
+
tea_util_1.default.validateModel(request);
|
|
8783
|
+
let query = {};
|
|
8784
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8785
|
+
query["ClientToken"] = request.clientToken;
|
|
8786
|
+
}
|
|
8787
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8788
|
+
query["RegionId"] = request.regionId;
|
|
8789
|
+
}
|
|
8790
|
+
if (!tea_util_1.default.isUnset(request.taskId)) {
|
|
8791
|
+
query["TaskId"] = request.taskId;
|
|
8792
|
+
}
|
|
8793
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
8794
|
+
query: openapi_util_1.default.query(query),
|
|
8795
|
+
});
|
|
8796
|
+
let params = new $OpenApi.Params({
|
|
8797
|
+
action: "DeleteApplicationMonitor",
|
|
8798
|
+
version: "2019-11-20",
|
|
8799
|
+
protocol: "HTTPS",
|
|
8800
|
+
pathname: "/",
|
|
8801
|
+
method: "POST",
|
|
8802
|
+
authType: "AK",
|
|
8803
|
+
style: "RPC",
|
|
8804
|
+
reqBodyType: "formData",
|
|
8805
|
+
bodyType: "json",
|
|
8806
|
+
});
|
|
8807
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DeleteApplicationMonitorResponse({}));
|
|
8808
|
+
}
|
|
8809
|
+
async deleteApplicationMonitor(request) {
|
|
8810
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
8811
|
+
return await this.deleteApplicationMonitorWithOptions(request, runtime);
|
|
8812
|
+
}
|
|
7808
8813
|
async deleteBandwidthPackageWithOptions(request, runtime) {
|
|
7809
8814
|
tea_util_1.default.validateModel(request);
|
|
7810
8815
|
let query = {};
|
|
7811
|
-
|
|
7812
|
-
|
|
7813
|
-
|
|
8816
|
+
if (!tea_util_1.default.isUnset(request.bandwidthPackageId)) {
|
|
8817
|
+
query["BandwidthPackageId"] = request.bandwidthPackageId;
|
|
8818
|
+
}
|
|
8819
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8820
|
+
query["ClientToken"] = request.clientToken;
|
|
8821
|
+
}
|
|
8822
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8823
|
+
query["RegionId"] = request.regionId;
|
|
8824
|
+
}
|
|
7814
8825
|
let req = new $OpenApi.OpenApiRequest({
|
|
7815
8826
|
query: openapi_util_1.default.query(query),
|
|
7816
8827
|
});
|
|
@@ -7834,8 +8845,12 @@ class Client extends openapi_client_1.default {
|
|
|
7834
8845
|
async deleteBasicAcceleratorWithOptions(request, runtime) {
|
|
7835
8846
|
tea_util_1.default.validateModel(request);
|
|
7836
8847
|
let query = {};
|
|
7837
|
-
|
|
7838
|
-
|
|
8848
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8849
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8850
|
+
}
|
|
8851
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8852
|
+
query["RegionId"] = request.regionId;
|
|
8853
|
+
}
|
|
7839
8854
|
let req = new $OpenApi.OpenApiRequest({
|
|
7840
8855
|
query: openapi_util_1.default.query(query),
|
|
7841
8856
|
});
|
|
@@ -7859,8 +8874,12 @@ class Client extends openapi_client_1.default {
|
|
|
7859
8874
|
async deleteBasicEndpointGroupWithOptions(request, runtime) {
|
|
7860
8875
|
tea_util_1.default.validateModel(request);
|
|
7861
8876
|
let query = {};
|
|
7862
|
-
|
|
7863
|
-
|
|
8877
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8878
|
+
query["ClientToken"] = request.clientToken;
|
|
8879
|
+
}
|
|
8880
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupId)) {
|
|
8881
|
+
query["EndpointGroupId"] = request.endpointGroupId;
|
|
8882
|
+
}
|
|
7864
8883
|
let req = new $OpenApi.OpenApiRequest({
|
|
7865
8884
|
query: openapi_util_1.default.query(query),
|
|
7866
8885
|
});
|
|
@@ -7884,9 +8903,15 @@ class Client extends openapi_client_1.default {
|
|
|
7884
8903
|
async deleteBasicIpSetWithOptions(request, runtime) {
|
|
7885
8904
|
tea_util_1.default.validateModel(request);
|
|
7886
8905
|
let query = {};
|
|
7887
|
-
|
|
7888
|
-
|
|
7889
|
-
|
|
8906
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8907
|
+
query["ClientToken"] = request.clientToken;
|
|
8908
|
+
}
|
|
8909
|
+
if (!tea_util_1.default.isUnset(request.ipSetId)) {
|
|
8910
|
+
query["IpSetId"] = request.ipSetId;
|
|
8911
|
+
}
|
|
8912
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8913
|
+
query["RegionId"] = request.regionId;
|
|
8914
|
+
}
|
|
7890
8915
|
let req = new $OpenApi.OpenApiRequest({
|
|
7891
8916
|
query: openapi_util_1.default.query(query),
|
|
7892
8917
|
});
|
|
@@ -7910,9 +8935,15 @@ class Client extends openapi_client_1.default {
|
|
|
7910
8935
|
async deleteEndpointGroupWithOptions(request, runtime) {
|
|
7911
8936
|
tea_util_1.default.validateModel(request);
|
|
7912
8937
|
let query = {};
|
|
7913
|
-
|
|
7914
|
-
|
|
7915
|
-
|
|
8938
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
8939
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
8940
|
+
}
|
|
8941
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8942
|
+
query["ClientToken"] = request.clientToken;
|
|
8943
|
+
}
|
|
8944
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupId)) {
|
|
8945
|
+
query["EndpointGroupId"] = request.endpointGroupId;
|
|
8946
|
+
}
|
|
7916
8947
|
let req = new $OpenApi.OpenApiRequest({
|
|
7917
8948
|
query: openapi_util_1.default.query(query),
|
|
7918
8949
|
});
|
|
@@ -7936,10 +8967,18 @@ class Client extends openapi_client_1.default {
|
|
|
7936
8967
|
async deleteEndpointGroupsWithOptions(request, runtime) {
|
|
7937
8968
|
tea_util_1.default.validateModel(request);
|
|
7938
8969
|
let query = {};
|
|
7939
|
-
|
|
7940
|
-
|
|
7941
|
-
|
|
7942
|
-
|
|
8970
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
8971
|
+
query["ClientToken"] = request.clientToken;
|
|
8972
|
+
}
|
|
8973
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
8974
|
+
query["DryRun"] = request.dryRun;
|
|
8975
|
+
}
|
|
8976
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupIds)) {
|
|
8977
|
+
query["EndpointGroupIds"] = request.endpointGroupIds;
|
|
8978
|
+
}
|
|
8979
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
8980
|
+
query["RegionId"] = request.regionId;
|
|
8981
|
+
}
|
|
7943
8982
|
let req = new $OpenApi.OpenApiRequest({
|
|
7944
8983
|
query: openapi_util_1.default.query(query),
|
|
7945
8984
|
});
|
|
@@ -7963,11 +9002,21 @@ class Client extends openapi_client_1.default {
|
|
|
7963
9002
|
async deleteForwardingRulesWithOptions(request, runtime) {
|
|
7964
9003
|
tea_util_1.default.validateModel(request);
|
|
7965
9004
|
let query = {};
|
|
7966
|
-
|
|
7967
|
-
|
|
7968
|
-
|
|
7969
|
-
|
|
7970
|
-
|
|
9005
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9006
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9007
|
+
}
|
|
9008
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9009
|
+
query["ClientToken"] = request.clientToken;
|
|
9010
|
+
}
|
|
9011
|
+
if (!tea_util_1.default.isUnset(request.forwardingRuleIds)) {
|
|
9012
|
+
query["ForwardingRuleIds"] = request.forwardingRuleIds;
|
|
9013
|
+
}
|
|
9014
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
9015
|
+
query["ListenerId"] = request.listenerId;
|
|
9016
|
+
}
|
|
9017
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9018
|
+
query["RegionId"] = request.regionId;
|
|
9019
|
+
}
|
|
7971
9020
|
let req = new $OpenApi.OpenApiRequest({
|
|
7972
9021
|
query: openapi_util_1.default.query(query),
|
|
7973
9022
|
});
|
|
@@ -7991,10 +9040,18 @@ class Client extends openapi_client_1.default {
|
|
|
7991
9040
|
async deleteIpSetWithOptions(request, runtime) {
|
|
7992
9041
|
tea_util_1.default.validateModel(request);
|
|
7993
9042
|
let query = {};
|
|
7994
|
-
|
|
7995
|
-
|
|
7996
|
-
|
|
7997
|
-
|
|
9043
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9044
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9045
|
+
}
|
|
9046
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9047
|
+
query["ClientToken"] = request.clientToken;
|
|
9048
|
+
}
|
|
9049
|
+
if (!tea_util_1.default.isUnset(request.ipSetId)) {
|
|
9050
|
+
query["IpSetId"] = request.ipSetId;
|
|
9051
|
+
}
|
|
9052
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9053
|
+
query["RegionId"] = request.regionId;
|
|
9054
|
+
}
|
|
7998
9055
|
let req = new $OpenApi.OpenApiRequest({
|
|
7999
9056
|
query: openapi_util_1.default.query(query),
|
|
8000
9057
|
});
|
|
@@ -8018,8 +9075,12 @@ class Client extends openapi_client_1.default {
|
|
|
8018
9075
|
async deleteIpSetsWithOptions(request, runtime) {
|
|
8019
9076
|
tea_util_1.default.validateModel(request);
|
|
8020
9077
|
let query = {};
|
|
8021
|
-
|
|
8022
|
-
|
|
9078
|
+
if (!tea_util_1.default.isUnset(request.ipSetIds)) {
|
|
9079
|
+
query["IpSetIds"] = request.ipSetIds;
|
|
9080
|
+
}
|
|
9081
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9082
|
+
query["RegionId"] = request.regionId;
|
|
9083
|
+
}
|
|
8023
9084
|
let req = new $OpenApi.OpenApiRequest({
|
|
8024
9085
|
query: openapi_util_1.default.query(query),
|
|
8025
9086
|
});
|
|
@@ -8043,9 +9104,15 @@ class Client extends openapi_client_1.default {
|
|
|
8043
9104
|
async deleteListenerWithOptions(request, runtime) {
|
|
8044
9105
|
tea_util_1.default.validateModel(request);
|
|
8045
9106
|
let query = {};
|
|
8046
|
-
|
|
8047
|
-
|
|
8048
|
-
|
|
9107
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9108
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9109
|
+
}
|
|
9110
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9111
|
+
query["ClientToken"] = request.clientToken;
|
|
9112
|
+
}
|
|
9113
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
9114
|
+
query["ListenerId"] = request.listenerId;
|
|
9115
|
+
}
|
|
8049
9116
|
let req = new $OpenApi.OpenApiRequest({
|
|
8050
9117
|
query: openapi_util_1.default.query(query),
|
|
8051
9118
|
});
|
|
@@ -8069,11 +9136,21 @@ class Client extends openapi_client_1.default {
|
|
|
8069
9136
|
async deleteSpareIpsWithOptions(request, runtime) {
|
|
8070
9137
|
tea_util_1.default.validateModel(request);
|
|
8071
9138
|
let query = {};
|
|
8072
|
-
|
|
8073
|
-
|
|
8074
|
-
|
|
8075
|
-
|
|
8076
|
-
|
|
9139
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9140
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9141
|
+
}
|
|
9142
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9143
|
+
query["ClientToken"] = request.clientToken;
|
|
9144
|
+
}
|
|
9145
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
9146
|
+
query["DryRun"] = request.dryRun;
|
|
9147
|
+
}
|
|
9148
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9149
|
+
query["RegionId"] = request.regionId;
|
|
9150
|
+
}
|
|
9151
|
+
if (!tea_util_1.default.isUnset(request.spareIps)) {
|
|
9152
|
+
query["SpareIps"] = request.spareIps;
|
|
9153
|
+
}
|
|
8077
9154
|
let req = new $OpenApi.OpenApiRequest({
|
|
8078
9155
|
query: openapi_util_1.default.query(query),
|
|
8079
9156
|
});
|
|
@@ -8097,8 +9174,12 @@ class Client extends openapi_client_1.default {
|
|
|
8097
9174
|
async describeAcceleratorWithOptions(request, runtime) {
|
|
8098
9175
|
tea_util_1.default.validateModel(request);
|
|
8099
9176
|
let query = {};
|
|
8100
|
-
|
|
8101
|
-
|
|
9177
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9178
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9179
|
+
}
|
|
9180
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9181
|
+
query["RegionId"] = request.regionId;
|
|
9182
|
+
}
|
|
8102
9183
|
let req = new $OpenApi.OpenApiRequest({
|
|
8103
9184
|
query: openapi_util_1.default.query(query),
|
|
8104
9185
|
});
|
|
@@ -8122,8 +9203,12 @@ class Client extends openapi_client_1.default {
|
|
|
8122
9203
|
async describeAcceleratorAutoRenewAttributeWithOptions(request, runtime) {
|
|
8123
9204
|
tea_util_1.default.validateModel(request);
|
|
8124
9205
|
let query = {};
|
|
8125
|
-
|
|
8126
|
-
|
|
9206
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9207
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9208
|
+
}
|
|
9209
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9210
|
+
query["RegionId"] = request.regionId;
|
|
9211
|
+
}
|
|
8127
9212
|
let req = new $OpenApi.OpenApiRequest({
|
|
8128
9213
|
query: openapi_util_1.default.query(query),
|
|
8129
9214
|
});
|
|
@@ -8144,11 +9229,47 @@ class Client extends openapi_client_1.default {
|
|
|
8144
9229
|
let runtime = new $Util.RuntimeOptions({});
|
|
8145
9230
|
return await this.describeAcceleratorAutoRenewAttributeWithOptions(request, runtime);
|
|
8146
9231
|
}
|
|
9232
|
+
async describeApplicationMonitorWithOptions(request, runtime) {
|
|
9233
|
+
tea_util_1.default.validateModel(request);
|
|
9234
|
+
let query = {};
|
|
9235
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9236
|
+
query["ClientToken"] = request.clientToken;
|
|
9237
|
+
}
|
|
9238
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9239
|
+
query["RegionId"] = request.regionId;
|
|
9240
|
+
}
|
|
9241
|
+
if (!tea_util_1.default.isUnset(request.taskId)) {
|
|
9242
|
+
query["TaskId"] = request.taskId;
|
|
9243
|
+
}
|
|
9244
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
9245
|
+
query: openapi_util_1.default.query(query),
|
|
9246
|
+
});
|
|
9247
|
+
let params = new $OpenApi.Params({
|
|
9248
|
+
action: "DescribeApplicationMonitor",
|
|
9249
|
+
version: "2019-11-20",
|
|
9250
|
+
protocol: "HTTPS",
|
|
9251
|
+
pathname: "/",
|
|
9252
|
+
method: "POST",
|
|
9253
|
+
authType: "AK",
|
|
9254
|
+
style: "RPC",
|
|
9255
|
+
reqBodyType: "formData",
|
|
9256
|
+
bodyType: "json",
|
|
9257
|
+
});
|
|
9258
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DescribeApplicationMonitorResponse({}));
|
|
9259
|
+
}
|
|
9260
|
+
async describeApplicationMonitor(request) {
|
|
9261
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
9262
|
+
return await this.describeApplicationMonitorWithOptions(request, runtime);
|
|
9263
|
+
}
|
|
8147
9264
|
async describeBandwidthPackageWithOptions(request, runtime) {
|
|
8148
9265
|
tea_util_1.default.validateModel(request);
|
|
8149
9266
|
let query = {};
|
|
8150
|
-
|
|
8151
|
-
|
|
9267
|
+
if (!tea_util_1.default.isUnset(request.bandwidthPackageId)) {
|
|
9268
|
+
query["BandwidthPackageId"] = request.bandwidthPackageId;
|
|
9269
|
+
}
|
|
9270
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9271
|
+
query["RegionId"] = request.regionId;
|
|
9272
|
+
}
|
|
8152
9273
|
let req = new $OpenApi.OpenApiRequest({
|
|
8153
9274
|
query: openapi_util_1.default.query(query),
|
|
8154
9275
|
});
|
|
@@ -8172,8 +9293,12 @@ class Client extends openapi_client_1.default {
|
|
|
8172
9293
|
async describeEndpointGroupWithOptions(request, runtime) {
|
|
8173
9294
|
tea_util_1.default.validateModel(request);
|
|
8174
9295
|
let query = {};
|
|
8175
|
-
|
|
8176
|
-
|
|
9296
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupId)) {
|
|
9297
|
+
query["EndpointGroupId"] = request.endpointGroupId;
|
|
9298
|
+
}
|
|
9299
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9300
|
+
query["RegionId"] = request.regionId;
|
|
9301
|
+
}
|
|
8177
9302
|
let req = new $OpenApi.OpenApiRequest({
|
|
8178
9303
|
query: openapi_util_1.default.query(query),
|
|
8179
9304
|
});
|
|
@@ -8197,8 +9322,12 @@ class Client extends openapi_client_1.default {
|
|
|
8197
9322
|
async describeIpSetWithOptions(request, runtime) {
|
|
8198
9323
|
tea_util_1.default.validateModel(request);
|
|
8199
9324
|
let query = {};
|
|
8200
|
-
|
|
8201
|
-
|
|
9325
|
+
if (!tea_util_1.default.isUnset(request.ipSetId)) {
|
|
9326
|
+
query["IpSetId"] = request.ipSetId;
|
|
9327
|
+
}
|
|
9328
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9329
|
+
query["RegionId"] = request.regionId;
|
|
9330
|
+
}
|
|
8202
9331
|
let req = new $OpenApi.OpenApiRequest({
|
|
8203
9332
|
query: openapi_util_1.default.query(query),
|
|
8204
9333
|
});
|
|
@@ -8222,8 +9351,12 @@ class Client extends openapi_client_1.default {
|
|
|
8222
9351
|
async describeListenerWithOptions(request, runtime) {
|
|
8223
9352
|
tea_util_1.default.validateModel(request);
|
|
8224
9353
|
let query = {};
|
|
8225
|
-
|
|
8226
|
-
|
|
9354
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
9355
|
+
query["ListenerId"] = request.listenerId;
|
|
9356
|
+
}
|
|
9357
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9358
|
+
query["RegionId"] = request.regionId;
|
|
9359
|
+
}
|
|
8227
9360
|
let req = new $OpenApi.OpenApiRequest({
|
|
8228
9361
|
query: openapi_util_1.default.query(query),
|
|
8229
9362
|
});
|
|
@@ -8247,7 +9380,9 @@ class Client extends openapi_client_1.default {
|
|
|
8247
9380
|
async describeRegionsWithOptions(request, runtime) {
|
|
8248
9381
|
tea_util_1.default.validateModel(request);
|
|
8249
9382
|
let query = {};
|
|
8250
|
-
|
|
9383
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9384
|
+
query["RegionId"] = request.regionId;
|
|
9385
|
+
}
|
|
8251
9386
|
let req = new $OpenApi.OpenApiRequest({
|
|
8252
9387
|
query: openapi_util_1.default.query(query),
|
|
8253
9388
|
});
|
|
@@ -8271,8 +9406,12 @@ class Client extends openapi_client_1.default {
|
|
|
8271
9406
|
async detachDdosFromAcceleratorWithOptions(request, runtime) {
|
|
8272
9407
|
tea_util_1.default.validateModel(request);
|
|
8273
9408
|
let query = {};
|
|
8274
|
-
|
|
8275
|
-
|
|
9409
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9410
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9411
|
+
}
|
|
9412
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9413
|
+
query["RegionId"] = request.regionId;
|
|
9414
|
+
}
|
|
8276
9415
|
let req = new $OpenApi.OpenApiRequest({
|
|
8277
9416
|
query: openapi_util_1.default.query(query),
|
|
8278
9417
|
});
|
|
@@ -8296,11 +9435,21 @@ class Client extends openapi_client_1.default {
|
|
|
8296
9435
|
async detachLogStoreFromEndpointGroupWithOptions(request, runtime) {
|
|
8297
9436
|
tea_util_1.default.validateModel(request);
|
|
8298
9437
|
let query = {};
|
|
8299
|
-
|
|
8300
|
-
|
|
8301
|
-
|
|
8302
|
-
|
|
8303
|
-
|
|
9438
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9439
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9440
|
+
}
|
|
9441
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9442
|
+
query["ClientToken"] = request.clientToken;
|
|
9443
|
+
}
|
|
9444
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupIds)) {
|
|
9445
|
+
query["EndpointGroupIds"] = request.endpointGroupIds;
|
|
9446
|
+
}
|
|
9447
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
9448
|
+
query["ListenerId"] = request.listenerId;
|
|
9449
|
+
}
|
|
9450
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9451
|
+
query["RegionId"] = request.regionId;
|
|
9452
|
+
}
|
|
8304
9453
|
let req = new $OpenApi.OpenApiRequest({
|
|
8305
9454
|
query: openapi_util_1.default.query(query),
|
|
8306
9455
|
});
|
|
@@ -8321,14 +9470,88 @@ class Client extends openapi_client_1.default {
|
|
|
8321
9470
|
let runtime = new $Util.RuntimeOptions({});
|
|
8322
9471
|
return await this.detachLogStoreFromEndpointGroupWithOptions(request, runtime);
|
|
8323
9472
|
}
|
|
9473
|
+
async detectApplicationMonitorWithOptions(request, runtime) {
|
|
9474
|
+
tea_util_1.default.validateModel(request);
|
|
9475
|
+
let query = {};
|
|
9476
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9477
|
+
query["ClientToken"] = request.clientToken;
|
|
9478
|
+
}
|
|
9479
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9480
|
+
query["RegionId"] = request.regionId;
|
|
9481
|
+
}
|
|
9482
|
+
if (!tea_util_1.default.isUnset(request.taskId)) {
|
|
9483
|
+
query["TaskId"] = request.taskId;
|
|
9484
|
+
}
|
|
9485
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
9486
|
+
query: openapi_util_1.default.query(query),
|
|
9487
|
+
});
|
|
9488
|
+
let params = new $OpenApi.Params({
|
|
9489
|
+
action: "DetectApplicationMonitor",
|
|
9490
|
+
version: "2019-11-20",
|
|
9491
|
+
protocol: "HTTPS",
|
|
9492
|
+
pathname: "/",
|
|
9493
|
+
method: "POST",
|
|
9494
|
+
authType: "AK",
|
|
9495
|
+
style: "RPC",
|
|
9496
|
+
reqBodyType: "formData",
|
|
9497
|
+
bodyType: "json",
|
|
9498
|
+
});
|
|
9499
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DetectApplicationMonitorResponse({}));
|
|
9500
|
+
}
|
|
9501
|
+
async detectApplicationMonitor(request) {
|
|
9502
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
9503
|
+
return await this.detectApplicationMonitorWithOptions(request, runtime);
|
|
9504
|
+
}
|
|
9505
|
+
async disableApplicationMonitorWithOptions(request, runtime) {
|
|
9506
|
+
tea_util_1.default.validateModel(request);
|
|
9507
|
+
let query = {};
|
|
9508
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9509
|
+
query["ClientToken"] = request.clientToken;
|
|
9510
|
+
}
|
|
9511
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9512
|
+
query["RegionId"] = request.regionId;
|
|
9513
|
+
}
|
|
9514
|
+
if (!tea_util_1.default.isUnset(request.taskId)) {
|
|
9515
|
+
query["TaskId"] = request.taskId;
|
|
9516
|
+
}
|
|
9517
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
9518
|
+
query: openapi_util_1.default.query(query),
|
|
9519
|
+
});
|
|
9520
|
+
let params = new $OpenApi.Params({
|
|
9521
|
+
action: "DisableApplicationMonitor",
|
|
9522
|
+
version: "2019-11-20",
|
|
9523
|
+
protocol: "HTTPS",
|
|
9524
|
+
pathname: "/",
|
|
9525
|
+
method: "POST",
|
|
9526
|
+
authType: "AK",
|
|
9527
|
+
style: "RPC",
|
|
9528
|
+
reqBodyType: "formData",
|
|
9529
|
+
bodyType: "json",
|
|
9530
|
+
});
|
|
9531
|
+
return $tea.cast(await this.callApi(params, req, runtime), new DisableApplicationMonitorResponse({}));
|
|
9532
|
+
}
|
|
9533
|
+
async disableApplicationMonitor(request) {
|
|
9534
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
9535
|
+
return await this.disableApplicationMonitorWithOptions(request, runtime);
|
|
9536
|
+
}
|
|
8324
9537
|
async dissociateAclsFromListenerWithOptions(request, runtime) {
|
|
8325
9538
|
tea_util_1.default.validateModel(request);
|
|
8326
9539
|
let query = {};
|
|
8327
|
-
|
|
8328
|
-
|
|
8329
|
-
|
|
8330
|
-
|
|
8331
|
-
|
|
9540
|
+
if (!tea_util_1.default.isUnset(request.aclIds)) {
|
|
9541
|
+
query["AclIds"] = request.aclIds;
|
|
9542
|
+
}
|
|
9543
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9544
|
+
query["ClientToken"] = request.clientToken;
|
|
9545
|
+
}
|
|
9546
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
9547
|
+
query["DryRun"] = request.dryRun;
|
|
9548
|
+
}
|
|
9549
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
9550
|
+
query["ListenerId"] = request.listenerId;
|
|
9551
|
+
}
|
|
9552
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9553
|
+
query["RegionId"] = request.regionId;
|
|
9554
|
+
}
|
|
8332
9555
|
let req = new $OpenApi.OpenApiRequest({
|
|
8333
9556
|
query: openapi_util_1.default.query(query),
|
|
8334
9557
|
});
|
|
@@ -8352,11 +9575,21 @@ class Client extends openapi_client_1.default {
|
|
|
8352
9575
|
async dissociateAdditionalCertificatesFromListenerWithOptions(request, runtime) {
|
|
8353
9576
|
tea_util_1.default.validateModel(request);
|
|
8354
9577
|
let query = {};
|
|
8355
|
-
|
|
8356
|
-
|
|
8357
|
-
|
|
8358
|
-
|
|
8359
|
-
|
|
9578
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9579
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9580
|
+
}
|
|
9581
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9582
|
+
query["ClientToken"] = request.clientToken;
|
|
9583
|
+
}
|
|
9584
|
+
if (!tea_util_1.default.isUnset(request.domains)) {
|
|
9585
|
+
query["Domains"] = request.domains;
|
|
9586
|
+
}
|
|
9587
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
9588
|
+
query["ListenerId"] = request.listenerId;
|
|
9589
|
+
}
|
|
9590
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9591
|
+
query["RegionId"] = request.regionId;
|
|
9592
|
+
}
|
|
8360
9593
|
let req = new $OpenApi.OpenApiRequest({
|
|
8361
9594
|
query: openapi_util_1.default.query(query),
|
|
8362
9595
|
});
|
|
@@ -8377,11 +9610,47 @@ class Client extends openapi_client_1.default {
|
|
|
8377
9610
|
let runtime = new $Util.RuntimeOptions({});
|
|
8378
9611
|
return await this.dissociateAdditionalCertificatesFromListenerWithOptions(request, runtime);
|
|
8379
9612
|
}
|
|
9613
|
+
async enableApplicationMonitorWithOptions(request, runtime) {
|
|
9614
|
+
tea_util_1.default.validateModel(request);
|
|
9615
|
+
let query = {};
|
|
9616
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9617
|
+
query["ClientToken"] = request.clientToken;
|
|
9618
|
+
}
|
|
9619
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9620
|
+
query["RegionId"] = request.regionId;
|
|
9621
|
+
}
|
|
9622
|
+
if (!tea_util_1.default.isUnset(request.taskId)) {
|
|
9623
|
+
query["TaskId"] = request.taskId;
|
|
9624
|
+
}
|
|
9625
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
9626
|
+
query: openapi_util_1.default.query(query),
|
|
9627
|
+
});
|
|
9628
|
+
let params = new $OpenApi.Params({
|
|
9629
|
+
action: "EnableApplicationMonitor",
|
|
9630
|
+
version: "2019-11-20",
|
|
9631
|
+
protocol: "HTTPS",
|
|
9632
|
+
pathname: "/",
|
|
9633
|
+
method: "POST",
|
|
9634
|
+
authType: "AK",
|
|
9635
|
+
style: "RPC",
|
|
9636
|
+
reqBodyType: "formData",
|
|
9637
|
+
bodyType: "json",
|
|
9638
|
+
});
|
|
9639
|
+
return $tea.cast(await this.callApi(params, req, runtime), new EnableApplicationMonitorResponse({}));
|
|
9640
|
+
}
|
|
9641
|
+
async enableApplicationMonitor(request) {
|
|
9642
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
9643
|
+
return await this.enableApplicationMonitorWithOptions(request, runtime);
|
|
9644
|
+
}
|
|
8380
9645
|
async getAclWithOptions(request, runtime) {
|
|
8381
9646
|
tea_util_1.default.validateModel(request);
|
|
8382
9647
|
let query = {};
|
|
8383
|
-
|
|
8384
|
-
|
|
9648
|
+
if (!tea_util_1.default.isUnset(request.aclId)) {
|
|
9649
|
+
query["AclId"] = request.aclId;
|
|
9650
|
+
}
|
|
9651
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9652
|
+
query["RegionId"] = request.regionId;
|
|
9653
|
+
}
|
|
8385
9654
|
let req = new $OpenApi.OpenApiRequest({
|
|
8386
9655
|
query: openapi_util_1.default.query(query),
|
|
8387
9656
|
});
|
|
@@ -8405,8 +9674,12 @@ class Client extends openapi_client_1.default {
|
|
|
8405
9674
|
async getBasicAcceleratorWithOptions(request, runtime) {
|
|
8406
9675
|
tea_util_1.default.validateModel(request);
|
|
8407
9676
|
let query = {};
|
|
8408
|
-
|
|
8409
|
-
|
|
9677
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9678
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9679
|
+
}
|
|
9680
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9681
|
+
query["RegionId"] = request.regionId;
|
|
9682
|
+
}
|
|
8410
9683
|
let req = new $OpenApi.OpenApiRequest({
|
|
8411
9684
|
query: openapi_util_1.default.query(query),
|
|
8412
9685
|
});
|
|
@@ -8430,9 +9703,15 @@ class Client extends openapi_client_1.default {
|
|
|
8430
9703
|
async getBasicEndpointGroupWithOptions(request, runtime) {
|
|
8431
9704
|
tea_util_1.default.validateModel(request);
|
|
8432
9705
|
let query = {};
|
|
8433
|
-
|
|
8434
|
-
|
|
8435
|
-
|
|
9706
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9707
|
+
query["ClientToken"] = request.clientToken;
|
|
9708
|
+
}
|
|
9709
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupId)) {
|
|
9710
|
+
query["EndpointGroupId"] = request.endpointGroupId;
|
|
9711
|
+
}
|
|
9712
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9713
|
+
query["RegionId"] = request.regionId;
|
|
9714
|
+
}
|
|
8436
9715
|
let req = new $OpenApi.OpenApiRequest({
|
|
8437
9716
|
query: openapi_util_1.default.query(query),
|
|
8438
9717
|
});
|
|
@@ -8456,9 +9735,15 @@ class Client extends openapi_client_1.default {
|
|
|
8456
9735
|
async getBasicIpSetWithOptions(request, runtime) {
|
|
8457
9736
|
tea_util_1.default.validateModel(request);
|
|
8458
9737
|
let query = {};
|
|
8459
|
-
|
|
8460
|
-
|
|
8461
|
-
|
|
9738
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9739
|
+
query["ClientToken"] = request.clientToken;
|
|
9740
|
+
}
|
|
9741
|
+
if (!tea_util_1.default.isUnset(request.ipSetId)) {
|
|
9742
|
+
query["IpSetId"] = request.ipSetId;
|
|
9743
|
+
}
|
|
9744
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9745
|
+
query["RegionId"] = request.regionId;
|
|
9746
|
+
}
|
|
8462
9747
|
let req = new $OpenApi.OpenApiRequest({
|
|
8463
9748
|
query: openapi_util_1.default.query(query),
|
|
8464
9749
|
});
|
|
@@ -8482,11 +9767,21 @@ class Client extends openapi_client_1.default {
|
|
|
8482
9767
|
async getHealthStatusWithOptions(request, runtime) {
|
|
8483
9768
|
tea_util_1.default.validateModel(request);
|
|
8484
9769
|
let query = {};
|
|
8485
|
-
|
|
8486
|
-
|
|
8487
|
-
|
|
8488
|
-
|
|
8489
|
-
|
|
9770
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9771
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9772
|
+
}
|
|
9773
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9774
|
+
query["ClientToken"] = request.clientToken;
|
|
9775
|
+
}
|
|
9776
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
9777
|
+
query["DryRun"] = request.dryRun;
|
|
9778
|
+
}
|
|
9779
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
9780
|
+
query["ListenerId"] = request.listenerId;
|
|
9781
|
+
}
|
|
9782
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9783
|
+
query["RegionId"] = request.regionId;
|
|
9784
|
+
}
|
|
8490
9785
|
let req = new $OpenApi.OpenApiRequest({
|
|
8491
9786
|
query: openapi_util_1.default.query(query),
|
|
8492
9787
|
});
|
|
@@ -8510,11 +9805,21 @@ class Client extends openapi_client_1.default {
|
|
|
8510
9805
|
async getSpareIpWithOptions(request, runtime) {
|
|
8511
9806
|
tea_util_1.default.validateModel(request);
|
|
8512
9807
|
let query = {};
|
|
8513
|
-
|
|
8514
|
-
|
|
8515
|
-
|
|
8516
|
-
|
|
8517
|
-
|
|
9808
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9809
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9810
|
+
}
|
|
9811
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9812
|
+
query["ClientToken"] = request.clientToken;
|
|
9813
|
+
}
|
|
9814
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
9815
|
+
query["DryRun"] = request.dryRun;
|
|
9816
|
+
}
|
|
9817
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9818
|
+
query["RegionId"] = request.regionId;
|
|
9819
|
+
}
|
|
9820
|
+
if (!tea_util_1.default.isUnset(request.spareIp)) {
|
|
9821
|
+
query["SpareIp"] = request.spareIp;
|
|
9822
|
+
}
|
|
8518
9823
|
let req = new $OpenApi.OpenApiRequest({
|
|
8519
9824
|
query: openapi_util_1.default.query(query),
|
|
8520
9825
|
});
|
|
@@ -8538,7 +9843,9 @@ class Client extends openapi_client_1.default {
|
|
|
8538
9843
|
async listAccelerateAreasWithOptions(request, runtime) {
|
|
8539
9844
|
tea_util_1.default.validateModel(request);
|
|
8540
9845
|
let query = {};
|
|
8541
|
-
|
|
9846
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9847
|
+
query["RegionId"] = request.regionId;
|
|
9848
|
+
}
|
|
8542
9849
|
let req = new $OpenApi.OpenApiRequest({
|
|
8543
9850
|
query: openapi_util_1.default.query(query),
|
|
8544
9851
|
});
|
|
@@ -8562,11 +9869,21 @@ class Client extends openapi_client_1.default {
|
|
|
8562
9869
|
async listAcceleratorsWithOptions(request, runtime) {
|
|
8563
9870
|
tea_util_1.default.validateModel(request);
|
|
8564
9871
|
let query = {};
|
|
8565
|
-
|
|
8566
|
-
|
|
8567
|
-
|
|
8568
|
-
|
|
8569
|
-
|
|
9872
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
9873
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
9874
|
+
}
|
|
9875
|
+
if (!tea_util_1.default.isUnset(request.pageNumber)) {
|
|
9876
|
+
query["PageNumber"] = request.pageNumber;
|
|
9877
|
+
}
|
|
9878
|
+
if (!tea_util_1.default.isUnset(request.pageSize)) {
|
|
9879
|
+
query["PageSize"] = request.pageSize;
|
|
9880
|
+
}
|
|
9881
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9882
|
+
query["RegionId"] = request.regionId;
|
|
9883
|
+
}
|
|
9884
|
+
if (!tea_util_1.default.isUnset(request.state)) {
|
|
9885
|
+
query["State"] = request.state;
|
|
9886
|
+
}
|
|
8570
9887
|
let req = new $OpenApi.OpenApiRequest({
|
|
8571
9888
|
query: openapi_util_1.default.query(query),
|
|
8572
9889
|
});
|
|
@@ -8590,12 +9907,24 @@ class Client extends openapi_client_1.default {
|
|
|
8590
9907
|
async listAclsWithOptions(request, runtime) {
|
|
8591
9908
|
tea_util_1.default.validateModel(request);
|
|
8592
9909
|
let query = {};
|
|
8593
|
-
|
|
8594
|
-
|
|
8595
|
-
|
|
8596
|
-
|
|
8597
|
-
|
|
8598
|
-
|
|
9910
|
+
if (!tea_util_1.default.isUnset(request.aclIds)) {
|
|
9911
|
+
query["AclIds"] = request.aclIds;
|
|
9912
|
+
}
|
|
9913
|
+
if (!tea_util_1.default.isUnset(request.aclName)) {
|
|
9914
|
+
query["AclName"] = request.aclName;
|
|
9915
|
+
}
|
|
9916
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
9917
|
+
query["ClientToken"] = request.clientToken;
|
|
9918
|
+
}
|
|
9919
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
9920
|
+
query["MaxResults"] = request.maxResults;
|
|
9921
|
+
}
|
|
9922
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
9923
|
+
query["NextToken"] = request.nextToken;
|
|
9924
|
+
}
|
|
9925
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9926
|
+
query["RegionId"] = request.regionId;
|
|
9927
|
+
}
|
|
8599
9928
|
let req = new $OpenApi.OpenApiRequest({
|
|
8600
9929
|
query: openapi_util_1.default.query(query),
|
|
8601
9930
|
});
|
|
@@ -8616,11 +9945,91 @@ class Client extends openapi_client_1.default {
|
|
|
8616
9945
|
let runtime = new $Util.RuntimeOptions({});
|
|
8617
9946
|
return await this.listAclsWithOptions(request, runtime);
|
|
8618
9947
|
}
|
|
9948
|
+
async listApplicationMonitorWithOptions(request, runtime) {
|
|
9949
|
+
tea_util_1.default.validateModel(request);
|
|
9950
|
+
let query = {};
|
|
9951
|
+
if (!tea_util_1.default.isUnset(request.pageNumber)) {
|
|
9952
|
+
query["PageNumber"] = request.pageNumber;
|
|
9953
|
+
}
|
|
9954
|
+
if (!tea_util_1.default.isUnset(request.pageSize)) {
|
|
9955
|
+
query["PageSize"] = request.pageSize;
|
|
9956
|
+
}
|
|
9957
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9958
|
+
query["RegionId"] = request.regionId;
|
|
9959
|
+
}
|
|
9960
|
+
if (!tea_util_1.default.isUnset(request.searchValue)) {
|
|
9961
|
+
query["SearchValue"] = request.searchValue;
|
|
9962
|
+
}
|
|
9963
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
9964
|
+
query: openapi_util_1.default.query(query),
|
|
9965
|
+
});
|
|
9966
|
+
let params = new $OpenApi.Params({
|
|
9967
|
+
action: "ListApplicationMonitor",
|
|
9968
|
+
version: "2019-11-20",
|
|
9969
|
+
protocol: "HTTPS",
|
|
9970
|
+
pathname: "/",
|
|
9971
|
+
method: "POST",
|
|
9972
|
+
authType: "AK",
|
|
9973
|
+
style: "RPC",
|
|
9974
|
+
reqBodyType: "formData",
|
|
9975
|
+
bodyType: "json",
|
|
9976
|
+
});
|
|
9977
|
+
return $tea.cast(await this.callApi(params, req, runtime), new ListApplicationMonitorResponse({}));
|
|
9978
|
+
}
|
|
9979
|
+
async listApplicationMonitor(request) {
|
|
9980
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
9981
|
+
return await this.listApplicationMonitorWithOptions(request, runtime);
|
|
9982
|
+
}
|
|
9983
|
+
async listApplicationMonitorDetectResultWithOptions(request, runtime) {
|
|
9984
|
+
tea_util_1.default.validateModel(request);
|
|
9985
|
+
let query = {};
|
|
9986
|
+
if (!tea_util_1.default.isUnset(request.beginTime)) {
|
|
9987
|
+
query["BeginTime"] = request.beginTime;
|
|
9988
|
+
}
|
|
9989
|
+
if (!tea_util_1.default.isUnset(request.endTime)) {
|
|
9990
|
+
query["EndTime"] = request.endTime;
|
|
9991
|
+
}
|
|
9992
|
+
if (!tea_util_1.default.isUnset(request.pageNumber)) {
|
|
9993
|
+
query["PageNumber"] = request.pageNumber;
|
|
9994
|
+
}
|
|
9995
|
+
if (!tea_util_1.default.isUnset(request.pageSize)) {
|
|
9996
|
+
query["PageSize"] = request.pageSize;
|
|
9997
|
+
}
|
|
9998
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
9999
|
+
query["RegionId"] = request.regionId;
|
|
10000
|
+
}
|
|
10001
|
+
if (!tea_util_1.default.isUnset(request.taskId)) {
|
|
10002
|
+
query["TaskId"] = request.taskId;
|
|
10003
|
+
}
|
|
10004
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
10005
|
+
query: openapi_util_1.default.query(query),
|
|
10006
|
+
});
|
|
10007
|
+
let params = new $OpenApi.Params({
|
|
10008
|
+
action: "ListApplicationMonitorDetectResult",
|
|
10009
|
+
version: "2019-11-20",
|
|
10010
|
+
protocol: "HTTPS",
|
|
10011
|
+
pathname: "/",
|
|
10012
|
+
method: "POST",
|
|
10013
|
+
authType: "AK",
|
|
10014
|
+
style: "RPC",
|
|
10015
|
+
reqBodyType: "formData",
|
|
10016
|
+
bodyType: "json",
|
|
10017
|
+
});
|
|
10018
|
+
return $tea.cast(await this.callApi(params, req, runtime), new ListApplicationMonitorDetectResultResponse({}));
|
|
10019
|
+
}
|
|
10020
|
+
async listApplicationMonitorDetectResult(request) {
|
|
10021
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
10022
|
+
return await this.listApplicationMonitorDetectResultWithOptions(request, runtime);
|
|
10023
|
+
}
|
|
8619
10024
|
async listAvailableAccelerateAreasWithOptions(request, runtime) {
|
|
8620
10025
|
tea_util_1.default.validateModel(request);
|
|
8621
10026
|
let query = {};
|
|
8622
|
-
|
|
8623
|
-
|
|
10027
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10028
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10029
|
+
}
|
|
10030
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10031
|
+
query["RegionId"] = request.regionId;
|
|
10032
|
+
}
|
|
8624
10033
|
let req = new $OpenApi.OpenApiRequest({
|
|
8625
10034
|
query: openapi_util_1.default.query(query),
|
|
8626
10035
|
});
|
|
@@ -8644,8 +10053,12 @@ class Client extends openapi_client_1.default {
|
|
|
8644
10053
|
async listAvailableBusiRegionsWithOptions(request, runtime) {
|
|
8645
10054
|
tea_util_1.default.validateModel(request);
|
|
8646
10055
|
let query = {};
|
|
8647
|
-
|
|
8648
|
-
|
|
10056
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10057
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10058
|
+
}
|
|
10059
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10060
|
+
query["RegionId"] = request.regionId;
|
|
10061
|
+
}
|
|
8649
10062
|
let req = new $OpenApi.OpenApiRequest({
|
|
8650
10063
|
query: openapi_util_1.default.query(query),
|
|
8651
10064
|
});
|
|
@@ -8669,12 +10082,24 @@ class Client extends openapi_client_1.default {
|
|
|
8669
10082
|
async listBandwidthPackagesWithOptions(request, runtime) {
|
|
8670
10083
|
tea_util_1.default.validateModel(request);
|
|
8671
10084
|
let query = {};
|
|
8672
|
-
|
|
8673
|
-
|
|
8674
|
-
|
|
8675
|
-
|
|
8676
|
-
|
|
8677
|
-
|
|
10085
|
+
if (!tea_util_1.default.isUnset(request.bandwidthPackageId)) {
|
|
10086
|
+
query["BandwidthPackageId"] = request.bandwidthPackageId;
|
|
10087
|
+
}
|
|
10088
|
+
if (!tea_util_1.default.isUnset(request.pageNumber)) {
|
|
10089
|
+
query["PageNumber"] = request.pageNumber;
|
|
10090
|
+
}
|
|
10091
|
+
if (!tea_util_1.default.isUnset(request.pageSize)) {
|
|
10092
|
+
query["PageSize"] = request.pageSize;
|
|
10093
|
+
}
|
|
10094
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10095
|
+
query["RegionId"] = request.regionId;
|
|
10096
|
+
}
|
|
10097
|
+
if (!tea_util_1.default.isUnset(request.state)) {
|
|
10098
|
+
query["State"] = request.state;
|
|
10099
|
+
}
|
|
10100
|
+
if (!tea_util_1.default.isUnset(request.type)) {
|
|
10101
|
+
query["Type"] = request.type;
|
|
10102
|
+
}
|
|
8678
10103
|
let req = new $OpenApi.OpenApiRequest({
|
|
8679
10104
|
query: openapi_util_1.default.query(query),
|
|
8680
10105
|
});
|
|
@@ -8698,9 +10123,15 @@ class Client extends openapi_client_1.default {
|
|
|
8698
10123
|
async listBandwidthackagesWithOptions(request, runtime) {
|
|
8699
10124
|
tea_util_1.default.validateModel(request);
|
|
8700
10125
|
let query = {};
|
|
8701
|
-
|
|
8702
|
-
|
|
8703
|
-
|
|
10126
|
+
if (!tea_util_1.default.isUnset(request.pageNumber)) {
|
|
10127
|
+
query["PageNumber"] = request.pageNumber;
|
|
10128
|
+
}
|
|
10129
|
+
if (!tea_util_1.default.isUnset(request.pageSize)) {
|
|
10130
|
+
query["PageSize"] = request.pageSize;
|
|
10131
|
+
}
|
|
10132
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10133
|
+
query["RegionId"] = request.regionId;
|
|
10134
|
+
}
|
|
8704
10135
|
let req = new $OpenApi.OpenApiRequest({
|
|
8705
10136
|
query: openapi_util_1.default.query(query),
|
|
8706
10137
|
});
|
|
@@ -8724,11 +10155,21 @@ class Client extends openapi_client_1.default {
|
|
|
8724
10155
|
async listBasicAcceleratorsWithOptions(request, runtime) {
|
|
8725
10156
|
tea_util_1.default.validateModel(request);
|
|
8726
10157
|
let query = {};
|
|
8727
|
-
|
|
8728
|
-
|
|
8729
|
-
|
|
8730
|
-
|
|
8731
|
-
|
|
10158
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10159
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10160
|
+
}
|
|
10161
|
+
if (!tea_util_1.default.isUnset(request.pageNumber)) {
|
|
10162
|
+
query["PageNumber"] = request.pageNumber;
|
|
10163
|
+
}
|
|
10164
|
+
if (!tea_util_1.default.isUnset(request.pageSize)) {
|
|
10165
|
+
query["PageSize"] = request.pageSize;
|
|
10166
|
+
}
|
|
10167
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10168
|
+
query["RegionId"] = request.regionId;
|
|
10169
|
+
}
|
|
10170
|
+
if (!tea_util_1.default.isUnset(request.state)) {
|
|
10171
|
+
query["State"] = request.state;
|
|
10172
|
+
}
|
|
8732
10173
|
let req = new $OpenApi.OpenApiRequest({
|
|
8733
10174
|
query: openapi_util_1.default.query(query),
|
|
8734
10175
|
});
|
|
@@ -8752,7 +10193,9 @@ class Client extends openapi_client_1.default {
|
|
|
8752
10193
|
async listBusiRegionsWithOptions(request, runtime) {
|
|
8753
10194
|
tea_util_1.default.validateModel(request);
|
|
8754
10195
|
let query = {};
|
|
8755
|
-
|
|
10196
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10197
|
+
query["RegionId"] = request.regionId;
|
|
10198
|
+
}
|
|
8756
10199
|
let req = new $OpenApi.OpenApiRequest({
|
|
8757
10200
|
query: openapi_util_1.default.query(query),
|
|
8758
10201
|
});
|
|
@@ -8776,14 +10219,30 @@ class Client extends openapi_client_1.default {
|
|
|
8776
10219
|
async listEndpointGroupsWithOptions(request, runtime) {
|
|
8777
10220
|
tea_util_1.default.validateModel(request);
|
|
8778
10221
|
let query = {};
|
|
8779
|
-
|
|
8780
|
-
|
|
8781
|
-
|
|
8782
|
-
|
|
8783
|
-
|
|
8784
|
-
|
|
8785
|
-
|
|
8786
|
-
|
|
10222
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10223
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10224
|
+
}
|
|
10225
|
+
if (!tea_util_1.default.isUnset(request.accessLogSwitch)) {
|
|
10226
|
+
query["AccessLogSwitch"] = request.accessLogSwitch;
|
|
10227
|
+
}
|
|
10228
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupId)) {
|
|
10229
|
+
query["EndpointGroupId"] = request.endpointGroupId;
|
|
10230
|
+
}
|
|
10231
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupType)) {
|
|
10232
|
+
query["EndpointGroupType"] = request.endpointGroupType;
|
|
10233
|
+
}
|
|
10234
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
10235
|
+
query["ListenerId"] = request.listenerId;
|
|
10236
|
+
}
|
|
10237
|
+
if (!tea_util_1.default.isUnset(request.pageNumber)) {
|
|
10238
|
+
query["PageNumber"] = request.pageNumber;
|
|
10239
|
+
}
|
|
10240
|
+
if (!tea_util_1.default.isUnset(request.pageSize)) {
|
|
10241
|
+
query["PageSize"] = request.pageSize;
|
|
10242
|
+
}
|
|
10243
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10244
|
+
query["RegionId"] = request.regionId;
|
|
10245
|
+
}
|
|
8787
10246
|
let req = new $OpenApi.OpenApiRequest({
|
|
8788
10247
|
query: openapi_util_1.default.query(query),
|
|
8789
10248
|
});
|
|
@@ -8807,13 +10266,27 @@ class Client extends openapi_client_1.default {
|
|
|
8807
10266
|
async listForwardingRulesWithOptions(request, runtime) {
|
|
8808
10267
|
tea_util_1.default.validateModel(request);
|
|
8809
10268
|
let query = {};
|
|
8810
|
-
|
|
8811
|
-
|
|
8812
|
-
|
|
8813
|
-
|
|
8814
|
-
|
|
8815
|
-
|
|
8816
|
-
|
|
10269
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10270
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10271
|
+
}
|
|
10272
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10273
|
+
query["ClientToken"] = request.clientToken;
|
|
10274
|
+
}
|
|
10275
|
+
if (!tea_util_1.default.isUnset(request.forwardingRuleId)) {
|
|
10276
|
+
query["ForwardingRuleId"] = request.forwardingRuleId;
|
|
10277
|
+
}
|
|
10278
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
10279
|
+
query["ListenerId"] = request.listenerId;
|
|
10280
|
+
}
|
|
10281
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
10282
|
+
query["MaxResults"] = request.maxResults;
|
|
10283
|
+
}
|
|
10284
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
10285
|
+
query["NextToken"] = request.nextToken;
|
|
10286
|
+
}
|
|
10287
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10288
|
+
query["RegionId"] = request.regionId;
|
|
10289
|
+
}
|
|
8817
10290
|
let req = new $OpenApi.OpenApiRequest({
|
|
8818
10291
|
query: openapi_util_1.default.query(query),
|
|
8819
10292
|
});
|
|
@@ -8837,10 +10310,18 @@ class Client extends openapi_client_1.default {
|
|
|
8837
10310
|
async listIpSetsWithOptions(request, runtime) {
|
|
8838
10311
|
tea_util_1.default.validateModel(request);
|
|
8839
10312
|
let query = {};
|
|
8840
|
-
|
|
8841
|
-
|
|
8842
|
-
|
|
8843
|
-
|
|
10313
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10314
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10315
|
+
}
|
|
10316
|
+
if (!tea_util_1.default.isUnset(request.pageNumber)) {
|
|
10317
|
+
query["PageNumber"] = request.pageNumber;
|
|
10318
|
+
}
|
|
10319
|
+
if (!tea_util_1.default.isUnset(request.pageSize)) {
|
|
10320
|
+
query["PageSize"] = request.pageSize;
|
|
10321
|
+
}
|
|
10322
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10323
|
+
query["RegionId"] = request.regionId;
|
|
10324
|
+
}
|
|
8844
10325
|
let req = new $OpenApi.OpenApiRequest({
|
|
8845
10326
|
query: openapi_util_1.default.query(query),
|
|
8846
10327
|
});
|
|
@@ -8864,12 +10345,24 @@ class Client extends openapi_client_1.default {
|
|
|
8864
10345
|
async listListenerCertificatesWithOptions(request, runtime) {
|
|
8865
10346
|
tea_util_1.default.validateModel(request);
|
|
8866
10347
|
let query = {};
|
|
8867
|
-
|
|
8868
|
-
|
|
8869
|
-
|
|
8870
|
-
|
|
8871
|
-
|
|
8872
|
-
|
|
10348
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10349
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10350
|
+
}
|
|
10351
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
10352
|
+
query["ListenerId"] = request.listenerId;
|
|
10353
|
+
}
|
|
10354
|
+
if (!tea_util_1.default.isUnset(request.maxResults)) {
|
|
10355
|
+
query["MaxResults"] = request.maxResults;
|
|
10356
|
+
}
|
|
10357
|
+
if (!tea_util_1.default.isUnset(request.nextToken)) {
|
|
10358
|
+
query["NextToken"] = request.nextToken;
|
|
10359
|
+
}
|
|
10360
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10361
|
+
query["RegionId"] = request.regionId;
|
|
10362
|
+
}
|
|
10363
|
+
if (!tea_util_1.default.isUnset(request.role)) {
|
|
10364
|
+
query["Role"] = request.role;
|
|
10365
|
+
}
|
|
8873
10366
|
let req = new $OpenApi.OpenApiRequest({
|
|
8874
10367
|
query: openapi_util_1.default.query(query),
|
|
8875
10368
|
});
|
|
@@ -8893,10 +10386,18 @@ class Client extends openapi_client_1.default {
|
|
|
8893
10386
|
async listListenersWithOptions(request, runtime) {
|
|
8894
10387
|
tea_util_1.default.validateModel(request);
|
|
8895
10388
|
let query = {};
|
|
8896
|
-
|
|
8897
|
-
|
|
8898
|
-
|
|
8899
|
-
|
|
10389
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10390
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10391
|
+
}
|
|
10392
|
+
if (!tea_util_1.default.isUnset(request.pageNumber)) {
|
|
10393
|
+
query["PageNumber"] = request.pageNumber;
|
|
10394
|
+
}
|
|
10395
|
+
if (!tea_util_1.default.isUnset(request.pageSize)) {
|
|
10396
|
+
query["PageSize"] = request.pageSize;
|
|
10397
|
+
}
|
|
10398
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10399
|
+
query["RegionId"] = request.regionId;
|
|
10400
|
+
}
|
|
8900
10401
|
let req = new $OpenApi.OpenApiRequest({
|
|
8901
10402
|
query: openapi_util_1.default.query(query),
|
|
8902
10403
|
});
|
|
@@ -8920,10 +10421,18 @@ class Client extends openapi_client_1.default {
|
|
|
8920
10421
|
async listSpareIpsWithOptions(request, runtime) {
|
|
8921
10422
|
tea_util_1.default.validateModel(request);
|
|
8922
10423
|
let query = {};
|
|
8923
|
-
|
|
8924
|
-
|
|
8925
|
-
|
|
8926
|
-
|
|
10424
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10425
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10426
|
+
}
|
|
10427
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10428
|
+
query["ClientToken"] = request.clientToken;
|
|
10429
|
+
}
|
|
10430
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
10431
|
+
query["DryRun"] = request.dryRun;
|
|
10432
|
+
}
|
|
10433
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10434
|
+
query["RegionId"] = request.regionId;
|
|
10435
|
+
}
|
|
8927
10436
|
let req = new $OpenApi.OpenApiRequest({
|
|
8928
10437
|
query: openapi_util_1.default.query(query),
|
|
8929
10438
|
});
|
|
@@ -8947,9 +10456,15 @@ class Client extends openapi_client_1.default {
|
|
|
8947
10456
|
async listSystemSecurityPoliciesWithOptions(request, runtime) {
|
|
8948
10457
|
tea_util_1.default.validateModel(request);
|
|
8949
10458
|
let query = {};
|
|
8950
|
-
|
|
8951
|
-
|
|
8952
|
-
|
|
10459
|
+
if (!tea_util_1.default.isUnset(request.pageNumber)) {
|
|
10460
|
+
query["PageNumber"] = request.pageNumber;
|
|
10461
|
+
}
|
|
10462
|
+
if (!tea_util_1.default.isUnset(request.pageSize)) {
|
|
10463
|
+
query["PageSize"] = request.pageSize;
|
|
10464
|
+
}
|
|
10465
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10466
|
+
query["RegionId"] = request.regionId;
|
|
10467
|
+
}
|
|
8953
10468
|
let req = new $OpenApi.OpenApiRequest({
|
|
8954
10469
|
query: openapi_util_1.default.query(query),
|
|
8955
10470
|
});
|
|
@@ -8973,11 +10488,21 @@ class Client extends openapi_client_1.default {
|
|
|
8973
10488
|
async removeEntriesFromAclWithOptions(request, runtime) {
|
|
8974
10489
|
tea_util_1.default.validateModel(request);
|
|
8975
10490
|
let query = {};
|
|
8976
|
-
|
|
8977
|
-
|
|
8978
|
-
|
|
8979
|
-
|
|
8980
|
-
|
|
10491
|
+
if (!tea_util_1.default.isUnset(request.aclEntries)) {
|
|
10492
|
+
query["AclEntries"] = request.aclEntries;
|
|
10493
|
+
}
|
|
10494
|
+
if (!tea_util_1.default.isUnset(request.aclId)) {
|
|
10495
|
+
query["AclId"] = request.aclId;
|
|
10496
|
+
}
|
|
10497
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10498
|
+
query["ClientToken"] = request.clientToken;
|
|
10499
|
+
}
|
|
10500
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
10501
|
+
query["DryRun"] = request.dryRun;
|
|
10502
|
+
}
|
|
10503
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10504
|
+
query["RegionId"] = request.regionId;
|
|
10505
|
+
}
|
|
8981
10506
|
let req = new $OpenApi.OpenApiRequest({
|
|
8982
10507
|
query: openapi_util_1.default.query(query),
|
|
8983
10508
|
});
|
|
@@ -9001,9 +10526,15 @@ class Client extends openapi_client_1.default {
|
|
|
9001
10526
|
async replaceBandwidthPackageWithOptions(request, runtime) {
|
|
9002
10527
|
tea_util_1.default.validateModel(request);
|
|
9003
10528
|
let query = {};
|
|
9004
|
-
|
|
9005
|
-
|
|
9006
|
-
|
|
10529
|
+
if (!tea_util_1.default.isUnset(request.bandwidthPackageId)) {
|
|
10530
|
+
query["BandwidthPackageId"] = request.bandwidthPackageId;
|
|
10531
|
+
}
|
|
10532
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10533
|
+
query["RegionId"] = request.regionId;
|
|
10534
|
+
}
|
|
10535
|
+
if (!tea_util_1.default.isUnset(request.targetBandwidthPackageId)) {
|
|
10536
|
+
query["TargetBandwidthPackageId"] = request.targetBandwidthPackageId;
|
|
10537
|
+
}
|
|
9007
10538
|
let req = new $OpenApi.OpenApiRequest({
|
|
9008
10539
|
query: openapi_util_1.default.query(query),
|
|
9009
10540
|
});
|
|
@@ -9027,14 +10558,30 @@ class Client extends openapi_client_1.default {
|
|
|
9027
10558
|
async updateAcceleratorWithOptions(request, runtime) {
|
|
9028
10559
|
tea_util_1.default.validateModel(request);
|
|
9029
10560
|
let query = {};
|
|
9030
|
-
|
|
9031
|
-
|
|
9032
|
-
|
|
9033
|
-
|
|
9034
|
-
|
|
9035
|
-
|
|
9036
|
-
|
|
9037
|
-
|
|
10561
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10562
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10563
|
+
}
|
|
10564
|
+
if (!tea_util_1.default.isUnset(request.autoPay)) {
|
|
10565
|
+
query["AutoPay"] = request.autoPay;
|
|
10566
|
+
}
|
|
10567
|
+
if (!tea_util_1.default.isUnset(request.autoUseCoupon)) {
|
|
10568
|
+
query["AutoUseCoupon"] = request.autoUseCoupon;
|
|
10569
|
+
}
|
|
10570
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10571
|
+
query["ClientToken"] = request.clientToken;
|
|
10572
|
+
}
|
|
10573
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
10574
|
+
query["Description"] = request.description;
|
|
10575
|
+
}
|
|
10576
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
10577
|
+
query["Name"] = request.name;
|
|
10578
|
+
}
|
|
10579
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10580
|
+
query["RegionId"] = request.regionId;
|
|
10581
|
+
}
|
|
10582
|
+
if (!tea_util_1.default.isUnset(request.spec)) {
|
|
10583
|
+
query["Spec"] = request.spec;
|
|
10584
|
+
}
|
|
9038
10585
|
let req = new $OpenApi.OpenApiRequest({
|
|
9039
10586
|
query: openapi_util_1.default.query(query),
|
|
9040
10587
|
});
|
|
@@ -9058,13 +10605,27 @@ class Client extends openapi_client_1.default {
|
|
|
9058
10605
|
async updateAcceleratorAutoRenewAttributeWithOptions(request, runtime) {
|
|
9059
10606
|
tea_util_1.default.validateModel(request);
|
|
9060
10607
|
let query = {};
|
|
9061
|
-
|
|
9062
|
-
|
|
9063
|
-
|
|
9064
|
-
|
|
9065
|
-
|
|
9066
|
-
|
|
9067
|
-
|
|
10608
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10609
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10610
|
+
}
|
|
10611
|
+
if (!tea_util_1.default.isUnset(request.autoRenew)) {
|
|
10612
|
+
query["AutoRenew"] = request.autoRenew;
|
|
10613
|
+
}
|
|
10614
|
+
if (!tea_util_1.default.isUnset(request.autoRenewDuration)) {
|
|
10615
|
+
query["AutoRenewDuration"] = request.autoRenewDuration;
|
|
10616
|
+
}
|
|
10617
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10618
|
+
query["ClientToken"] = request.clientToken;
|
|
10619
|
+
}
|
|
10620
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
10621
|
+
query["Name"] = request.name;
|
|
10622
|
+
}
|
|
10623
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10624
|
+
query["RegionId"] = request.regionId;
|
|
10625
|
+
}
|
|
10626
|
+
if (!tea_util_1.default.isUnset(request.renewalStatus)) {
|
|
10627
|
+
query["RenewalStatus"] = request.renewalStatus;
|
|
10628
|
+
}
|
|
9068
10629
|
let req = new $OpenApi.OpenApiRequest({
|
|
9069
10630
|
query: openapi_util_1.default.query(query),
|
|
9070
10631
|
});
|
|
@@ -9088,8 +10649,12 @@ class Client extends openapi_client_1.default {
|
|
|
9088
10649
|
async updateAcceleratorConfirmWithOptions(request, runtime) {
|
|
9089
10650
|
tea_util_1.default.validateModel(request);
|
|
9090
10651
|
let query = {};
|
|
9091
|
-
|
|
9092
|
-
|
|
10652
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10653
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10654
|
+
}
|
|
10655
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10656
|
+
query["RegionId"] = request.regionId;
|
|
10657
|
+
}
|
|
9093
10658
|
let req = new $OpenApi.OpenApiRequest({
|
|
9094
10659
|
query: openapi_util_1.default.query(query),
|
|
9095
10660
|
});
|
|
@@ -9113,11 +10678,21 @@ class Client extends openapi_client_1.default {
|
|
|
9113
10678
|
async updateAclAttributeWithOptions(request, runtime) {
|
|
9114
10679
|
tea_util_1.default.validateModel(request);
|
|
9115
10680
|
let query = {};
|
|
9116
|
-
|
|
9117
|
-
|
|
9118
|
-
|
|
9119
|
-
|
|
9120
|
-
|
|
10681
|
+
if (!tea_util_1.default.isUnset(request.aclId)) {
|
|
10682
|
+
query["AclId"] = request.aclId;
|
|
10683
|
+
}
|
|
10684
|
+
if (!tea_util_1.default.isUnset(request.aclName)) {
|
|
10685
|
+
query["AclName"] = request.aclName;
|
|
10686
|
+
}
|
|
10687
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10688
|
+
query["ClientToken"] = request.clientToken;
|
|
10689
|
+
}
|
|
10690
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
10691
|
+
query["DryRun"] = request.dryRun;
|
|
10692
|
+
}
|
|
10693
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10694
|
+
query["RegionId"] = request.regionId;
|
|
10695
|
+
}
|
|
9121
10696
|
let req = new $OpenApi.OpenApiRequest({
|
|
9122
10697
|
query: openapi_util_1.default.query(query),
|
|
9123
10698
|
});
|
|
@@ -9138,17 +10713,80 @@ class Client extends openapi_client_1.default {
|
|
|
9138
10713
|
let runtime = new $Util.RuntimeOptions({});
|
|
9139
10714
|
return await this.updateAclAttributeWithOptions(request, runtime);
|
|
9140
10715
|
}
|
|
10716
|
+
async updateApplicationMonitorWithOptions(request, runtime) {
|
|
10717
|
+
tea_util_1.default.validateModel(request);
|
|
10718
|
+
let query = {};
|
|
10719
|
+
if (!tea_util_1.default.isUnset(request.address)) {
|
|
10720
|
+
query["Address"] = request.address;
|
|
10721
|
+
}
|
|
10722
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10723
|
+
query["ClientToken"] = request.clientToken;
|
|
10724
|
+
}
|
|
10725
|
+
if (!tea_util_1.default.isUnset(request.detectThreshold)) {
|
|
10726
|
+
query["DetectThreshold"] = request.detectThreshold;
|
|
10727
|
+
}
|
|
10728
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
10729
|
+
query["ListenerId"] = request.listenerId;
|
|
10730
|
+
}
|
|
10731
|
+
if (!tea_util_1.default.isUnset(request.optionsJson)) {
|
|
10732
|
+
query["OptionsJson"] = request.optionsJson;
|
|
10733
|
+
}
|
|
10734
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10735
|
+
query["RegionId"] = request.regionId;
|
|
10736
|
+
}
|
|
10737
|
+
if (!tea_util_1.default.isUnset(request.taskId)) {
|
|
10738
|
+
query["TaskId"] = request.taskId;
|
|
10739
|
+
}
|
|
10740
|
+
if (!tea_util_1.default.isUnset(request.taskName)) {
|
|
10741
|
+
query["TaskName"] = request.taskName;
|
|
10742
|
+
}
|
|
10743
|
+
let req = new $OpenApi.OpenApiRequest({
|
|
10744
|
+
query: openapi_util_1.default.query(query),
|
|
10745
|
+
});
|
|
10746
|
+
let params = new $OpenApi.Params({
|
|
10747
|
+
action: "UpdateApplicationMonitor",
|
|
10748
|
+
version: "2019-11-20",
|
|
10749
|
+
protocol: "HTTPS",
|
|
10750
|
+
pathname: "/",
|
|
10751
|
+
method: "POST",
|
|
10752
|
+
authType: "AK",
|
|
10753
|
+
style: "RPC",
|
|
10754
|
+
reqBodyType: "formData",
|
|
10755
|
+
bodyType: "json",
|
|
10756
|
+
});
|
|
10757
|
+
return $tea.cast(await this.callApi(params, req, runtime), new UpdateApplicationMonitorResponse({}));
|
|
10758
|
+
}
|
|
10759
|
+
async updateApplicationMonitor(request) {
|
|
10760
|
+
let runtime = new $Util.RuntimeOptions({});
|
|
10761
|
+
return await this.updateApplicationMonitorWithOptions(request, runtime);
|
|
10762
|
+
}
|
|
9141
10763
|
async updateBandwidthPackageWithOptions(request, runtime) {
|
|
9142
10764
|
tea_util_1.default.validateModel(request);
|
|
9143
10765
|
let query = {};
|
|
9144
|
-
|
|
9145
|
-
|
|
9146
|
-
|
|
9147
|
-
|
|
9148
|
-
|
|
9149
|
-
|
|
9150
|
-
|
|
9151
|
-
|
|
10766
|
+
if (!tea_util_1.default.isUnset(request.autoPay)) {
|
|
10767
|
+
query["AutoPay"] = request.autoPay;
|
|
10768
|
+
}
|
|
10769
|
+
if (!tea_util_1.default.isUnset(request.autoUseCoupon)) {
|
|
10770
|
+
query["AutoUseCoupon"] = request.autoUseCoupon;
|
|
10771
|
+
}
|
|
10772
|
+
if (!tea_util_1.default.isUnset(request.bandwidth)) {
|
|
10773
|
+
query["Bandwidth"] = request.bandwidth;
|
|
10774
|
+
}
|
|
10775
|
+
if (!tea_util_1.default.isUnset(request.bandwidthPackageId)) {
|
|
10776
|
+
query["BandwidthPackageId"] = request.bandwidthPackageId;
|
|
10777
|
+
}
|
|
10778
|
+
if (!tea_util_1.default.isUnset(request.bandwidthType)) {
|
|
10779
|
+
query["BandwidthType"] = request.bandwidthType;
|
|
10780
|
+
}
|
|
10781
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
10782
|
+
query["Description"] = request.description;
|
|
10783
|
+
}
|
|
10784
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
10785
|
+
query["Name"] = request.name;
|
|
10786
|
+
}
|
|
10787
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10788
|
+
query["RegionId"] = request.regionId;
|
|
10789
|
+
}
|
|
9152
10790
|
let req = new $OpenApi.OpenApiRequest({
|
|
9153
10791
|
query: openapi_util_1.default.query(query),
|
|
9154
10792
|
});
|
|
@@ -9172,11 +10810,21 @@ class Client extends openapi_client_1.default {
|
|
|
9172
10810
|
async updateBasicAcceleratorWithOptions(request, runtime) {
|
|
9173
10811
|
tea_util_1.default.validateModel(request);
|
|
9174
10812
|
let query = {};
|
|
9175
|
-
|
|
9176
|
-
|
|
9177
|
-
|
|
9178
|
-
|
|
9179
|
-
|
|
10813
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
10814
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
10815
|
+
}
|
|
10816
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10817
|
+
query["ClientToken"] = request.clientToken;
|
|
10818
|
+
}
|
|
10819
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
10820
|
+
query["Description"] = request.description;
|
|
10821
|
+
}
|
|
10822
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
10823
|
+
query["Name"] = request.name;
|
|
10824
|
+
}
|
|
10825
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10826
|
+
query["RegionId"] = request.regionId;
|
|
10827
|
+
}
|
|
9180
10828
|
let req = new $OpenApi.OpenApiRequest({
|
|
9181
10829
|
query: openapi_util_1.default.query(query),
|
|
9182
10830
|
});
|
|
@@ -9200,13 +10848,27 @@ class Client extends openapi_client_1.default {
|
|
|
9200
10848
|
async updateBasicEndpointGroupWithOptions(request, runtime) {
|
|
9201
10849
|
tea_util_1.default.validateModel(request);
|
|
9202
10850
|
let query = {};
|
|
9203
|
-
|
|
9204
|
-
|
|
9205
|
-
|
|
9206
|
-
|
|
9207
|
-
|
|
9208
|
-
|
|
9209
|
-
|
|
10851
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10852
|
+
query["ClientToken"] = request.clientToken;
|
|
10853
|
+
}
|
|
10854
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
10855
|
+
query["Description"] = request.description;
|
|
10856
|
+
}
|
|
10857
|
+
if (!tea_util_1.default.isUnset(request.endpointAddress)) {
|
|
10858
|
+
query["EndpointAddress"] = request.endpointAddress;
|
|
10859
|
+
}
|
|
10860
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupId)) {
|
|
10861
|
+
query["EndpointGroupId"] = request.endpointGroupId;
|
|
10862
|
+
}
|
|
10863
|
+
if (!tea_util_1.default.isUnset(request.endpointType)) {
|
|
10864
|
+
query["EndpointType"] = request.endpointType;
|
|
10865
|
+
}
|
|
10866
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
10867
|
+
query["Name"] = request.name;
|
|
10868
|
+
}
|
|
10869
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10870
|
+
query["RegionId"] = request.regionId;
|
|
10871
|
+
}
|
|
9210
10872
|
let req = new $OpenApi.OpenApiRequest({
|
|
9211
10873
|
query: openapi_util_1.default.query(query),
|
|
9212
10874
|
});
|
|
@@ -9230,22 +10892,54 @@ class Client extends openapi_client_1.default {
|
|
|
9230
10892
|
async updateEndpointGroupWithOptions(request, runtime) {
|
|
9231
10893
|
tea_util_1.default.validateModel(request);
|
|
9232
10894
|
let query = {};
|
|
9233
|
-
|
|
9234
|
-
|
|
9235
|
-
|
|
9236
|
-
|
|
9237
|
-
|
|
9238
|
-
|
|
9239
|
-
|
|
9240
|
-
|
|
9241
|
-
|
|
9242
|
-
|
|
9243
|
-
|
|
9244
|
-
|
|
9245
|
-
|
|
9246
|
-
|
|
9247
|
-
|
|
9248
|
-
|
|
10895
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10896
|
+
query["ClientToken"] = request.clientToken;
|
|
10897
|
+
}
|
|
10898
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
10899
|
+
query["Description"] = request.description;
|
|
10900
|
+
}
|
|
10901
|
+
if (!tea_util_1.default.isUnset(request.endpointConfigurations)) {
|
|
10902
|
+
query["EndpointConfigurations"] = request.endpointConfigurations;
|
|
10903
|
+
}
|
|
10904
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupId)) {
|
|
10905
|
+
query["EndpointGroupId"] = request.endpointGroupId;
|
|
10906
|
+
}
|
|
10907
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupRegion)) {
|
|
10908
|
+
query["EndpointGroupRegion"] = request.endpointGroupRegion;
|
|
10909
|
+
}
|
|
10910
|
+
if (!tea_util_1.default.isUnset(request.endpointRequestProtocol)) {
|
|
10911
|
+
query["EndpointRequestProtocol"] = request.endpointRequestProtocol;
|
|
10912
|
+
}
|
|
10913
|
+
if (!tea_util_1.default.isUnset(request.healthCheckEnabled)) {
|
|
10914
|
+
query["HealthCheckEnabled"] = request.healthCheckEnabled;
|
|
10915
|
+
}
|
|
10916
|
+
if (!tea_util_1.default.isUnset(request.healthCheckIntervalSeconds)) {
|
|
10917
|
+
query["HealthCheckIntervalSeconds"] = request.healthCheckIntervalSeconds;
|
|
10918
|
+
}
|
|
10919
|
+
if (!tea_util_1.default.isUnset(request.healthCheckPath)) {
|
|
10920
|
+
query["HealthCheckPath"] = request.healthCheckPath;
|
|
10921
|
+
}
|
|
10922
|
+
if (!tea_util_1.default.isUnset(request.healthCheckPort)) {
|
|
10923
|
+
query["HealthCheckPort"] = request.healthCheckPort;
|
|
10924
|
+
}
|
|
10925
|
+
if (!tea_util_1.default.isUnset(request.healthCheckProtocol)) {
|
|
10926
|
+
query["HealthCheckProtocol"] = request.healthCheckProtocol;
|
|
10927
|
+
}
|
|
10928
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
10929
|
+
query["Name"] = request.name;
|
|
10930
|
+
}
|
|
10931
|
+
if (!tea_util_1.default.isUnset(request.portOverrides)) {
|
|
10932
|
+
query["PortOverrides"] = request.portOverrides;
|
|
10933
|
+
}
|
|
10934
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10935
|
+
query["RegionId"] = request.regionId;
|
|
10936
|
+
}
|
|
10937
|
+
if (!tea_util_1.default.isUnset(request.thresholdCount)) {
|
|
10938
|
+
query["ThresholdCount"] = request.thresholdCount;
|
|
10939
|
+
}
|
|
10940
|
+
if (!tea_util_1.default.isUnset(request.trafficPercentage)) {
|
|
10941
|
+
query["TrafficPercentage"] = request.trafficPercentage;
|
|
10942
|
+
}
|
|
9249
10943
|
let req = new $OpenApi.OpenApiRequest({
|
|
9250
10944
|
query: openapi_util_1.default.query(query),
|
|
9251
10945
|
});
|
|
@@ -9269,11 +10963,21 @@ class Client extends openapi_client_1.default {
|
|
|
9269
10963
|
async updateEndpointGroupAttributeWithOptions(request, runtime) {
|
|
9270
10964
|
tea_util_1.default.validateModel(request);
|
|
9271
10965
|
let query = {};
|
|
9272
|
-
|
|
9273
|
-
|
|
9274
|
-
|
|
9275
|
-
|
|
9276
|
-
|
|
10966
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
10967
|
+
query["ClientToken"] = request.clientToken;
|
|
10968
|
+
}
|
|
10969
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
10970
|
+
query["Description"] = request.description;
|
|
10971
|
+
}
|
|
10972
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupId)) {
|
|
10973
|
+
query["EndpointGroupId"] = request.endpointGroupId;
|
|
10974
|
+
}
|
|
10975
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
10976
|
+
query["Name"] = request.name;
|
|
10977
|
+
}
|
|
10978
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
10979
|
+
query["RegionId"] = request.regionId;
|
|
10980
|
+
}
|
|
9277
10981
|
let req = new $OpenApi.OpenApiRequest({
|
|
9278
10982
|
query: openapi_util_1.default.query(query),
|
|
9279
10983
|
});
|
|
@@ -9297,11 +11001,21 @@ class Client extends openapi_client_1.default {
|
|
|
9297
11001
|
async updateEndpointGroupsWithOptions(request, runtime) {
|
|
9298
11002
|
tea_util_1.default.validateModel(request);
|
|
9299
11003
|
let query = {};
|
|
9300
|
-
|
|
9301
|
-
|
|
9302
|
-
|
|
9303
|
-
|
|
9304
|
-
|
|
11004
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
11005
|
+
query["ClientToken"] = request.clientToken;
|
|
11006
|
+
}
|
|
11007
|
+
if (!tea_util_1.default.isUnset(request.dryRun)) {
|
|
11008
|
+
query["DryRun"] = request.dryRun;
|
|
11009
|
+
}
|
|
11010
|
+
if (!tea_util_1.default.isUnset(request.endpointGroupConfigurations)) {
|
|
11011
|
+
query["EndpointGroupConfigurations"] = request.endpointGroupConfigurations;
|
|
11012
|
+
}
|
|
11013
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
11014
|
+
query["ListenerId"] = request.listenerId;
|
|
11015
|
+
}
|
|
11016
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
11017
|
+
query["RegionId"] = request.regionId;
|
|
11018
|
+
}
|
|
9305
11019
|
let req = new $OpenApi.OpenApiRequest({
|
|
9306
11020
|
query: openapi_util_1.default.query(query),
|
|
9307
11021
|
});
|
|
@@ -9325,11 +11039,21 @@ class Client extends openapi_client_1.default {
|
|
|
9325
11039
|
async updateForwardingRulesWithOptions(request, runtime) {
|
|
9326
11040
|
tea_util_1.default.validateModel(request);
|
|
9327
11041
|
let query = {};
|
|
9328
|
-
|
|
9329
|
-
|
|
9330
|
-
|
|
9331
|
-
|
|
9332
|
-
|
|
11042
|
+
if (!tea_util_1.default.isUnset(request.acceleratorId)) {
|
|
11043
|
+
query["AcceleratorId"] = request.acceleratorId;
|
|
11044
|
+
}
|
|
11045
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
11046
|
+
query["ClientToken"] = request.clientToken;
|
|
11047
|
+
}
|
|
11048
|
+
if (!tea_util_1.default.isUnset(request.forwardingRules)) {
|
|
11049
|
+
query["ForwardingRules"] = request.forwardingRules;
|
|
11050
|
+
}
|
|
11051
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
11052
|
+
query["ListenerId"] = request.listenerId;
|
|
11053
|
+
}
|
|
11054
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
11055
|
+
query["RegionId"] = request.regionId;
|
|
11056
|
+
}
|
|
9333
11057
|
let req = new $OpenApi.OpenApiRequest({
|
|
9334
11058
|
query: openapi_util_1.default.query(query),
|
|
9335
11059
|
});
|
|
@@ -9353,10 +11077,18 @@ class Client extends openapi_client_1.default {
|
|
|
9353
11077
|
async updateIpSetWithOptions(request, runtime) {
|
|
9354
11078
|
tea_util_1.default.validateModel(request);
|
|
9355
11079
|
let query = {};
|
|
9356
|
-
|
|
9357
|
-
|
|
9358
|
-
|
|
9359
|
-
|
|
11080
|
+
if (!tea_util_1.default.isUnset(request.bandwidth)) {
|
|
11081
|
+
query["Bandwidth"] = request.bandwidth;
|
|
11082
|
+
}
|
|
11083
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
11084
|
+
query["ClientToken"] = request.clientToken;
|
|
11085
|
+
}
|
|
11086
|
+
if (!tea_util_1.default.isUnset(request.ipSetId)) {
|
|
11087
|
+
query["IpSetId"] = request.ipSetId;
|
|
11088
|
+
}
|
|
11089
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
11090
|
+
query["RegionId"] = request.regionId;
|
|
11091
|
+
}
|
|
9360
11092
|
let req = new $OpenApi.OpenApiRequest({
|
|
9361
11093
|
query: openapi_util_1.default.query(query),
|
|
9362
11094
|
});
|
|
@@ -9380,8 +11112,12 @@ class Client extends openapi_client_1.default {
|
|
|
9380
11112
|
async updateIpSetsWithOptions(request, runtime) {
|
|
9381
11113
|
tea_util_1.default.validateModel(request);
|
|
9382
11114
|
let query = {};
|
|
9383
|
-
|
|
9384
|
-
|
|
11115
|
+
if (!tea_util_1.default.isUnset(request.ipSets)) {
|
|
11116
|
+
query["IpSets"] = request.ipSets;
|
|
11117
|
+
}
|
|
11118
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
11119
|
+
query["RegionId"] = request.regionId;
|
|
11120
|
+
}
|
|
9385
11121
|
let req = new $OpenApi.OpenApiRequest({
|
|
9386
11122
|
query: openapi_util_1.default.query(query),
|
|
9387
11123
|
});
|
|
@@ -9405,19 +11141,45 @@ class Client extends openapi_client_1.default {
|
|
|
9405
11141
|
async updateListenerWithOptions(request, runtime) {
|
|
9406
11142
|
tea_util_1.default.validateModel(request);
|
|
9407
11143
|
let query = {};
|
|
9408
|
-
|
|
9409
|
-
|
|
9410
|
-
|
|
9411
|
-
|
|
9412
|
-
|
|
9413
|
-
|
|
9414
|
-
|
|
9415
|
-
|
|
9416
|
-
|
|
9417
|
-
|
|
9418
|
-
|
|
9419
|
-
|
|
9420
|
-
|
|
11144
|
+
if (!tea_util_1.default.isUnset(request.backendPorts)) {
|
|
11145
|
+
query["BackendPorts"] = request.backendPorts;
|
|
11146
|
+
}
|
|
11147
|
+
if (!tea_util_1.default.isUnset(request.certificates)) {
|
|
11148
|
+
query["Certificates"] = request.certificates;
|
|
11149
|
+
}
|
|
11150
|
+
if (!tea_util_1.default.isUnset(request.clientAffinity)) {
|
|
11151
|
+
query["ClientAffinity"] = request.clientAffinity;
|
|
11152
|
+
}
|
|
11153
|
+
if (!tea_util_1.default.isUnset(request.clientToken)) {
|
|
11154
|
+
query["ClientToken"] = request.clientToken;
|
|
11155
|
+
}
|
|
11156
|
+
if (!tea_util_1.default.isUnset(request.description)) {
|
|
11157
|
+
query["Description"] = request.description;
|
|
11158
|
+
}
|
|
11159
|
+
if (!tea_util_1.default.isUnset(request.listenerId)) {
|
|
11160
|
+
query["ListenerId"] = request.listenerId;
|
|
11161
|
+
}
|
|
11162
|
+
if (!tea_util_1.default.isUnset(request.name)) {
|
|
11163
|
+
query["Name"] = request.name;
|
|
11164
|
+
}
|
|
11165
|
+
if (!tea_util_1.default.isUnset(request.portRanges)) {
|
|
11166
|
+
query["PortRanges"] = request.portRanges;
|
|
11167
|
+
}
|
|
11168
|
+
if (!tea_util_1.default.isUnset(request.protocol)) {
|
|
11169
|
+
query["Protocol"] = request.protocol;
|
|
11170
|
+
}
|
|
11171
|
+
if (!tea_util_1.default.isUnset(request.proxyProtocol)) {
|
|
11172
|
+
query["ProxyProtocol"] = request.proxyProtocol;
|
|
11173
|
+
}
|
|
11174
|
+
if (!tea_util_1.default.isUnset(request.regionId)) {
|
|
11175
|
+
query["RegionId"] = request.regionId;
|
|
11176
|
+
}
|
|
11177
|
+
if (!tea_util_1.default.isUnset(request.securityPolicyId)) {
|
|
11178
|
+
query["SecurityPolicyId"] = request.securityPolicyId;
|
|
11179
|
+
}
|
|
11180
|
+
if (!tea_util_1.default.isUnset($tea.toMap(request.XForwardedForConfig))) {
|
|
11181
|
+
query["XForwardedForConfig"] = request.XForwardedForConfig;
|
|
11182
|
+
}
|
|
9421
11183
|
let req = new $OpenApi.OpenApiRequest({
|
|
9422
11184
|
query: openapi_util_1.default.query(query),
|
|
9423
11185
|
});
|