@alicloud/esa20240910 2.8.2 → 2.8.3

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/src/client.ts CHANGED
@@ -112,7 +112,6 @@ export class WafRuleConfig extends $tea.Model {
112
112
  managedGroupId?: number;
113
113
  managedList?: string;
114
114
  managedRulesets?: WafRuleConfigManagedRulesets[];
115
- match?: WafRuleMatch;
116
115
  name?: string;
117
116
  notes?: string;
118
117
  rateLimit?: WafRuleConfigRateLimit;
@@ -132,7 +131,6 @@ export class WafRuleConfig extends $tea.Model {
132
131
  managedGroupId: 'ManagedGroupId',
133
132
  managedList: 'ManagedList',
134
133
  managedRulesets: 'ManagedRulesets',
135
- match: 'Match',
136
134
  name: 'Name',
137
135
  notes: 'Notes',
138
136
  rateLimit: 'RateLimit',
@@ -155,7 +153,6 @@ export class WafRuleConfig extends $tea.Model {
155
153
  managedGroupId: 'number',
156
154
  managedList: 'string',
157
155
  managedRulesets: { 'type': 'array', 'itemType': WafRuleConfigManagedRulesets },
158
- match: WafRuleMatch,
159
156
  name: 'string',
160
157
  notes: 'string',
161
158
  rateLimit: WafRuleConfigRateLimit,
@@ -703,194 +700,6 @@ export class BatchCreateRecordsResponse extends $tea.Model {
703
700
  }
704
701
  }
705
702
 
706
- export class BatchCreateWafRulesRequest extends $tea.Model {
707
- /**
708
- * @remarks
709
- * The configurations of the rules.
710
- */
711
- configs?: WafRuleConfig[];
712
- /**
713
- * @remarks
714
- * The WAF rule category.
715
- *
716
- * @example
717
- * http_custom
718
- */
719
- phase?: string;
720
- /**
721
- * @remarks
722
- * The configurations shared by multiple rules.
723
- */
724
- shared?: WafBatchRuleShared;
725
- /**
726
- * @remarks
727
- * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
728
- *
729
- * @example
730
- * 1
731
- */
732
- siteId?: number;
733
- /**
734
- * @remarks
735
- * The version of the website.
736
- *
737
- * @example
738
- * 0
739
- */
740
- siteVersion?: number;
741
- static names(): { [key: string]: string } {
742
- return {
743
- configs: 'Configs',
744
- phase: 'Phase',
745
- shared: 'Shared',
746
- siteId: 'SiteId',
747
- siteVersion: 'SiteVersion',
748
- };
749
- }
750
-
751
- static types(): { [key: string]: any } {
752
- return {
753
- configs: { 'type': 'array', 'itemType': WafRuleConfig },
754
- phase: 'string',
755
- shared: WafBatchRuleShared,
756
- siteId: 'number',
757
- siteVersion: 'number',
758
- };
759
- }
760
-
761
- constructor(map?: { [key: string]: any }) {
762
- super(map);
763
- }
764
- }
765
-
766
- export class BatchCreateWafRulesShrinkRequest extends $tea.Model {
767
- /**
768
- * @remarks
769
- * The configurations of the rules.
770
- */
771
- configsShrink?: string;
772
- /**
773
- * @remarks
774
- * The WAF rule category.
775
- *
776
- * @example
777
- * http_custom
778
- */
779
- phase?: string;
780
- /**
781
- * @remarks
782
- * The configurations shared by multiple rules.
783
- */
784
- sharedShrink?: string;
785
- /**
786
- * @remarks
787
- * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
788
- *
789
- * @example
790
- * 1
791
- */
792
- siteId?: number;
793
- /**
794
- * @remarks
795
- * The version of the website.
796
- *
797
- * @example
798
- * 0
799
- */
800
- siteVersion?: number;
801
- static names(): { [key: string]: string } {
802
- return {
803
- configsShrink: 'Configs',
804
- phase: 'Phase',
805
- sharedShrink: 'Shared',
806
- siteId: 'SiteId',
807
- siteVersion: 'SiteVersion',
808
- };
809
- }
810
-
811
- static types(): { [key: string]: any } {
812
- return {
813
- configsShrink: 'string',
814
- phase: 'string',
815
- sharedShrink: 'string',
816
- siteId: 'number',
817
- siteVersion: 'number',
818
- };
819
- }
820
-
821
- constructor(map?: { [key: string]: any }) {
822
- super(map);
823
- }
824
- }
825
-
826
- export class BatchCreateWafRulesResponseBody extends $tea.Model {
827
- /**
828
- * @remarks
829
- * The IDs of the WAF rules.[](~~2850237~~)
830
- */
831
- ids?: number[];
832
- /**
833
- * @remarks
834
- * The request ID.
835
- *
836
- * @example
837
- * 36af3fcc-43d0-441c-86b1-428951dc8225
838
- */
839
- requestId?: string;
840
- /**
841
- * @remarks
842
- * The ID of the WAF ruleset.[](~~2850233~~)
843
- *
844
- * @example
845
- * 10000001
846
- */
847
- rulesetId?: number;
848
- static names(): { [key: string]: string } {
849
- return {
850
- ids: 'Ids',
851
- requestId: 'RequestId',
852
- rulesetId: 'RulesetId',
853
- };
854
- }
855
-
856
- static types(): { [key: string]: any } {
857
- return {
858
- ids: { 'type': 'array', 'itemType': 'number' },
859
- requestId: 'string',
860
- rulesetId: 'number',
861
- };
862
- }
863
-
864
- constructor(map?: { [key: string]: any }) {
865
- super(map);
866
- }
867
- }
868
-
869
- export class BatchCreateWafRulesResponse extends $tea.Model {
870
- headers?: { [key: string]: string };
871
- statusCode?: number;
872
- body?: BatchCreateWafRulesResponseBody;
873
- static names(): { [key: string]: string } {
874
- return {
875
- headers: 'headers',
876
- statusCode: 'statusCode',
877
- body: 'body',
878
- };
879
- }
880
-
881
- static types(): { [key: string]: any } {
882
- return {
883
- headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
884
- statusCode: 'number',
885
- body: BatchCreateWafRulesResponseBody,
886
- };
887
- }
888
-
889
- constructor(map?: { [key: string]: any }) {
890
- super(map);
891
- }
892
- }
893
-
894
703
  export class BatchDeleteKvRequest extends $tea.Model {
895
704
  /**
896
705
  * @remarks
@@ -1609,189 +1418,70 @@ export class BatchPutKvWithHighCapacityResponse extends $tea.Model {
1609
1418
  }
1610
1419
  }
1611
1420
 
1612
- export class BatchUpdateWafRulesRequest extends $tea.Model {
1613
- /**
1614
- * @remarks
1615
- * The configurations of rules.
1616
- */
1617
- configs?: WafRuleConfig[];
1421
+ export class BlockObjectRequest extends $tea.Model {
1618
1422
  /**
1619
1423
  * @remarks
1620
- * The WAF rule category.
1424
+ * The content to block.
1621
1425
  *
1622
- * @example
1623
- * http_custom
1426
+ * This parameter is required.
1624
1427
  */
1625
- phase?: string;
1428
+ content?: string[];
1626
1429
  /**
1627
1430
  * @remarks
1628
- * The ID of the WAF ruleset, which can be obtained by calling the [ListWafRulesets](https://help.aliyun.com/document_detail/2850233.html) operation.
1431
+ * The blocking period that you can extend. Set the value to 2year.
1629
1432
  *
1630
1433
  * @example
1631
- * 10000001
1632
- */
1633
- rulesetId?: number;
1634
- /**
1635
- * @remarks
1636
- * The configurations shared by multiple rules.
1434
+ * 2year
1637
1435
  */
1638
- shared?: WafBatchRuleShared;
1436
+ extension?: string;
1639
1437
  /**
1640
1438
  * @remarks
1641
- * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
1439
+ * The period of time during which the URL is blocked. Unit: seconds. Specify this parameter if Type is set to block.
1642
1440
  *
1643
1441
  * @example
1644
- * 1
1442
+ * 864000
1645
1443
  */
1646
- siteId?: number;
1444
+ maxage?: number;
1647
1445
  /**
1648
1446
  * @remarks
1649
- * The version of the website.
1447
+ * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
1650
1448
  *
1651
- * @example
1652
- * 0
1653
- */
1654
- siteVersion?: number;
1655
- static names(): { [key: string]: string } {
1656
- return {
1657
- configs: 'Configs',
1658
- phase: 'Phase',
1659
- rulesetId: 'RulesetId',
1660
- shared: 'Shared',
1661
- siteId: 'SiteId',
1662
- siteVersion: 'SiteVersion',
1663
- };
1664
- }
1665
-
1666
- static types(): { [key: string]: any } {
1667
- return {
1668
- configs: { 'type': 'array', 'itemType': WafRuleConfig },
1669
- phase: 'string',
1670
- rulesetId: 'number',
1671
- shared: WafBatchRuleShared,
1672
- siteId: 'number',
1673
- siteVersion: 'number',
1674
- };
1675
- }
1676
-
1677
- constructor(map?: { [key: string]: any }) {
1678
- super(map);
1679
- }
1680
- }
1681
-
1682
- export class BatchUpdateWafRulesShrinkRequest extends $tea.Model {
1683
- /**
1684
- * @remarks
1685
- * The configurations of rules.
1686
- */
1687
- configsShrink?: string;
1688
- /**
1689
- * @remarks
1690
- * The WAF rule category.
1449
+ * This parameter is required.
1691
1450
  *
1692
1451
  * @example
1693
- * http_custom
1452
+ * BlockObject
1694
1453
  */
1695
- phase?: string;
1454
+ siteId?: number;
1696
1455
  /**
1697
1456
  * @remarks
1698
- * The ID of the WAF ruleset, which can be obtained by calling the [ListWafRulesets](https://help.aliyun.com/document_detail/2850233.html) operation.
1457
+ * The type. Valid values:
1699
1458
  *
1700
- * @example
1701
- * 10000001
1702
- */
1703
- rulesetId?: number;
1704
- /**
1705
- * @remarks
1706
- * The configurations shared by multiple rules.
1707
- */
1708
- sharedShrink?: string;
1709
- /**
1710
- * @remarks
1711
- * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
1459
+ * * **block**
1460
+ * * **unblock**
1712
1461
  *
1713
- * @example
1714
- * 1
1715
- */
1716
- siteId?: number;
1717
- /**
1718
- * @remarks
1719
- * The version of the website.
1462
+ * This parameter is required.
1720
1463
  *
1721
1464
  * @example
1722
- * 0
1465
+ * block
1723
1466
  */
1724
- siteVersion?: number;
1467
+ type?: string;
1725
1468
  static names(): { [key: string]: string } {
1726
1469
  return {
1727
- configsShrink: 'Configs',
1728
- phase: 'Phase',
1729
- rulesetId: 'RulesetId',
1730
- sharedShrink: 'Shared',
1470
+ content: 'Content',
1471
+ extension: 'Extension',
1472
+ maxage: 'Maxage',
1731
1473
  siteId: 'SiteId',
1732
- siteVersion: 'SiteVersion',
1474
+ type: 'Type',
1733
1475
  };
1734
1476
  }
1735
1477
 
1736
1478
  static types(): { [key: string]: any } {
1737
1479
  return {
1738
- configsShrink: 'string',
1739
- phase: 'string',
1740
- rulesetId: 'number',
1741
- sharedShrink: 'string',
1480
+ content: { 'type': 'array', 'itemType': 'string' },
1481
+ extension: 'string',
1482
+ maxage: 'number',
1742
1483
  siteId: 'number',
1743
- siteVersion: 'number',
1744
- };
1745
- }
1746
-
1747
- constructor(map?: { [key: string]: any }) {
1748
- super(map);
1749
- }
1750
- }
1751
-
1752
- export class BatchUpdateWafRulesResponseBody extends $tea.Model {
1753
- /**
1754
- * @remarks
1755
- * The request ID.
1756
- *
1757
- * @example
1758
- * 36af3fcc-43d0-441c-86b1-428951dc8225
1759
- */
1760
- requestId?: string;
1761
- static names(): { [key: string]: string } {
1762
- return {
1763
- requestId: 'RequestId',
1764
- };
1765
- }
1766
-
1767
- static types(): { [key: string]: any } {
1768
- return {
1769
- requestId: 'string',
1770
- };
1771
- }
1772
-
1773
- constructor(map?: { [key: string]: any }) {
1774
- super(map);
1775
- }
1776
- }
1777
-
1778
- export class BatchUpdateWafRulesResponse extends $tea.Model {
1779
- headers?: { [key: string]: string };
1780
- statusCode?: number;
1781
- body?: BatchUpdateWafRulesResponseBody;
1782
- static names(): { [key: string]: string } {
1783
- return {
1784
- headers: 'headers',
1785
- statusCode: 'statusCode',
1786
- body: 'body',
1787
- };
1788
- }
1789
-
1790
- static types(): { [key: string]: any } {
1791
- return {
1792
- headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
1793
- statusCode: 'number',
1794
- body: BatchUpdateWafRulesResponseBody,
1484
+ type: 'string',
1795
1485
  };
1796
1486
  }
1797
1487
 
@@ -1800,86 +1490,14 @@ export class BatchUpdateWafRulesResponse extends $tea.Model {
1800
1490
  }
1801
1491
  }
1802
1492
 
1803
- export class BlockObjectRequest extends $tea.Model {
1493
+ export class BlockObjectShrinkRequest extends $tea.Model {
1804
1494
  /**
1805
1495
  * @remarks
1806
1496
  * The content to block.
1807
1497
  *
1808
1498
  * This parameter is required.
1809
1499
  */
1810
- content?: string[];
1811
- /**
1812
- * @remarks
1813
- * The blocking period that you can extend. Set the value to 2year.
1814
- *
1815
- * @example
1816
- * 2year
1817
- */
1818
- extension?: string;
1819
- /**
1820
- * @remarks
1821
- * The period of time during which the URL is blocked. Unit: seconds. Specify this parameter if Type is set to block.
1822
- *
1823
- * @example
1824
- * 864000
1825
- */
1826
- maxage?: number;
1827
- /**
1828
- * @remarks
1829
- * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
1830
- *
1831
- * This parameter is required.
1832
- *
1833
- * @example
1834
- * BlockObject
1835
- */
1836
- siteId?: number;
1837
- /**
1838
- * @remarks
1839
- * The type. Valid values:
1840
- *
1841
- * * **block**
1842
- * * **unblock**
1843
- *
1844
- * This parameter is required.
1845
- *
1846
- * @example
1847
- * block
1848
- */
1849
- type?: string;
1850
- static names(): { [key: string]: string } {
1851
- return {
1852
- content: 'Content',
1853
- extension: 'Extension',
1854
- maxage: 'Maxage',
1855
- siteId: 'SiteId',
1856
- type: 'Type',
1857
- };
1858
- }
1859
-
1860
- static types(): { [key: string]: any } {
1861
- return {
1862
- content: { 'type': 'array', 'itemType': 'string' },
1863
- extension: 'string',
1864
- maxage: 'number',
1865
- siteId: 'number',
1866
- type: 'string',
1867
- };
1868
- }
1869
-
1870
- constructor(map?: { [key: string]: any }) {
1871
- super(map);
1872
- }
1873
- }
1874
-
1875
- export class BlockObjectShrinkRequest extends $tea.Model {
1876
- /**
1877
- * @remarks
1878
- * The content to block.
1879
- *
1880
- * This parameter is required.
1881
- */
1882
- contentShrink?: string;
1500
+ contentShrink?: string;
1883
1501
  /**
1884
1502
  * @remarks
1885
1503
  * The blocking period that you can extend. Set the value to 2year.
@@ -6196,183 +5814,228 @@ export class CreateUserDeliveryTaskResponse extends $tea.Model {
6196
5814
  }
6197
5815
  }
6198
5816
 
6199
- export class CreateWafRuleRequest extends $tea.Model {
5817
+ export class CreateWaitingRoomRequest extends $tea.Model {
6200
5818
  /**
6201
5819
  * @remarks
6202
- * The configuration of the rule that you want to create.
5820
+ * The name of the custom cookie.
5821
+ *
5822
+ * This parameter is required.
5823
+ *
5824
+ * @example
5825
+ * __aliwaitingroom_example
6203
5826
  */
6204
- config?: WafRuleConfig;
5827
+ cookieName?: string;
6205
5828
  /**
6206
5829
  * @remarks
6207
- * The WAF rule category.
5830
+ * The content of the custom waiting room page. You must specify this parameter if you set WaitingRoomType to custom. The content must be Base64-encoded.
5831
+ *
5832
+ * @example
5833
+ * Hello%20world!
5834
+ */
5835
+ customPageHtml?: string;
5836
+ /**
5837
+ * @remarks
5838
+ * The description of the waiting room.
5839
+ */
5840
+ description?: string;
5841
+ /**
5842
+ * @remarks
5843
+ * Specifies whether to disable session renewal. Valid values:
5844
+ *
5845
+ * * on
5846
+ * * off
5847
+ *
5848
+ * @example
5849
+ * on
5850
+ */
5851
+ disableSessionRenewalEnable?: string;
5852
+ /**
5853
+ * @remarks
5854
+ * Specifies whether to enable the waiting room. Valid values:
5855
+ *
5856
+ * * on
5857
+ * * off
6208
5858
  *
6209
5859
  * This parameter is required.
6210
5860
  *
6211
5861
  * @example
6212
- * http_custom
5862
+ * on
6213
5863
  */
6214
- phase?: string;
5864
+ enable?: string;
6215
5865
  /**
6216
5866
  * @remarks
6217
- * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
5867
+ * The hostname and path.
6218
5868
  *
6219
5869
  * This parameter is required.
5870
+ */
5871
+ hostNameAndPath?: CreateWaitingRoomRequestHostNameAndPath[];
5872
+ /**
5873
+ * @remarks
5874
+ * Specifies whether to enable JSON response. If you set this parameter to on, a JSON body is returned for requests to the waiting room with the header Accept: application/json. Valid values:
5875
+ *
5876
+ * * on
5877
+ * * off
6220
5878
  *
6221
5879
  * @example
6222
- * 1
5880
+ * on
6223
5881
  */
6224
- siteId?: number;
5882
+ jsonResponseEnable?: string;
6225
5883
  /**
6226
5884
  * @remarks
6227
- * The version of the website.
5885
+ * The language of the waiting room page. You must specify this parameter if you set WaitingRoomType to default. Valid values:
5886
+ *
5887
+ * * enus: English.
5888
+ * * zhcn: Simplified Chinese.
5889
+ * * zhhk: Traditional Chinese.
6228
5890
  *
6229
5891
  * @example
6230
- * 0
5892
+ * enus
6231
5893
  */
6232
- siteVersion?: number;
6233
- static names(): { [key: string]: string } {
6234
- return {
6235
- config: 'Config',
6236
- phase: 'Phase',
6237
- siteId: 'SiteId',
6238
- siteVersion: 'SiteVersion',
6239
- };
6240
- }
6241
-
6242
- static types(): { [key: string]: any } {
6243
- return {
6244
- config: WafRuleConfig,
6245
- phase: 'string',
6246
- siteId: 'number',
6247
- siteVersion: 'number',
6248
- };
6249
- }
6250
-
6251
- constructor(map?: { [key: string]: any }) {
6252
- super(map);
6253
- }
6254
- }
6255
-
6256
- export class CreateWafRuleShrinkRequest extends $tea.Model {
5894
+ language?: string;
6257
5895
  /**
6258
5896
  * @remarks
6259
- * The configuration of the rule that you want to create.
5897
+ * The name of the waiting room.
5898
+ *
5899
+ * This parameter is required.
5900
+ *
5901
+ * @example
5902
+ * waitingroom_example
6260
5903
  */
6261
- configShrink?: string;
5904
+ name?: string;
6262
5905
  /**
6263
5906
  * @remarks
6264
- * The WAF rule category.
5907
+ * The maximum number of new users per minute.
6265
5908
  *
6266
5909
  * This parameter is required.
6267
5910
  *
6268
5911
  * @example
6269
- * http_custom
5912
+ * 200
6270
5913
  */
6271
- phase?: string;
5914
+ newUsersPerMinute?: string;
6272
5915
  /**
6273
5916
  * @remarks
6274
- * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
5917
+ * Specifies whether to queue all requests. Valid values:
5918
+ *
5919
+ * * on
5920
+ * * off
5921
+ *
5922
+ * @example
5923
+ * on
5924
+ */
5925
+ queueAllEnable?: string;
5926
+ /**
5927
+ * @remarks
5928
+ * The queuing method. Valid values:
5929
+ *
5930
+ * * random: Users gain access to the origin randomly, regardless of the arrival time.
5931
+ * * fifo: Users gain access to the origin in order of arrival.
5932
+ * * passthrough: Users pass through the waiting room and go straight to the origin.
5933
+ * * reject-all: Users are blocked from reaching the origin.
6275
5934
  *
6276
5935
  * This parameter is required.
6277
5936
  *
6278
5937
  * @example
6279
- * 1
5938
+ * fifo
6280
5939
  */
6281
- siteId?: number;
5940
+ queuingMethod?: string;
6282
5941
  /**
6283
5942
  * @remarks
6284
- * The version of the website.
5943
+ * The HTTP status code to return while a user is in the queue. Valid values:
5944
+ *
5945
+ * * 200
5946
+ * * 202
5947
+ * * 429
5948
+ *
5949
+ * This parameter is required.
6285
5950
  *
6286
5951
  * @example
6287
- * 0
5952
+ * 200
6288
5953
  */
6289
- siteVersion?: number;
6290
- static names(): { [key: string]: string } {
6291
- return {
6292
- configShrink: 'Config',
6293
- phase: 'Phase',
6294
- siteId: 'SiteId',
6295
- siteVersion: 'SiteVersion',
6296
- };
6297
- }
6298
-
6299
- static types(): { [key: string]: any } {
6300
- return {
6301
- configShrink: 'string',
6302
- phase: 'string',
6303
- siteId: 'number',
6304
- siteVersion: 'number',
6305
- };
6306
- }
6307
-
6308
- constructor(map?: { [key: string]: any }) {
6309
- super(map);
6310
- }
6311
- }
6312
-
6313
- export class CreateWafRuleResponseBody extends $tea.Model {
5954
+ queuingStatusCode?: string;
6314
5955
  /**
6315
5956
  * @remarks
6316
- * The ID of the WAF rule.[](~~2850237~~)
5957
+ * The maximum duration for which a session remains valid after a user leaves the origin. Unit: minutes.
5958
+ *
5959
+ * This parameter is required.
6317
5960
  *
6318
5961
  * @example
6319
- * 20000001
5962
+ * 5
6320
5963
  */
6321
- id?: number;
5964
+ sessionDuration?: string;
6322
5965
  /**
6323
5966
  * @remarks
6324
- * The request ID.
5967
+ * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
5968
+ *
5969
+ * This parameter is required.
6325
5970
  *
6326
5971
  * @example
6327
- * 36af3fcc-43d0-441c-86b1-428951dc8225
5972
+ * 1234567890123
6328
5973
  */
6329
- requestId?: string;
5974
+ siteId?: number;
6330
5975
  /**
6331
5976
  * @remarks
6332
- * The ID of the WAF ruleset.[](~~2850233~~)
5977
+ * The maximum number of active users.
5978
+ *
5979
+ * This parameter is required.
6333
5980
  *
6334
5981
  * @example
6335
- * 10000001
5982
+ * 300
6336
5983
  */
6337
- rulesetId?: number;
6338
- static names(): { [key: string]: string } {
6339
- return {
6340
- id: 'Id',
6341
- requestId: 'RequestId',
6342
- rulesetId: 'RulesetId',
6343
- };
6344
- }
6345
-
6346
- static types(): { [key: string]: any } {
6347
- return {
6348
- id: 'number',
6349
- requestId: 'string',
6350
- rulesetId: 'number',
6351
- };
6352
- }
6353
-
6354
- constructor(map?: { [key: string]: any }) {
6355
- super(map);
6356
- }
6357
- }
6358
-
6359
- export class CreateWafRuleResponse extends $tea.Model {
6360
- headers?: { [key: string]: string };
6361
- statusCode?: number;
6362
- body?: CreateWafRuleResponseBody;
5984
+ totalActiveUsers?: string;
5985
+ /**
5986
+ * @remarks
5987
+ * The type of the waiting room. Valid values:
5988
+ *
5989
+ * * default
5990
+ * * custom
5991
+ *
5992
+ * This parameter is required.
5993
+ *
5994
+ * @example
5995
+ * default
5996
+ */
5997
+ waitingRoomType?: string;
6363
5998
  static names(): { [key: string]: string } {
6364
5999
  return {
6365
- headers: 'headers',
6366
- statusCode: 'statusCode',
6367
- body: 'body',
6000
+ cookieName: 'CookieName',
6001
+ customPageHtml: 'CustomPageHtml',
6002
+ description: 'Description',
6003
+ disableSessionRenewalEnable: 'DisableSessionRenewalEnable',
6004
+ enable: 'Enable',
6005
+ hostNameAndPath: 'HostNameAndPath',
6006
+ jsonResponseEnable: 'JsonResponseEnable',
6007
+ language: 'Language',
6008
+ name: 'Name',
6009
+ newUsersPerMinute: 'NewUsersPerMinute',
6010
+ queueAllEnable: 'QueueAllEnable',
6011
+ queuingMethod: 'QueuingMethod',
6012
+ queuingStatusCode: 'QueuingStatusCode',
6013
+ sessionDuration: 'SessionDuration',
6014
+ siteId: 'SiteId',
6015
+ totalActiveUsers: 'TotalActiveUsers',
6016
+ waitingRoomType: 'WaitingRoomType',
6368
6017
  };
6369
6018
  }
6370
6019
 
6371
6020
  static types(): { [key: string]: any } {
6372
6021
  return {
6373
- headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
6374
- statusCode: 'number',
6375
- body: CreateWafRuleResponseBody,
6022
+ cookieName: 'string',
6023
+ customPageHtml: 'string',
6024
+ description: 'string',
6025
+ disableSessionRenewalEnable: 'string',
6026
+ enable: 'string',
6027
+ hostNameAndPath: { 'type': 'array', 'itemType': CreateWaitingRoomRequestHostNameAndPath },
6028
+ jsonResponseEnable: 'string',
6029
+ language: 'string',
6030
+ name: 'string',
6031
+ newUsersPerMinute: 'string',
6032
+ queueAllEnable: 'string',
6033
+ queuingMethod: 'string',
6034
+ queuingStatusCode: 'string',
6035
+ sessionDuration: 'string',
6036
+ siteId: 'number',
6037
+ totalActiveUsers: 'string',
6038
+ waitingRoomType: 'string',
6376
6039
  };
6377
6040
  }
6378
6041
 
@@ -6381,237 +6044,7 @@ export class CreateWafRuleResponse extends $tea.Model {
6381
6044
  }
6382
6045
  }
6383
6046
 
6384
- export class CreateWaitingRoomRequest extends $tea.Model {
6385
- /**
6386
- * @remarks
6387
- * The name of the custom cookie.
6388
- *
6389
- * This parameter is required.
6390
- *
6391
- * @example
6392
- * __aliwaitingroom_example
6393
- */
6394
- cookieName?: string;
6395
- /**
6396
- * @remarks
6397
- * The content of the custom waiting room page. You must specify this parameter if you set WaitingRoomType to custom. The content must be Base64-encoded.
6398
- *
6399
- * @example
6400
- * Hello%20world!
6401
- */
6402
- customPageHtml?: string;
6403
- /**
6404
- * @remarks
6405
- * The description of the waiting room.
6406
- */
6407
- description?: string;
6408
- /**
6409
- * @remarks
6410
- * Specifies whether to disable session renewal. Valid values:
6411
- *
6412
- * * on
6413
- * * off
6414
- *
6415
- * @example
6416
- * on
6417
- */
6418
- disableSessionRenewalEnable?: string;
6419
- /**
6420
- * @remarks
6421
- * Specifies whether to enable the waiting room. Valid values:
6422
- *
6423
- * * on
6424
- * * off
6425
- *
6426
- * This parameter is required.
6427
- *
6428
- * @example
6429
- * on
6430
- */
6431
- enable?: string;
6432
- /**
6433
- * @remarks
6434
- * The hostname and path.
6435
- *
6436
- * This parameter is required.
6437
- */
6438
- hostNameAndPath?: CreateWaitingRoomRequestHostNameAndPath[];
6439
- /**
6440
- * @remarks
6441
- * Specifies whether to enable JSON response. If you set this parameter to on, a JSON body is returned for requests to the waiting room with the header Accept: application/json. Valid values:
6442
- *
6443
- * * on
6444
- * * off
6445
- *
6446
- * @example
6447
- * on
6448
- */
6449
- jsonResponseEnable?: string;
6450
- /**
6451
- * @remarks
6452
- * The language of the waiting room page. You must specify this parameter if you set WaitingRoomType to default. Valid values:
6453
- *
6454
- * * enus: English.
6455
- * * zhcn: Simplified Chinese.
6456
- * * zhhk: Traditional Chinese.
6457
- *
6458
- * @example
6459
- * enus
6460
- */
6461
- language?: string;
6462
- /**
6463
- * @remarks
6464
- * The name of the waiting room.
6465
- *
6466
- * This parameter is required.
6467
- *
6468
- * @example
6469
- * waitingroom_example
6470
- */
6471
- name?: string;
6472
- /**
6473
- * @remarks
6474
- * The maximum number of new users per minute.
6475
- *
6476
- * This parameter is required.
6477
- *
6478
- * @example
6479
- * 200
6480
- */
6481
- newUsersPerMinute?: string;
6482
- /**
6483
- * @remarks
6484
- * Specifies whether to queue all requests. Valid values:
6485
- *
6486
- * * on
6487
- * * off
6488
- *
6489
- * @example
6490
- * on
6491
- */
6492
- queueAllEnable?: string;
6493
- /**
6494
- * @remarks
6495
- * The queuing method. Valid values:
6496
- *
6497
- * * random: Users gain access to the origin randomly, regardless of the arrival time.
6498
- * * fifo: Users gain access to the origin in order of arrival.
6499
- * * passthrough: Users pass through the waiting room and go straight to the origin.
6500
- * * reject-all: Users are blocked from reaching the origin.
6501
- *
6502
- * This parameter is required.
6503
- *
6504
- * @example
6505
- * fifo
6506
- */
6507
- queuingMethod?: string;
6508
- /**
6509
- * @remarks
6510
- * The HTTP status code to return while a user is in the queue. Valid values:
6511
- *
6512
- * * 200
6513
- * * 202
6514
- * * 429
6515
- *
6516
- * This parameter is required.
6517
- *
6518
- * @example
6519
- * 200
6520
- */
6521
- queuingStatusCode?: string;
6522
- /**
6523
- * @remarks
6524
- * The maximum duration for which a session remains valid after a user leaves the origin. Unit: minutes.
6525
- *
6526
- * This parameter is required.
6527
- *
6528
- * @example
6529
- * 5
6530
- */
6531
- sessionDuration?: string;
6532
- /**
6533
- * @remarks
6534
- * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
6535
- *
6536
- * This parameter is required.
6537
- *
6538
- * @example
6539
- * 1234567890123
6540
- */
6541
- siteId?: number;
6542
- /**
6543
- * @remarks
6544
- * The maximum number of active users.
6545
- *
6546
- * This parameter is required.
6547
- *
6548
- * @example
6549
- * 300
6550
- */
6551
- totalActiveUsers?: string;
6552
- /**
6553
- * @remarks
6554
- * The type of the waiting room. Valid values:
6555
- *
6556
- * * default
6557
- * * custom
6558
- *
6559
- * This parameter is required.
6560
- *
6561
- * @example
6562
- * default
6563
- */
6564
- waitingRoomType?: string;
6565
- static names(): { [key: string]: string } {
6566
- return {
6567
- cookieName: 'CookieName',
6568
- customPageHtml: 'CustomPageHtml',
6569
- description: 'Description',
6570
- disableSessionRenewalEnable: 'DisableSessionRenewalEnable',
6571
- enable: 'Enable',
6572
- hostNameAndPath: 'HostNameAndPath',
6573
- jsonResponseEnable: 'JsonResponseEnable',
6574
- language: 'Language',
6575
- name: 'Name',
6576
- newUsersPerMinute: 'NewUsersPerMinute',
6577
- queueAllEnable: 'QueueAllEnable',
6578
- queuingMethod: 'QueuingMethod',
6579
- queuingStatusCode: 'QueuingStatusCode',
6580
- sessionDuration: 'SessionDuration',
6581
- siteId: 'SiteId',
6582
- totalActiveUsers: 'TotalActiveUsers',
6583
- waitingRoomType: 'WaitingRoomType',
6584
- };
6585
- }
6586
-
6587
- static types(): { [key: string]: any } {
6588
- return {
6589
- cookieName: 'string',
6590
- customPageHtml: 'string',
6591
- description: 'string',
6592
- disableSessionRenewalEnable: 'string',
6593
- enable: 'string',
6594
- hostNameAndPath: { 'type': 'array', 'itemType': CreateWaitingRoomRequestHostNameAndPath },
6595
- jsonResponseEnable: 'string',
6596
- language: 'string',
6597
- name: 'string',
6598
- newUsersPerMinute: 'string',
6599
- queueAllEnable: 'string',
6600
- queuingMethod: 'string',
6601
- queuingStatusCode: 'string',
6602
- sessionDuration: 'string',
6603
- siteId: 'number',
6604
- totalActiveUsers: 'string',
6605
- waitingRoomType: 'string',
6606
- };
6607
- }
6608
-
6609
- constructor(map?: { [key: string]: any }) {
6610
- super(map);
6611
- }
6612
- }
6613
-
6614
- export class CreateWaitingRoomShrinkRequest extends $tea.Model {
6047
+ export class CreateWaitingRoomShrinkRequest extends $tea.Model {
6615
6048
  /**
6616
6049
  * @remarks
6617
6050
  * The name of the custom cookie.
@@ -9404,206 +8837,6 @@ export class DeleteUserDeliveryTaskResponse extends $tea.Model {
9404
8837
  }
9405
8838
  }
9406
8839
 
9407
- export class DeleteWafRuleRequest extends $tea.Model {
9408
- /**
9409
- * @remarks
9410
- * The ID of the WAF rule, which can be obtained by calling the [ListWafRules](https://help.aliyun.com/document_detail/2850237.html) operation.
9411
- *
9412
- * This parameter is required.
9413
- *
9414
- * @example
9415
- * 20000001
9416
- */
9417
- id?: number;
9418
- /**
9419
- * @remarks
9420
- * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
9421
- *
9422
- * This parameter is required.
9423
- *
9424
- * @example
9425
- * 1
9426
- */
9427
- siteId?: number;
9428
- /**
9429
- * @remarks
9430
- * The version of the website.
9431
- *
9432
- * @example
9433
- * 1
9434
- */
9435
- siteVersion?: number;
9436
- static names(): { [key: string]: string } {
9437
- return {
9438
- id: 'Id',
9439
- siteId: 'SiteId',
9440
- siteVersion: 'SiteVersion',
9441
- };
9442
- }
9443
-
9444
- static types(): { [key: string]: any } {
9445
- return {
9446
- id: 'number',
9447
- siteId: 'number',
9448
- siteVersion: 'number',
9449
- };
9450
- }
9451
-
9452
- constructor(map?: { [key: string]: any }) {
9453
- super(map);
9454
- }
9455
- }
9456
-
9457
- export class DeleteWafRuleResponseBody extends $tea.Model {
9458
- /**
9459
- * @remarks
9460
- * The request ID.
9461
- *
9462
- * @example
9463
- * 36af3fcc-43d0-441c-86b1-428951dc8225
9464
- */
9465
- requestId?: string;
9466
- static names(): { [key: string]: string } {
9467
- return {
9468
- requestId: 'RequestId',
9469
- };
9470
- }
9471
-
9472
- static types(): { [key: string]: any } {
9473
- return {
9474
- requestId: 'string',
9475
- };
9476
- }
9477
-
9478
- constructor(map?: { [key: string]: any }) {
9479
- super(map);
9480
- }
9481
- }
9482
-
9483
- export class DeleteWafRuleResponse extends $tea.Model {
9484
- headers?: { [key: string]: string };
9485
- statusCode?: number;
9486
- body?: DeleteWafRuleResponseBody;
9487
- static names(): { [key: string]: string } {
9488
- return {
9489
- headers: 'headers',
9490
- statusCode: 'statusCode',
9491
- body: 'body',
9492
- };
9493
- }
9494
-
9495
- static types(): { [key: string]: any } {
9496
- return {
9497
- headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
9498
- statusCode: 'number',
9499
- body: DeleteWafRuleResponseBody,
9500
- };
9501
- }
9502
-
9503
- constructor(map?: { [key: string]: any }) {
9504
- super(map);
9505
- }
9506
- }
9507
-
9508
- export class DeleteWafRulesetRequest extends $tea.Model {
9509
- /**
9510
- * @remarks
9511
- * The ID of the WAF ruleset, which can be obtained by calling the [ListWafRulesets](https://help.aliyun.com/document_detail/2850233.html) operation.
9512
- *
9513
- * This parameter is required.
9514
- *
9515
- * @example
9516
- * 10000001
9517
- */
9518
- id?: number;
9519
- /**
9520
- * @remarks
9521
- * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
9522
- *
9523
- * @example
9524
- * 1
9525
- */
9526
- siteId?: number;
9527
- /**
9528
- * @remarks
9529
- * The version of the website.
9530
- *
9531
- * @example
9532
- * 1
9533
- */
9534
- siteVersion?: number;
9535
- static names(): { [key: string]: string } {
9536
- return {
9537
- id: 'Id',
9538
- siteId: 'SiteId',
9539
- siteVersion: 'SiteVersion',
9540
- };
9541
- }
9542
-
9543
- static types(): { [key: string]: any } {
9544
- return {
9545
- id: 'number',
9546
- siteId: 'number',
9547
- siteVersion: 'number',
9548
- };
9549
- }
9550
-
9551
- constructor(map?: { [key: string]: any }) {
9552
- super(map);
9553
- }
9554
- }
9555
-
9556
- export class DeleteWafRulesetResponseBody extends $tea.Model {
9557
- /**
9558
- * @remarks
9559
- * The request ID.
9560
- *
9561
- * @example
9562
- * 36af3fcc-43d0-441c-86b1-428951dc8225
9563
- */
9564
- requestId?: string;
9565
- static names(): { [key: string]: string } {
9566
- return {
9567
- requestId: 'RequestId',
9568
- };
9569
- }
9570
-
9571
- static types(): { [key: string]: any } {
9572
- return {
9573
- requestId: 'string',
9574
- };
9575
- }
9576
-
9577
- constructor(map?: { [key: string]: any }) {
9578
- super(map);
9579
- }
9580
- }
9581
-
9582
- export class DeleteWafRulesetResponse extends $tea.Model {
9583
- headers?: { [key: string]: string };
9584
- statusCode?: number;
9585
- body?: DeleteWafRulesetResponseBody;
9586
- static names(): { [key: string]: string } {
9587
- return {
9588
- headers: 'headers',
9589
- statusCode: 'statusCode',
9590
- body: 'body',
9591
- };
9592
- }
9593
-
9594
- static types(): { [key: string]: any } {
9595
- return {
9596
- headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
9597
- statusCode: 'number',
9598
- body: DeleteWafRulesetResponseBody,
9599
- };
9600
- }
9601
-
9602
- constructor(map?: { [key: string]: any }) {
9603
- super(map);
9604
- }
9605
- }
9606
-
9607
8840
  export class DeleteWaitingRoomRequest extends $tea.Model {
9608
8841
  /**
9609
8842
  * @remarks
@@ -11710,12 +10943,17 @@ export class GetClientCertificateResponse extends $tea.Model {
11710
10943
 
11711
10944
  export class GetClientCertificateHostnamesRequest extends $tea.Model {
11712
10945
  /**
10946
+ * @remarks
10947
+ * The certificate ID.
10948
+ *
11713
10949
  * @example
11714
10950
  * baba39055622c008b90285a8838ed09a
11715
10951
  */
11716
10952
  id?: string;
11717
10953
  /**
11718
10954
  * @remarks
10955
+ * The website ID.
10956
+ *
11719
10957
  * This parameter is required.
11720
10958
  *
11721
10959
  * @example
@@ -11742,23 +10980,39 @@ export class GetClientCertificateHostnamesRequest extends $tea.Model {
11742
10980
  }
11743
10981
 
11744
10982
  export class GetClientCertificateHostnamesResponseBody extends $tea.Model {
10983
+ /**
10984
+ * @remarks
10985
+ * The domain names with which the certificate is associated.
10986
+ */
11745
10987
  hostnames?: string[];
11746
10988
  /**
10989
+ * @remarks
10990
+ * The ID of the client CA certificate.
10991
+ *
11747
10992
  * @example
11748
10993
  * baba39055622c008b90285a8838ed09a
11749
10994
  */
11750
10995
  id?: string;
11751
10996
  /**
10997
+ * @remarks
10998
+ * The request ID.
10999
+ *
11752
11000
  * @example
11753
11001
  * EEEBE525-F576-1196-8DAF-2D70CA3F4D2F
11754
11002
  */
11755
11003
  requestId?: string;
11756
11004
  /**
11005
+ * @remarks
11006
+ * The website ID.
11007
+ *
11757
11008
  * @example
11758
11009
  * 1234567890123
11759
11010
  */
11760
11011
  siteId?: number;
11761
11012
  /**
11013
+ * @remarks
11014
+ * The website name.
11015
+ *
11762
11016
  * @example
11763
11017
  * example.com
11764
11018
  */
@@ -15814,333 +15068,6 @@ export class GetWafQuotaResponse extends $tea.Model {
15814
15068
  }
15815
15069
  }
15816
15070
 
15817
- export class GetWafRuleRequest extends $tea.Model {
15818
- /**
15819
- * @remarks
15820
- * The ID of the WAF rule, which can be obtained by calling the [ListWafRules](https://help.aliyun.com/document_detail/2850237.html) operation.
15821
- *
15822
- * This parameter is required.
15823
- *
15824
- * @example
15825
- * 20000001
15826
- */
15827
- id?: number;
15828
- /**
15829
- * @remarks
15830
- * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
15831
- *
15832
- * This parameter is required.
15833
- *
15834
- * @example
15835
- * 1
15836
- */
15837
- siteId?: number;
15838
- static names(): { [key: string]: string } {
15839
- return {
15840
- id: 'Id',
15841
- siteId: 'SiteId',
15842
- };
15843
- }
15844
-
15845
- static types(): { [key: string]: any } {
15846
- return {
15847
- id: 'number',
15848
- siteId: 'number',
15849
- };
15850
- }
15851
-
15852
- constructor(map?: { [key: string]: any }) {
15853
- super(map);
15854
- }
15855
- }
15856
-
15857
- export class GetWafRuleResponseBody extends $tea.Model {
15858
- /**
15859
- * @remarks
15860
- * The configuration of the rule.
15861
- */
15862
- config?: WafRuleConfig;
15863
- /**
15864
- * @remarks
15865
- * The ID of the WAF rule.[](~~2850237~~)
15866
- *
15867
- * @example
15868
- * 2000001
15869
- */
15870
- id?: number;
15871
- /**
15872
- * @remarks
15873
- * The rule name.
15874
- *
15875
- * This parameter is required.
15876
- *
15877
- * @example
15878
- * example
15879
- */
15880
- name?: string;
15881
- /**
15882
- * @remarks
15883
- * The WAF rule category.
15884
- *
15885
- * This parameter is required.
15886
- *
15887
- * @example
15888
- * http_custom
15889
- */
15890
- phase?: string;
15891
- /**
15892
- * @remarks
15893
- * The order of the rule in the ruleset.
15894
- *
15895
- * @example
15896
- * 1
15897
- */
15898
- position?: number;
15899
- /**
15900
- * @remarks
15901
- * The request ID.
15902
- *
15903
- * @example
15904
- * 36af3fcc-43d0-441c-86b1-428951dc8225
15905
- */
15906
- requestId?: string;
15907
- /**
15908
- * @remarks
15909
- * Indicates whether the rule is enabled.
15910
- *
15911
- * @example
15912
- * on
15913
- */
15914
- status?: string;
15915
- /**
15916
- * @remarks
15917
- * The time when the rule was last modified.
15918
- *
15919
- * @example
15920
- * 2024-01-01T00:00:00Z
15921
- */
15922
- updateTime?: string;
15923
- static names(): { [key: string]: string } {
15924
- return {
15925
- config: 'Config',
15926
- id: 'Id',
15927
- name: 'Name',
15928
- phase: 'Phase',
15929
- position: 'Position',
15930
- requestId: 'RequestId',
15931
- status: 'Status',
15932
- updateTime: 'UpdateTime',
15933
- };
15934
- }
15935
-
15936
- static types(): { [key: string]: any } {
15937
- return {
15938
- config: WafRuleConfig,
15939
- id: 'number',
15940
- name: 'string',
15941
- phase: 'string',
15942
- position: 'number',
15943
- requestId: 'string',
15944
- status: 'string',
15945
- updateTime: 'string',
15946
- };
15947
- }
15948
-
15949
- constructor(map?: { [key: string]: any }) {
15950
- super(map);
15951
- }
15952
- }
15953
-
15954
- export class GetWafRuleResponse extends $tea.Model {
15955
- headers?: { [key: string]: string };
15956
- statusCode?: number;
15957
- body?: GetWafRuleResponseBody;
15958
- static names(): { [key: string]: string } {
15959
- return {
15960
- headers: 'headers',
15961
- statusCode: 'statusCode',
15962
- body: 'body',
15963
- };
15964
- }
15965
-
15966
- static types(): { [key: string]: any } {
15967
- return {
15968
- headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
15969
- statusCode: 'number',
15970
- body: GetWafRuleResponseBody,
15971
- };
15972
- }
15973
-
15974
- constructor(map?: { [key: string]: any }) {
15975
- super(map);
15976
- }
15977
- }
15978
-
15979
- export class GetWafRulesetRequest extends $tea.Model {
15980
- /**
15981
- * @remarks
15982
- * The ID of the WAF ruleset, which can be obtained by calling the [ListWafRulesets](https://help.aliyun.com/document_detail/2850233.html) operation.
15983
- *
15984
- * @example
15985
- * 10000001
15986
- */
15987
- id?: number;
15988
- /**
15989
- * @remarks
15990
- * The WAF rule category of rulesets to query.
15991
- *
15992
- * @example
15993
- * http_bot
15994
- */
15995
- phase?: string;
15996
- /**
15997
- * @remarks
15998
- * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
15999
- *
16000
- * @example
16001
- * 1
16002
- */
16003
- siteId?: number;
16004
- static names(): { [key: string]: string } {
16005
- return {
16006
- id: 'Id',
16007
- phase: 'Phase',
16008
- siteId: 'SiteId',
16009
- };
16010
- }
16011
-
16012
- static types(): { [key: string]: any } {
16013
- return {
16014
- id: 'number',
16015
- phase: 'string',
16016
- siteId: 'number',
16017
- };
16018
- }
16019
-
16020
- constructor(map?: { [key: string]: any }) {
16021
- super(map);
16022
- }
16023
- }
16024
-
16025
- export class GetWafRulesetResponseBody extends $tea.Model {
16026
- /**
16027
- * @remarks
16028
- * The ruleset ID.
16029
- *
16030
- * @example
16031
- * 10000001
16032
- */
16033
- id?: number;
16034
- /**
16035
- * @remarks
16036
- * The ruleset name.
16037
- *
16038
- * This parameter is required.
16039
- *
16040
- * @example
16041
- * example
16042
- */
16043
- name?: string;
16044
- /**
16045
- * @remarks
16046
- * The WAF rule category of the ruleset.
16047
- *
16048
- * This parameter is required.
16049
- *
16050
- * @example
16051
- * http_bot
16052
- */
16053
- phase?: string;
16054
- /**
16055
- * @remarks
16056
- * The request ID.
16057
- *
16058
- * @example
16059
- * 36af3fcc-43d0-441c-86b1-428951dc8225
16060
- */
16061
- requestId?: string;
16062
- /**
16063
- * @remarks
16064
- * The rule configurations in the ruleset.
16065
- */
16066
- rules?: WafRuleConfig[];
16067
- /**
16068
- * @remarks
16069
- * The configurations shared by the rules in the ruleset.
16070
- */
16071
- shared?: WafBatchRuleShared;
16072
- /**
16073
- * @remarks
16074
- * The ruleset status.
16075
- *
16076
- * @example
16077
- * on
16078
- */
16079
- status?: string;
16080
- /**
16081
- * @remarks
16082
- * The time when the ruleset was last modified.
16083
- *
16084
- * @example
16085
- * 2024-01-01T00:00:00Z
16086
- */
16087
- updateTime?: string;
16088
- static names(): { [key: string]: string } {
16089
- return {
16090
- id: 'Id',
16091
- name: 'Name',
16092
- phase: 'Phase',
16093
- requestId: 'RequestId',
16094
- rules: 'Rules',
16095
- shared: 'Shared',
16096
- status: 'Status',
16097
- updateTime: 'UpdateTime',
16098
- };
16099
- }
16100
-
16101
- static types(): { [key: string]: any } {
16102
- return {
16103
- id: 'number',
16104
- name: 'string',
16105
- phase: 'string',
16106
- requestId: 'string',
16107
- rules: { 'type': 'array', 'itemType': WafRuleConfig },
16108
- shared: WafBatchRuleShared,
16109
- status: 'string',
16110
- updateTime: 'string',
16111
- };
16112
- }
16113
-
16114
- constructor(map?: { [key: string]: any }) {
16115
- super(map);
16116
- }
16117
- }
16118
-
16119
- export class GetWafRulesetResponse extends $tea.Model {
16120
- headers?: { [key: string]: string };
16121
- statusCode?: number;
16122
- body?: GetWafRulesetResponseBody;
16123
- static names(): { [key: string]: string } {
16124
- return {
16125
- headers: 'headers',
16126
- statusCode: 'statusCode',
16127
- body: 'body',
16128
- };
16129
- }
16130
-
16131
- static types(): { [key: string]: any } {
16132
- return {
16133
- headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
16134
- statusCode: 'number',
16135
- body: GetWafRulesetResponseBody,
16136
- };
16137
- }
16138
-
16139
- constructor(map?: { [key: string]: any }) {
16140
- super(map);
16141
- }
16142
- }
16143
-
16144
15071
  export class ListCacheReserveInstancesRequest extends $tea.Model {
16145
15072
  /**
16146
15073
  * @remarks
@@ -19519,6 +18446,10 @@ export class ListSitesRequest extends $tea.Model {
19519
18446
  * false
19520
18447
  */
19521
18448
  onlyEnterprise?: boolean;
18449
+ /**
18450
+ * @example
18451
+ * visitTime
18452
+ */
19522
18453
  orderBy?: string;
19523
18454
  /**
19524
18455
  * @remarks
@@ -19662,6 +18593,10 @@ export class ListSitesShrinkRequest extends $tea.Model {
19662
18593
  * false
19663
18594
  */
19664
18595
  onlyEnterprise?: boolean;
18596
+ /**
18597
+ * @example
18598
+ * visitTime
18599
+ */
19665
18600
  orderBy?: string;
19666
18601
  /**
19667
18602
  * @remarks
@@ -20507,7 +19442,7 @@ export class ListWafManagedRulesRequest extends $tea.Model {
20507
19442
  attackType?: number;
20508
19443
  /**
20509
19444
  * @remarks
20510
- * The ID of the WAF rule, which can be obtained by calling the [ListWafRules](~~ListWafRules~~) operation.
19445
+ * The ID of the WAF rule, which can be obtained by calling the [ListWafRules](https://help.aliyun.com/document_detail/2850237.html) operation.
20511
19446
  *
20512
19447
  * This parameter is required.
20513
19448
  *
@@ -20550,7 +19485,7 @@ export class ListWafManagedRulesRequest extends $tea.Model {
20550
19485
  queryArgs?: ListWafManagedRulesRequestQueryArgs;
20551
19486
  /**
20552
19487
  * @remarks
20553
- * The website ID, which can be obtained by calling the [ListSites](~~ListSites~~) operation.
19488
+ * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
20554
19489
  *
20555
19490
  * This parameter is required.
20556
19491
  *
@@ -20613,7 +19548,7 @@ export class ListWafManagedRulesShrinkRequest extends $tea.Model {
20613
19548
  attackType?: number;
20614
19549
  /**
20615
19550
  * @remarks
20616
- * The ID of the WAF rule, which can be obtained by calling the [ListWafRules](~~ListWafRules~~) operation.
19551
+ * The ID of the WAF rule, which can be obtained by calling the [ListWafRules](https://help.aliyun.com/document_detail/2850237.html) operation.
20617
19552
  *
20618
19553
  * This parameter is required.
20619
19554
  *
@@ -20656,7 +19591,7 @@ export class ListWafManagedRulesShrinkRequest extends $tea.Model {
20656
19591
  queryArgsShrink?: string;
20657
19592
  /**
20658
19593
  * @remarks
20659
- * The website ID, which can be obtained by calling the [ListSites](~~ListSites~~) operation.
19594
+ * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
20660
19595
  *
20661
19596
  * This parameter is required.
20662
19597
  *
@@ -20879,530 +19814,6 @@ export class ListWafPhasesResponse extends $tea.Model {
20879
19814
  }
20880
19815
  }
20881
19816
 
20882
- export class ListWafRulesRequest extends $tea.Model {
20883
- /**
20884
- * @remarks
20885
- * The page number.
20886
- *
20887
- * @example
20888
- * http_custom
20889
- */
20890
- pageNumber?: number;
20891
- /**
20892
- * @remarks
20893
- * The number of entries per page.
20894
- *
20895
- * @example
20896
- * 1
20897
- */
20898
- pageSize?: number;
20899
- /**
20900
- * @remarks
20901
- * The WAF rule category. You can filter rules of a specific category.
20902
- *
20903
- * @example
20904
- * 0
20905
- */
20906
- phase?: string;
20907
- /**
20908
- * @remarks
20909
- * The filter conditions.
20910
- *
20911
- * @example
20912
- * http_custom
20913
- */
20914
- queryArgs?: ListWafRulesRequestQueryArgs;
20915
- /**
20916
- * @remarks
20917
- * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
20918
- *
20919
- * This parameter is required.
20920
- *
20921
- * @example
20922
- * 1
20923
- */
20924
- siteId?: number;
20925
- /**
20926
- * @remarks
20927
- * The version of the website.
20928
- *
20929
- * @example
20930
- * 1
20931
- */
20932
- siteVersion?: number;
20933
- static names(): { [key: string]: string } {
20934
- return {
20935
- pageNumber: 'PageNumber',
20936
- pageSize: 'PageSize',
20937
- phase: 'Phase',
20938
- queryArgs: 'QueryArgs',
20939
- siteId: 'SiteId',
20940
- siteVersion: 'SiteVersion',
20941
- };
20942
- }
20943
-
20944
- static types(): { [key: string]: any } {
20945
- return {
20946
- pageNumber: 'number',
20947
- pageSize: 'number',
20948
- phase: 'string',
20949
- queryArgs: ListWafRulesRequestQueryArgs,
20950
- siteId: 'number',
20951
- siteVersion: 'number',
20952
- };
20953
- }
20954
-
20955
- constructor(map?: { [key: string]: any }) {
20956
- super(map);
20957
- }
20958
- }
20959
-
20960
- export class ListWafRulesShrinkRequest extends $tea.Model {
20961
- /**
20962
- * @remarks
20963
- * The page number.
20964
- *
20965
- * @example
20966
- * http_custom
20967
- */
20968
- pageNumber?: number;
20969
- /**
20970
- * @remarks
20971
- * The number of entries per page.
20972
- *
20973
- * @example
20974
- * 1
20975
- */
20976
- pageSize?: number;
20977
- /**
20978
- * @remarks
20979
- * The WAF rule category. You can filter rules of a specific category.
20980
- *
20981
- * @example
20982
- * 0
20983
- */
20984
- phase?: string;
20985
- /**
20986
- * @remarks
20987
- * The filter conditions.
20988
- *
20989
- * @example
20990
- * http_custom
20991
- */
20992
- queryArgsShrink?: string;
20993
- /**
20994
- * @remarks
20995
- * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
20996
- *
20997
- * This parameter is required.
20998
- *
20999
- * @example
21000
- * 1
21001
- */
21002
- siteId?: number;
21003
- /**
21004
- * @remarks
21005
- * The version of the website.
21006
- *
21007
- * @example
21008
- * 1
21009
- */
21010
- siteVersion?: number;
21011
- static names(): { [key: string]: string } {
21012
- return {
21013
- pageNumber: 'PageNumber',
21014
- pageSize: 'PageSize',
21015
- phase: 'Phase',
21016
- queryArgsShrink: 'QueryArgs',
21017
- siteId: 'SiteId',
21018
- siteVersion: 'SiteVersion',
21019
- };
21020
- }
21021
-
21022
- static types(): { [key: string]: any } {
21023
- return {
21024
- pageNumber: 'number',
21025
- pageSize: 'number',
21026
- phase: 'string',
21027
- queryArgsShrink: 'string',
21028
- siteId: 'number',
21029
- siteVersion: 'number',
21030
- };
21031
- }
21032
-
21033
- constructor(map?: { [key: string]: any }) {
21034
- super(map);
21035
- }
21036
- }
21037
-
21038
- export class ListWafRulesResponseBody extends $tea.Model {
21039
- /**
21040
- * @remarks
21041
- * The rule usage of the instance that corresponds to the website in the WAF rule category.
21042
- *
21043
- * @example
21044
- * 10
21045
- */
21046
- instanceUsage?: number;
21047
- /**
21048
- * @remarks
21049
- * The page number.
21050
- *
21051
- * @example
21052
- * 1
21053
- */
21054
- pageNumber?: number;
21055
- /**
21056
- * @remarks
21057
- * The number of entries per page.
21058
- *
21059
- * @example
21060
- * 20
21061
- */
21062
- pageSize?: number;
21063
- /**
21064
- * @remarks
21065
- * The request ID.
21066
- *
21067
- * @example
21068
- * 36af3fcc-43d0-441c-86b1-428951dc8225
21069
- */
21070
- requestId?: string;
21071
- /**
21072
- * @remarks
21073
- * The rules returned.
21074
- */
21075
- rules?: ListWafRulesResponseBodyRules[];
21076
- /**
21077
- * @remarks
21078
- * The rule usage of the website.
21079
- *
21080
- * @example
21081
- * 5
21082
- */
21083
- siteUsage?: number;
21084
- /**
21085
- * @remarks
21086
- * The total number of filtered rules.
21087
- *
21088
- * @example
21089
- * 20
21090
- */
21091
- totalCount?: number;
21092
- static names(): { [key: string]: string } {
21093
- return {
21094
- instanceUsage: 'InstanceUsage',
21095
- pageNumber: 'PageNumber',
21096
- pageSize: 'PageSize',
21097
- requestId: 'RequestId',
21098
- rules: 'Rules',
21099
- siteUsage: 'SiteUsage',
21100
- totalCount: 'TotalCount',
21101
- };
21102
- }
21103
-
21104
- static types(): { [key: string]: any } {
21105
- return {
21106
- instanceUsage: 'number',
21107
- pageNumber: 'number',
21108
- pageSize: 'number',
21109
- requestId: 'string',
21110
- rules: { 'type': 'array', 'itemType': ListWafRulesResponseBodyRules },
21111
- siteUsage: 'number',
21112
- totalCount: 'number',
21113
- };
21114
- }
21115
-
21116
- constructor(map?: { [key: string]: any }) {
21117
- super(map);
21118
- }
21119
- }
21120
-
21121
- export class ListWafRulesResponse extends $tea.Model {
21122
- headers?: { [key: string]: string };
21123
- statusCode?: number;
21124
- body?: ListWafRulesResponseBody;
21125
- static names(): { [key: string]: string } {
21126
- return {
21127
- headers: 'headers',
21128
- statusCode: 'statusCode',
21129
- body: 'body',
21130
- };
21131
- }
21132
-
21133
- static types(): { [key: string]: any } {
21134
- return {
21135
- headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
21136
- statusCode: 'number',
21137
- body: ListWafRulesResponseBody,
21138
- };
21139
- }
21140
-
21141
- constructor(map?: { [key: string]: any }) {
21142
- super(map);
21143
- }
21144
- }
21145
-
21146
- export class ListWafRulesetsRequest extends $tea.Model {
21147
- /**
21148
- * @remarks
21149
- * The page number.
21150
- *
21151
- * @example
21152
- * 1
21153
- */
21154
- pageNumber?: number;
21155
- /**
21156
- * @remarks
21157
- * The number of entries per page.
21158
- *
21159
- * @example
21160
- * 20
21161
- */
21162
- pageSize?: number;
21163
- /**
21164
- * @remarks
21165
- * The WAF rule category of rulesets to query.
21166
- *
21167
- * @example
21168
- * http_bot
21169
- */
21170
- phase?: string;
21171
- /**
21172
- * @remarks
21173
- * The query arguments in the JSON format, which contain filter conditions.
21174
- *
21175
- * @example
21176
- * http_bot
21177
- */
21178
- queryArgs?: ListWafRulesetsRequestQueryArgs;
21179
- /**
21180
- * @remarks
21181
- * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
21182
- *
21183
- * @example
21184
- * 1
21185
- */
21186
- siteId?: number;
21187
- /**
21188
- * @remarks
21189
- * The version of the website.
21190
- *
21191
- * @example
21192
- * 1
21193
- */
21194
- siteVersion?: number;
21195
- static names(): { [key: string]: string } {
21196
- return {
21197
- pageNumber: 'PageNumber',
21198
- pageSize: 'PageSize',
21199
- phase: 'Phase',
21200
- queryArgs: 'QueryArgs',
21201
- siteId: 'SiteId',
21202
- siteVersion: 'SiteVersion',
21203
- };
21204
- }
21205
-
21206
- static types(): { [key: string]: any } {
21207
- return {
21208
- pageNumber: 'number',
21209
- pageSize: 'number',
21210
- phase: 'string',
21211
- queryArgs: ListWafRulesetsRequestQueryArgs,
21212
- siteId: 'number',
21213
- siteVersion: 'number',
21214
- };
21215
- }
21216
-
21217
- constructor(map?: { [key: string]: any }) {
21218
- super(map);
21219
- }
21220
- }
21221
-
21222
- export class ListWafRulesetsShrinkRequest extends $tea.Model {
21223
- /**
21224
- * @remarks
21225
- * The page number.
21226
- *
21227
- * @example
21228
- * 1
21229
- */
21230
- pageNumber?: number;
21231
- /**
21232
- * @remarks
21233
- * The number of entries per page.
21234
- *
21235
- * @example
21236
- * 20
21237
- */
21238
- pageSize?: number;
21239
- /**
21240
- * @remarks
21241
- * The WAF rule category of rulesets to query.
21242
- *
21243
- * @example
21244
- * http_bot
21245
- */
21246
- phase?: string;
21247
- /**
21248
- * @remarks
21249
- * The query arguments in the JSON format, which contain filter conditions.
21250
- *
21251
- * @example
21252
- * http_bot
21253
- */
21254
- queryArgsShrink?: string;
21255
- /**
21256
- * @remarks
21257
- * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
21258
- *
21259
- * @example
21260
- * 1
21261
- */
21262
- siteId?: number;
21263
- /**
21264
- * @remarks
21265
- * The version of the website.
21266
- *
21267
- * @example
21268
- * 1
21269
- */
21270
- siteVersion?: number;
21271
- static names(): { [key: string]: string } {
21272
- return {
21273
- pageNumber: 'PageNumber',
21274
- pageSize: 'PageSize',
21275
- phase: 'Phase',
21276
- queryArgsShrink: 'QueryArgs',
21277
- siteId: 'SiteId',
21278
- siteVersion: 'SiteVersion',
21279
- };
21280
- }
21281
-
21282
- static types(): { [key: string]: any } {
21283
- return {
21284
- pageNumber: 'number',
21285
- pageSize: 'number',
21286
- phase: 'string',
21287
- queryArgsShrink: 'string',
21288
- siteId: 'number',
21289
- siteVersion: 'number',
21290
- };
21291
- }
21292
-
21293
- constructor(map?: { [key: string]: any }) {
21294
- super(map);
21295
- }
21296
- }
21297
-
21298
- export class ListWafRulesetsResponseBody extends $tea.Model {
21299
- /**
21300
- * @remarks
21301
- * The number of WAF rulesets that are used by the instance in the WAF rule category.
21302
- *
21303
- * @example
21304
- * 10
21305
- */
21306
- instanceUsage?: number;
21307
- /**
21308
- * @remarks
21309
- * The page number returned.
21310
- *
21311
- * @example
21312
- * 1
21313
- */
21314
- pageNumber?: number;
21315
- /**
21316
- * @remarks
21317
- * The number of entries per page.
21318
- *
21319
- * @example
21320
- * 20
21321
- */
21322
- pageSize?: number;
21323
- /**
21324
- * @remarks
21325
- * The request ID.
21326
- *
21327
- * @example
21328
- * 36af3fcc-43d0-441c-86b1-428951dc8225
21329
- */
21330
- requestId?: string;
21331
- /**
21332
- * @remarks
21333
- * The details of the rulesets.
21334
- */
21335
- rulesets?: ListWafRulesetsResponseBodyRulesets[];
21336
- /**
21337
- * @remarks
21338
- * The number of WAF rulesets that are used by the website in the WAF rule category.
21339
- *
21340
- * @example
21341
- * 5
21342
- */
21343
- siteUsage?: number;
21344
- /**
21345
- * @remarks
21346
- * The total number of filtered rulesets.
21347
- *
21348
- * @example
21349
- * 5
21350
- */
21351
- totalCount?: number;
21352
- static names(): { [key: string]: string } {
21353
- return {
21354
- instanceUsage: 'InstanceUsage',
21355
- pageNumber: 'PageNumber',
21356
- pageSize: 'PageSize',
21357
- requestId: 'RequestId',
21358
- rulesets: 'Rulesets',
21359
- siteUsage: 'SiteUsage',
21360
- totalCount: 'TotalCount',
21361
- };
21362
- }
21363
-
21364
- static types(): { [key: string]: any } {
21365
- return {
21366
- instanceUsage: 'number',
21367
- pageNumber: 'number',
21368
- pageSize: 'number',
21369
- requestId: 'string',
21370
- rulesets: { 'type': 'array', 'itemType': ListWafRulesetsResponseBodyRulesets },
21371
- siteUsage: 'number',
21372
- totalCount: 'number',
21373
- };
21374
- }
21375
-
21376
- constructor(map?: { [key: string]: any }) {
21377
- super(map);
21378
- }
21379
- }
21380
-
21381
- export class ListWafRulesetsResponse extends $tea.Model {
21382
- headers?: { [key: string]: string };
21383
- statusCode?: number;
21384
- body?: ListWafRulesetsResponseBody;
21385
- static names(): { [key: string]: string } {
21386
- return {
21387
- headers: 'headers',
21388
- statusCode: 'statusCode',
21389
- body: 'body',
21390
- };
21391
- }
21392
-
21393
- static types(): { [key: string]: any } {
21394
- return {
21395
- headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
21396
- statusCode: 'number',
21397
- body: ListWafRulesetsResponseBody,
21398
- };
21399
- }
21400
-
21401
- constructor(map?: { [key: string]: any }) {
21402
- super(map);
21403
- }
21404
- }
21405
-
21406
19817
  export class ListWafTemplateRulesRequest extends $tea.Model {
21407
19818
  /**
21408
19819
  * @remarks
@@ -23830,16 +22241,23 @@ export class SetCertificateResponse extends $tea.Model {
23830
22241
  export class SetClientCertificateHostnamesRequest extends $tea.Model {
23831
22242
  /**
23832
22243
  * @remarks
22244
+ * The domain names to associate.
22245
+ *
23833
22246
  * This parameter is required.
23834
22247
  */
23835
22248
  hostnames?: string[];
23836
22249
  /**
22250
+ * @remarks
22251
+ * The ID of the client CA certificate.
22252
+ *
23837
22253
  * @example
23838
22254
  * babab9db65ee5efcca9f3d41d4b50d66
23839
22255
  */
23840
22256
  id?: string;
23841
22257
  /**
23842
22258
  * @remarks
22259
+ * The website ID.
22260
+ *
23843
22261
  * This parameter is required.
23844
22262
  *
23845
22263
  * @example
@@ -23870,16 +22288,23 @@ export class SetClientCertificateHostnamesRequest extends $tea.Model {
23870
22288
  export class SetClientCertificateHostnamesShrinkRequest extends $tea.Model {
23871
22289
  /**
23872
22290
  * @remarks
22291
+ * The domain names to associate.
22292
+ *
23873
22293
  * This parameter is required.
23874
22294
  */
23875
22295
  hostnamesShrink?: string;
23876
22296
  /**
22297
+ * @remarks
22298
+ * The ID of the client CA certificate.
22299
+ *
23877
22300
  * @example
23878
22301
  * babab9db65ee5efcca9f3d41d4b50d66
23879
22302
  */
23880
22303
  id?: string;
23881
22304
  /**
23882
22305
  * @remarks
22306
+ * The website ID.
22307
+ *
23883
22308
  * This parameter is required.
23884
22309
  *
23885
22310
  * @example
@@ -23909,21 +22334,33 @@ export class SetClientCertificateHostnamesShrinkRequest extends $tea.Model {
23909
22334
 
23910
22335
  export class SetClientCertificateHostnamesResponseBody extends $tea.Model {
23911
22336
  /**
22337
+ * @remarks
22338
+ * The ID of the client CA certificate.
22339
+ *
23912
22340
  * @example
23913
22341
  * babab9db65ee5efcca9f3d41d4b50d66
23914
22342
  */
23915
22343
  id?: string;
23916
22344
  /**
22345
+ * @remarks
22346
+ * The request ID.
22347
+ *
23917
22348
  * @example
23918
22349
  * ET5BF670-09D5-4D0B-BEBY-D96A2A528000
23919
22350
  */
23920
22351
  requestId?: string;
23921
22352
  /**
22353
+ * @remarks
22354
+ * The website ID.
22355
+ *
23922
22356
  * @example
23923
22357
  * 1234567890123
23924
22358
  */
23925
22359
  siteId?: number;
23926
22360
  /**
22361
+ * @remarks
22362
+ * The website name.
22363
+ *
23927
22364
  * @example
23928
22365
  * example.com
23929
22366
  */
@@ -26454,339 +24891,10 @@ export class UpdateSiteDeliveryTaskResponseBody extends $tea.Model {
26454
24891
  }
26455
24892
  }
26456
24893
 
26457
- export class UpdateSiteDeliveryTaskResponse extends $tea.Model {
26458
- headers?: { [key: string]: string };
26459
- statusCode?: number;
26460
- body?: UpdateSiteDeliveryTaskResponseBody;
26461
- static names(): { [key: string]: string } {
26462
- return {
26463
- headers: 'headers',
26464
- statusCode: 'statusCode',
26465
- body: 'body',
26466
- };
26467
- }
26468
-
26469
- static types(): { [key: string]: any } {
26470
- return {
26471
- headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
26472
- statusCode: 'number',
26473
- body: UpdateSiteDeliveryTaskResponseBody,
26474
- };
26475
- }
26476
-
26477
- constructor(map?: { [key: string]: any }) {
26478
- super(map);
26479
- }
26480
- }
26481
-
26482
- export class UpdateSiteDeliveryTaskStatusRequest extends $tea.Model {
26483
- /**
26484
- * @remarks
26485
- * Specifies whether to enable the delivery task.
26486
- *
26487
- * This parameter is required.
26488
- *
26489
- * @example
26490
- * online
26491
- */
26492
- method?: string;
26493
- /**
26494
- * @remarks
26495
- * The website ID.
26496
- *
26497
- * @example
26498
- * 123456****
26499
- */
26500
- siteId?: number;
26501
- /**
26502
- * @remarks
26503
- * The name of the delivery task.
26504
- *
26505
- * This parameter is required.
26506
- *
26507
- * @example
26508
- * cdn-test-task
26509
- */
26510
- taskName?: string;
26511
- static names(): { [key: string]: string } {
26512
- return {
26513
- method: 'Method',
26514
- siteId: 'SiteId',
26515
- taskName: 'TaskName',
26516
- };
26517
- }
26518
-
26519
- static types(): { [key: string]: any } {
26520
- return {
26521
- method: 'string',
26522
- siteId: 'number',
26523
- taskName: 'string',
26524
- };
26525
- }
26526
-
26527
- constructor(map?: { [key: string]: any }) {
26528
- super(map);
26529
- }
26530
- }
26531
-
26532
- export class UpdateSiteDeliveryTaskStatusResponseBody extends $tea.Model {
26533
- /**
26534
- * @remarks
26535
- * The request ID.
26536
- *
26537
- * @example
26538
- * 34DCBC8A-****-****-****-6DAA11D7DDBD
26539
- */
26540
- requestId?: string;
26541
- /**
26542
- * @remarks
26543
- * The status of the delivery task. Valid values:
26544
- *
26545
- * * **online**
26546
- * * **offline**
26547
- *
26548
- * @example
26549
- * online
26550
- */
26551
- status?: string;
26552
- /**
26553
- * @remarks
26554
- * The name of the delivery task.
26555
- *
26556
- * @example
26557
- * cdn-test-task
26558
- */
26559
- taskName?: string;
26560
- static names(): { [key: string]: string } {
26561
- return {
26562
- requestId: 'RequestId',
26563
- status: 'Status',
26564
- taskName: 'TaskName',
26565
- };
26566
- }
26567
-
26568
- static types(): { [key: string]: any } {
26569
- return {
26570
- requestId: 'string',
26571
- status: 'string',
26572
- taskName: 'string',
26573
- };
26574
- }
26575
-
26576
- constructor(map?: { [key: string]: any }) {
26577
- super(map);
26578
- }
26579
- }
26580
-
26581
- export class UpdateSiteDeliveryTaskStatusResponse extends $tea.Model {
26582
- headers?: { [key: string]: string };
26583
- statusCode?: number;
26584
- body?: UpdateSiteDeliveryTaskStatusResponseBody;
26585
- static names(): { [key: string]: string } {
26586
- return {
26587
- headers: 'headers',
26588
- statusCode: 'statusCode',
26589
- body: 'body',
26590
- };
26591
- }
26592
-
26593
- static types(): { [key: string]: any } {
26594
- return {
26595
- headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
26596
- statusCode: 'number',
26597
- body: UpdateSiteDeliveryTaskStatusResponseBody,
26598
- };
26599
- }
26600
-
26601
- constructor(map?: { [key: string]: any }) {
26602
- super(map);
26603
- }
26604
- }
26605
-
26606
- export class UpdateSiteVanityNSRequest extends $tea.Model {
26607
- /**
26608
- * @remarks
26609
- * The website ID. You can call the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation to obtain the ID.
26610
- *
26611
- * This parameter is required.
26612
- *
26613
- * @example
26614
- * 1234567890123
26615
- */
26616
- siteId?: number;
26617
- /**
26618
- * @remarks
26619
- * The custom nameserver names. You can specify two to five custom nameserver names. Separate multiple names with commas (,).
26620
- *
26621
- * @example
26622
- * ns1.example.com,ns2.example.com
26623
- */
26624
- vanityNSList?: string;
26625
- static names(): { [key: string]: string } {
26626
- return {
26627
- siteId: 'SiteId',
26628
- vanityNSList: 'VanityNSList',
26629
- };
26630
- }
26631
-
26632
- static types(): { [key: string]: any } {
26633
- return {
26634
- siteId: 'number',
26635
- vanityNSList: 'string',
26636
- };
26637
- }
26638
-
26639
- constructor(map?: { [key: string]: any }) {
26640
- super(map);
26641
- }
26642
- }
26643
-
26644
- export class UpdateSiteVanityNSResponseBody extends $tea.Model {
26645
- /**
26646
- * @remarks
26647
- * The request ID.
26648
- *
26649
- * @example
26650
- * 0AEDAF20-4DDF-4165-8750-47FF9C1929C9
26651
- */
26652
- requestId?: string;
26653
- static names(): { [key: string]: string } {
26654
- return {
26655
- requestId: 'RequestId',
26656
- };
26657
- }
26658
-
26659
- static types(): { [key: string]: any } {
26660
- return {
26661
- requestId: 'string',
26662
- };
26663
- }
26664
-
26665
- constructor(map?: { [key: string]: any }) {
26666
- super(map);
26667
- }
26668
- }
26669
-
26670
- export class UpdateSiteVanityNSResponse extends $tea.Model {
26671
- headers?: { [key: string]: string };
26672
- statusCode?: number;
26673
- body?: UpdateSiteVanityNSResponseBody;
26674
- static names(): { [key: string]: string } {
26675
- return {
26676
- headers: 'headers',
26677
- statusCode: 'statusCode',
26678
- body: 'body',
26679
- };
26680
- }
26681
-
26682
- static types(): { [key: string]: any } {
26683
- return {
26684
- headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
26685
- statusCode: 'number',
26686
- body: UpdateSiteVanityNSResponseBody,
26687
- };
26688
- }
26689
-
26690
- constructor(map?: { [key: string]: any }) {
26691
- super(map);
26692
- }
26693
- }
26694
-
26695
- export class UpdateUserDeliveryTaskRequest extends $tea.Model {
26696
- /**
26697
- * @remarks
26698
- * The log category. Valid values:
26699
- *
26700
- * * dcdn_log_access_l1 (default): access logs.
26701
- * * dcdn_log_er: Edge Routine logs.
26702
- * * dcdn_log_waf: firewall logs.
26703
- * * dcdn_log_ipa: TCP/UDP proxy logs.
26704
- *
26705
- * @example
26706
- * dcdn_log_er
26707
- */
26708
- businessType?: string;
26709
- /**
26710
- * @remarks
26711
- * The discard rate. Default value: 0.
26712
- *
26713
- * @example
26714
- * 0
26715
- */
26716
- discardRate?: number;
26717
- /**
26718
- * @remarks
26719
- * The log fields that you want to include in logs to be delivered. Separate the log fields with commas (,).
26720
- *
26721
- * This parameter is required.
26722
- *
26723
- * @example
26724
- * ClientRequestID,ClientRequestHost
26725
- */
26726
- fieldName?: string;
26727
- /**
26728
- * @remarks
26729
- * The name of the delivery task.
26730
- *
26731
- * This parameter is required.
26732
- *
26733
- * @example
26734
- * test_project
26735
- */
26736
- taskName?: string;
26737
- static names(): { [key: string]: string } {
26738
- return {
26739
- businessType: 'BusinessType',
26740
- discardRate: 'DiscardRate',
26741
- fieldName: 'FieldName',
26742
- taskName: 'TaskName',
26743
- };
26744
- }
26745
-
26746
- static types(): { [key: string]: any } {
26747
- return {
26748
- businessType: 'string',
26749
- discardRate: 'number',
26750
- fieldName: 'string',
26751
- taskName: 'string',
26752
- };
26753
- }
26754
-
26755
- constructor(map?: { [key: string]: any }) {
26756
- super(map);
26757
- }
26758
- }
26759
-
26760
- export class UpdateUserDeliveryTaskResponseBody extends $tea.Model {
26761
- /**
26762
- * @remarks
26763
- * The request ID.
26764
- *
26765
- * @example
26766
- * 34DCBC8A-****-****-****-6DAA11D7DDBD
26767
- */
26768
- requestId?: string;
26769
- static names(): { [key: string]: string } {
26770
- return {
26771
- requestId: 'RequestId',
26772
- };
26773
- }
26774
-
26775
- static types(): { [key: string]: any } {
26776
- return {
26777
- requestId: 'string',
26778
- };
26779
- }
26780
-
26781
- constructor(map?: { [key: string]: any }) {
26782
- super(map);
26783
- }
26784
- }
26785
-
26786
- export class UpdateUserDeliveryTaskResponse extends $tea.Model {
24894
+ export class UpdateSiteDeliveryTaskResponse extends $tea.Model {
26787
24895
  headers?: { [key: string]: string };
26788
24896
  statusCode?: number;
26789
- body?: UpdateUserDeliveryTaskResponseBody;
24897
+ body?: UpdateSiteDeliveryTaskResponseBody;
26790
24898
  static names(): { [key: string]: string } {
26791
24899
  return {
26792
24900
  headers: 'headers',
@@ -26799,7 +24907,7 @@ export class UpdateUserDeliveryTaskResponse extends $tea.Model {
26799
24907
  return {
26800
24908
  headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
26801
24909
  statusCode: 'number',
26802
- body: UpdateUserDeliveryTaskResponseBody,
24910
+ body: UpdateSiteDeliveryTaskResponseBody,
26803
24911
  };
26804
24912
  }
26805
24913
 
@@ -26808,10 +24916,10 @@ export class UpdateUserDeliveryTaskResponse extends $tea.Model {
26808
24916
  }
26809
24917
  }
26810
24918
 
26811
- export class UpdateUserDeliveryTaskStatusRequest extends $tea.Model {
24919
+ export class UpdateSiteDeliveryTaskStatusRequest extends $tea.Model {
26812
24920
  /**
26813
24921
  * @remarks
26814
- * Enables or disables the delivery task. Valid values: online and offline.
24922
+ * Specifies whether to enable the delivery task.
26815
24923
  *
26816
24924
  * This parameter is required.
26817
24925
  *
@@ -26819,6 +24927,14 @@ export class UpdateUserDeliveryTaskStatusRequest extends $tea.Model {
26819
24927
  * online
26820
24928
  */
26821
24929
  method?: string;
24930
+ /**
24931
+ * @remarks
24932
+ * The website ID.
24933
+ *
24934
+ * @example
24935
+ * 123456****
24936
+ */
24937
+ siteId?: number;
26822
24938
  /**
26823
24939
  * @remarks
26824
24940
  * The name of the delivery task.
@@ -26826,12 +24942,13 @@ export class UpdateUserDeliveryTaskStatusRequest extends $tea.Model {
26826
24942
  * This parameter is required.
26827
24943
  *
26828
24944
  * @example
26829
- * test_project
24945
+ * cdn-test-task
26830
24946
  */
26831
24947
  taskName?: string;
26832
24948
  static names(): { [key: string]: string } {
26833
24949
  return {
26834
24950
  method: 'Method',
24951
+ siteId: 'SiteId',
26835
24952
  taskName: 'TaskName',
26836
24953
  };
26837
24954
  }
@@ -26839,6 +24956,7 @@ export class UpdateUserDeliveryTaskStatusRequest extends $tea.Model {
26839
24956
  static types(): { [key: string]: any } {
26840
24957
  return {
26841
24958
  method: 'string',
24959
+ siteId: 'number',
26842
24960
  taskName: 'string',
26843
24961
  };
26844
24962
  }
@@ -26848,7 +24966,7 @@ export class UpdateUserDeliveryTaskStatusRequest extends $tea.Model {
26848
24966
  }
26849
24967
  }
26850
24968
 
26851
- export class UpdateUserDeliveryTaskStatusResponseBody extends $tea.Model {
24969
+ export class UpdateSiteDeliveryTaskStatusResponseBody extends $tea.Model {
26852
24970
  /**
26853
24971
  * @remarks
26854
24972
  * The request ID.
@@ -26859,7 +24977,10 @@ export class UpdateUserDeliveryTaskStatusResponseBody extends $tea.Model {
26859
24977
  requestId?: string;
26860
24978
  /**
26861
24979
  * @remarks
26862
- * The status of the delivery task.
24980
+ * The status of the delivery task. Valid values:
24981
+ *
24982
+ * * **online**
24983
+ * * **offline**
26863
24984
  *
26864
24985
  * @example
26865
24986
  * online
@@ -26870,7 +24991,7 @@ export class UpdateUserDeliveryTaskStatusResponseBody extends $tea.Model {
26870
24991
  * The name of the delivery task.
26871
24992
  *
26872
24993
  * @example
26873
- * test_project
24994
+ * cdn-test-task
26874
24995
  */
26875
24996
  taskName?: string;
26876
24997
  static names(): { [key: string]: string } {
@@ -26894,10 +25015,10 @@ export class UpdateUserDeliveryTaskStatusResponseBody extends $tea.Model {
26894
25015
  }
26895
25016
  }
26896
25017
 
26897
- export class UpdateUserDeliveryTaskStatusResponse extends $tea.Model {
25018
+ export class UpdateSiteDeliveryTaskStatusResponse extends $tea.Model {
26898
25019
  headers?: { [key: string]: string };
26899
25020
  statusCode?: number;
26900
- body?: UpdateUserDeliveryTaskStatusResponseBody;
25021
+ body?: UpdateSiteDeliveryTaskStatusResponseBody;
26901
25022
  static names(): { [key: string]: string } {
26902
25023
  return {
26903
25024
  headers: 'headers',
@@ -26910,7 +25031,7 @@ export class UpdateUserDeliveryTaskStatusResponse extends $tea.Model {
26910
25031
  return {
26911
25032
  headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
26912
25033
  statusCode: 'number',
26913
- body: UpdateUserDeliveryTaskStatusResponseBody,
25034
+ body: UpdateSiteDeliveryTaskStatusResponseBody,
26914
25035
  };
26915
25036
  }
26916
25037
 
@@ -26919,75 +25040,36 @@ export class UpdateUserDeliveryTaskStatusResponse extends $tea.Model {
26919
25040
  }
26920
25041
  }
26921
25042
 
26922
- export class UpdateWafRuleRequest extends $tea.Model {
26923
- /**
26924
- * @remarks
26925
- * The configuration of the rule.
26926
- */
26927
- config?: WafRuleConfig;
26928
- /**
26929
- * @remarks
26930
- * The ID of the WAF rule, which can be obtained by calling the [ListWafRules](https://help.aliyun.com/document_detail/2850237.html) operation.
26931
- *
26932
- * This parameter is required.
26933
- *
26934
- * @example
26935
- * 20000001
26936
- */
26937
- id?: number;
26938
- /**
26939
- * @remarks
26940
- * The order of the rule in the ruleset.
26941
- *
26942
- * @example
26943
- * 1
26944
- */
26945
- position?: number;
25043
+ export class UpdateSiteVanityNSRequest extends $tea.Model {
26946
25044
  /**
26947
25045
  * @remarks
26948
- * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
25046
+ * The website ID. You can call the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation to obtain the ID.
26949
25047
  *
26950
25048
  * This parameter is required.
26951
25049
  *
26952
25050
  * @example
26953
- * 1
25051
+ * 1234567890123
26954
25052
  */
26955
25053
  siteId?: number;
26956
25054
  /**
26957
25055
  * @remarks
26958
- * The version of the website.
26959
- *
26960
- * @example
26961
- * 0
26962
- */
26963
- siteVersion?: number;
26964
- /**
26965
- * @remarks
26966
- * The status of the rule.
25056
+ * The custom nameserver names. You can specify two to five custom nameserver names. Separate multiple names with commas (,).
26967
25057
  *
26968
25058
  * @example
26969
- * on
25059
+ * ns1.example.com,ns2.example.com
26970
25060
  */
26971
- status?: string;
25061
+ vanityNSList?: string;
26972
25062
  static names(): { [key: string]: string } {
26973
25063
  return {
26974
- config: 'Config',
26975
- id: 'Id',
26976
- position: 'Position',
26977
25064
  siteId: 'SiteId',
26978
- siteVersion: 'SiteVersion',
26979
- status: 'Status',
25065
+ vanityNSList: 'VanityNSList',
26980
25066
  };
26981
25067
  }
26982
25068
 
26983
25069
  static types(): { [key: string]: any } {
26984
25070
  return {
26985
- config: WafRuleConfig,
26986
- id: 'number',
26987
- position: 'number',
26988
25071
  siteId: 'number',
26989
- siteVersion: 'number',
26990
- status: 'string',
25072
+ vanityNSList: 'string',
26991
25073
  };
26992
25074
  }
26993
25075
 
@@ -26996,75 +25078,114 @@ export class UpdateWafRuleRequest extends $tea.Model {
26996
25078
  }
26997
25079
  }
26998
25080
 
26999
- export class UpdateWafRuleShrinkRequest extends $tea.Model {
25081
+ export class UpdateSiteVanityNSResponseBody extends $tea.Model {
27000
25082
  /**
27001
25083
  * @remarks
27002
- * The configuration of the rule.
25084
+ * The request ID.
25085
+ *
25086
+ * @example
25087
+ * 0AEDAF20-4DDF-4165-8750-47FF9C1929C9
27003
25088
  */
27004
- configShrink?: string;
25089
+ requestId?: string;
25090
+ static names(): { [key: string]: string } {
25091
+ return {
25092
+ requestId: 'RequestId',
25093
+ };
25094
+ }
25095
+
25096
+ static types(): { [key: string]: any } {
25097
+ return {
25098
+ requestId: 'string',
25099
+ };
25100
+ }
25101
+
25102
+ constructor(map?: { [key: string]: any }) {
25103
+ super(map);
25104
+ }
25105
+ }
25106
+
25107
+ export class UpdateSiteVanityNSResponse extends $tea.Model {
25108
+ headers?: { [key: string]: string };
25109
+ statusCode?: number;
25110
+ body?: UpdateSiteVanityNSResponseBody;
25111
+ static names(): { [key: string]: string } {
25112
+ return {
25113
+ headers: 'headers',
25114
+ statusCode: 'statusCode',
25115
+ body: 'body',
25116
+ };
25117
+ }
25118
+
25119
+ static types(): { [key: string]: any } {
25120
+ return {
25121
+ headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
25122
+ statusCode: 'number',
25123
+ body: UpdateSiteVanityNSResponseBody,
25124
+ };
25125
+ }
25126
+
25127
+ constructor(map?: { [key: string]: any }) {
25128
+ super(map);
25129
+ }
25130
+ }
25131
+
25132
+ export class UpdateUserDeliveryTaskRequest extends $tea.Model {
27005
25133
  /**
27006
25134
  * @remarks
27007
- * The ID of the WAF rule, which can be obtained by calling the [ListWafRules](https://help.aliyun.com/document_detail/2850237.html) operation.
25135
+ * The log category. Valid values:
27008
25136
  *
27009
- * This parameter is required.
25137
+ * * dcdn_log_access_l1 (default): access logs.
25138
+ * * dcdn_log_er: Edge Routine logs.
25139
+ * * dcdn_log_waf: firewall logs.
25140
+ * * dcdn_log_ipa: TCP/UDP proxy logs.
27010
25141
  *
27011
25142
  * @example
27012
- * 20000001
25143
+ * dcdn_log_er
27013
25144
  */
27014
- id?: number;
25145
+ businessType?: string;
27015
25146
  /**
27016
25147
  * @remarks
27017
- * The order of the rule in the ruleset.
25148
+ * The discard rate. Default value: 0.
27018
25149
  *
27019
25150
  * @example
27020
- * 1
25151
+ * 0
27021
25152
  */
27022
- position?: number;
25153
+ discardRate?: number;
27023
25154
  /**
27024
25155
  * @remarks
27025
- * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
25156
+ * The log fields that you want to include in logs to be delivered. Separate the log fields with commas (,).
27026
25157
  *
27027
25158
  * This parameter is required.
27028
25159
  *
27029
25160
  * @example
27030
- * 1
25161
+ * ClientRequestID,ClientRequestHost
27031
25162
  */
27032
- siteId?: number;
25163
+ fieldName?: string;
27033
25164
  /**
27034
25165
  * @remarks
27035
- * The version of the website.
25166
+ * The name of the delivery task.
27036
25167
  *
27037
- * @example
27038
- * 0
27039
- */
27040
- siteVersion?: number;
27041
- /**
27042
- * @remarks
27043
- * The status of the rule.
25168
+ * This parameter is required.
27044
25169
  *
27045
25170
  * @example
27046
- * on
25171
+ * test_project
27047
25172
  */
27048
- status?: string;
25173
+ taskName?: string;
27049
25174
  static names(): { [key: string]: string } {
27050
25175
  return {
27051
- configShrink: 'Config',
27052
- id: 'Id',
27053
- position: 'Position',
27054
- siteId: 'SiteId',
27055
- siteVersion: 'SiteVersion',
27056
- status: 'Status',
25176
+ businessType: 'BusinessType',
25177
+ discardRate: 'DiscardRate',
25178
+ fieldName: 'FieldName',
25179
+ taskName: 'TaskName',
27057
25180
  };
27058
25181
  }
27059
25182
 
27060
25183
  static types(): { [key: string]: any } {
27061
25184
  return {
27062
- configShrink: 'string',
27063
- id: 'number',
27064
- position: 'number',
27065
- siteId: 'number',
27066
- siteVersion: 'number',
27067
- status: 'string',
25185
+ businessType: 'string',
25186
+ discardRate: 'number',
25187
+ fieldName: 'string',
25188
+ taskName: 'string',
27068
25189
  };
27069
25190
  }
27070
25191
 
@@ -27073,33 +25194,23 @@ export class UpdateWafRuleShrinkRequest extends $tea.Model {
27073
25194
  }
27074
25195
  }
27075
25196
 
27076
- export class UpdateWafRuleResponseBody extends $tea.Model {
27077
- /**
27078
- * @remarks
27079
- * The ID of the WAF rule.[](~~2850237~~)
27080
- *
27081
- * @example
27082
- * 20000001
27083
- */
27084
- id?: number;
25197
+ export class UpdateUserDeliveryTaskResponseBody extends $tea.Model {
27085
25198
  /**
27086
25199
  * @remarks
27087
25200
  * The request ID.
27088
25201
  *
27089
25202
  * @example
27090
- * 36af3fcc-43d0-441c-86b1-428951dc8225
25203
+ * 34DCBC8A-****-****-****-6DAA11D7DDBD
27091
25204
  */
27092
25205
  requestId?: string;
27093
25206
  static names(): { [key: string]: string } {
27094
25207
  return {
27095
- id: 'Id',
27096
25208
  requestId: 'RequestId',
27097
25209
  };
27098
25210
  }
27099
25211
 
27100
25212
  static types(): { [key: string]: any } {
27101
25213
  return {
27102
- id: 'number',
27103
25214
  requestId: 'string',
27104
25215
  };
27105
25216
  }
@@ -27109,10 +25220,10 @@ export class UpdateWafRuleResponseBody extends $tea.Model {
27109
25220
  }
27110
25221
  }
27111
25222
 
27112
- export class UpdateWafRuleResponse extends $tea.Model {
25223
+ export class UpdateUserDeliveryTaskResponse extends $tea.Model {
27113
25224
  headers?: { [key: string]: string };
27114
25225
  statusCode?: number;
27115
- body?: UpdateWafRuleResponseBody;
25226
+ body?: UpdateUserDeliveryTaskResponseBody;
27116
25227
  static names(): { [key: string]: string } {
27117
25228
  return {
27118
25229
  headers: 'headers',
@@ -27125,7 +25236,7 @@ export class UpdateWafRuleResponse extends $tea.Model {
27125
25236
  return {
27126
25237
  headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
27127
25238
  statusCode: 'number',
27128
- body: UpdateWafRuleResponseBody,
25239
+ body: UpdateUserDeliveryTaskResponseBody,
27129
25240
  };
27130
25241
  }
27131
25242
 
@@ -27134,56 +25245,38 @@ export class UpdateWafRuleResponse extends $tea.Model {
27134
25245
  }
27135
25246
  }
27136
25247
 
27137
- export class UpdateWafRulesetRequest extends $tea.Model {
25248
+ export class UpdateUserDeliveryTaskStatusRequest extends $tea.Model {
27138
25249
  /**
27139
25250
  * @remarks
27140
- * The ID of the WAF ruleset, which can be obtained by calling the [ListWafRulesets](https://help.aliyun.com/document_detail/2850233.html) operation.
25251
+ * Enables or disables the delivery task. Valid values: online and offline.
27141
25252
  *
27142
25253
  * This parameter is required.
27143
25254
  *
27144
25255
  * @example
27145
- * 10000001
27146
- */
27147
- id?: number;
27148
- /**
27149
- * @remarks
27150
- * The website ID, which can be obtained by calling the [ListSites](https://help.aliyun.com/document_detail/2850189.html) operation.
27151
- *
27152
- * @example
27153
- * 1
25256
+ * online
27154
25257
  */
27155
- siteId?: number;
25258
+ method?: string;
27156
25259
  /**
27157
25260
  * @remarks
27158
- * The version of the website.
25261
+ * The name of the delivery task.
27159
25262
  *
27160
- * @example
27161
- * 1
27162
- */
27163
- siteVersion?: number;
27164
- /**
27165
- * @remarks
27166
- * The status to which you want to change the ruleset.
25263
+ * This parameter is required.
27167
25264
  *
27168
25265
  * @example
27169
- * on
25266
+ * test_project
27170
25267
  */
27171
- status?: string;
25268
+ taskName?: string;
27172
25269
  static names(): { [key: string]: string } {
27173
25270
  return {
27174
- id: 'Id',
27175
- siteId: 'SiteId',
27176
- siteVersion: 'SiteVersion',
27177
- status: 'Status',
25271
+ method: 'Method',
25272
+ taskName: 'TaskName',
27178
25273
  };
27179
25274
  }
27180
25275
 
27181
25276
  static types(): { [key: string]: any } {
27182
25277
  return {
27183
- id: 'number',
27184
- siteId: 'number',
27185
- siteVersion: 'number',
27186
- status: 'string',
25278
+ method: 'string',
25279
+ taskName: 'string',
27187
25280
  };
27188
25281
  }
27189
25282
 
@@ -27192,24 +25285,44 @@ export class UpdateWafRulesetRequest extends $tea.Model {
27192
25285
  }
27193
25286
  }
27194
25287
 
27195
- export class UpdateWafRulesetResponseBody extends $tea.Model {
25288
+ export class UpdateUserDeliveryTaskStatusResponseBody extends $tea.Model {
27196
25289
  /**
27197
25290
  * @remarks
27198
25291
  * The request ID.
27199
25292
  *
27200
25293
  * @example
27201
- * 36af3fcc-43d0-441c-86b1-428951dc8225
25294
+ * 34DCBC8A-****-****-****-6DAA11D7DDBD
27202
25295
  */
27203
25296
  requestId?: string;
25297
+ /**
25298
+ * @remarks
25299
+ * The status of the delivery task.
25300
+ *
25301
+ * @example
25302
+ * online
25303
+ */
25304
+ status?: string;
25305
+ /**
25306
+ * @remarks
25307
+ * The name of the delivery task.
25308
+ *
25309
+ * @example
25310
+ * test_project
25311
+ */
25312
+ taskName?: string;
27204
25313
  static names(): { [key: string]: string } {
27205
25314
  return {
27206
25315
  requestId: 'RequestId',
25316
+ status: 'Status',
25317
+ taskName: 'TaskName',
27207
25318
  };
27208
25319
  }
27209
25320
 
27210
25321
  static types(): { [key: string]: any } {
27211
25322
  return {
27212
25323
  requestId: 'string',
25324
+ status: 'string',
25325
+ taskName: 'string',
27213
25326
  };
27214
25327
  }
27215
25328
 
@@ -27218,10 +25331,10 @@ export class UpdateWafRulesetResponseBody extends $tea.Model {
27218
25331
  }
27219
25332
  }
27220
25333
 
27221
- export class UpdateWafRulesetResponse extends $tea.Model {
25334
+ export class UpdateUserDeliveryTaskStatusResponse extends $tea.Model {
27222
25335
  headers?: { [key: string]: string };
27223
25336
  statusCode?: number;
27224
- body?: UpdateWafRulesetResponseBody;
25337
+ body?: UpdateUserDeliveryTaskStatusResponseBody;
27225
25338
  static names(): { [key: string]: string } {
27226
25339
  return {
27227
25340
  headers: 'headers',
@@ -27234,7 +25347,7 @@ export class UpdateWafRulesetResponse extends $tea.Model {
27234
25347
  return {
27235
25348
  headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
27236
25349
  statusCode: 'number',
27237
- body: UpdateWafRulesetResponseBody,
25350
+ body: UpdateUserDeliveryTaskStatusResponseBody,
27238
25351
  };
27239
25352
  }
27240
25353
 
@@ -38783,6 +36896,10 @@ export class ListSitesResponseBodySites extends $tea.Model {
38783
36896
  * verify_d516cb3740f81f0cef77d162edd1****
38784
36897
  */
38785
36898
  verifyCode?: string;
36899
+ /**
36900
+ * @example
36901
+ * 2023-12-24T02:01:11Z
36902
+ */
38786
36903
  visitTime?: string;
38787
36904
  static names(): { [key: string]: string } {
38788
36905
  return {
@@ -39340,7 +37457,7 @@ export class ListWafManagedRulesRequestQueryArgs extends $tea.Model {
39340
37457
  protectionLevels?: number[];
39341
37458
  /**
39342
37459
  * @remarks
39343
- * The status.
37460
+ * The status of the rule.
39344
37461
  *
39345
37462
  * @example
39346
37463
  * on
@@ -39515,389 +37632,6 @@ export class ListWafPhasesResponseBodyPhases extends $tea.Model {
39515
37632
  }
39516
37633
  }
39517
37634
 
39518
- export class ListWafRulesRequestQueryArgs extends $tea.Model {
39519
- configValueLike?: string;
39520
- /**
39521
- * @remarks
39522
- * Specifies whether to sort the returned data in descending order.
39523
- *
39524
- * @example
39525
- * true
39526
- */
39527
- desc?: boolean;
39528
- /**
39529
- * @remarks
39530
- * The ID of a WAF rule for exact search.
39531
- *
39532
- * @example
39533
- * 20000001
39534
- */
39535
- id?: number;
39536
- /**
39537
- * @remarks
39538
- * The ID or name of a WAF rule for fuzzy search.
39539
- *
39540
- * @example
39541
- * example
39542
- */
39543
- idNameLike?: string;
39544
- /**
39545
- * @remarks
39546
- * The name of a WAF rule for fuzzy search.
39547
- *
39548
- * @example
39549
- * example
39550
- */
39551
- nameLike?: string;
39552
- /**
39553
- * @remarks
39554
- * The column by which you want to sort the returned data.
39555
- *
39556
- * @example
39557
- * position
39558
- */
39559
- orderBy?: string;
39560
- /**
39561
- * @remarks
39562
- * The ID of a WAF ruleset for exact search.
39563
- *
39564
- * @example
39565
- * 10000001
39566
- */
39567
- rulesetId?: number;
39568
- /**
39569
- * @remarks
39570
- * The status of a WAF rule for exact search.
39571
- *
39572
- * @example
39573
- * on
39574
- */
39575
- status?: string;
39576
- static names(): { [key: string]: string } {
39577
- return {
39578
- configValueLike: 'ConfigValueLike',
39579
- desc: 'Desc',
39580
- id: 'Id',
39581
- idNameLike: 'IdNameLike',
39582
- nameLike: 'NameLike',
39583
- orderBy: 'OrderBy',
39584
- rulesetId: 'RulesetId',
39585
- status: 'Status',
39586
- };
39587
- }
39588
-
39589
- static types(): { [key: string]: any } {
39590
- return {
39591
- configValueLike: 'string',
39592
- desc: 'boolean',
39593
- id: 'number',
39594
- idNameLike: 'string',
39595
- nameLike: 'string',
39596
- orderBy: 'string',
39597
- rulesetId: 'number',
39598
- status: 'string',
39599
- };
39600
- }
39601
-
39602
- constructor(map?: { [key: string]: any }) {
39603
- super(map);
39604
- }
39605
- }
39606
-
39607
- export class ListWafRulesResponseBodyRules extends $tea.Model {
39608
- /**
39609
- * @remarks
39610
- * The action triggered when requests match conditions defined in the rule.
39611
- *
39612
- * @example
39613
- * deny
39614
- */
39615
- action?: string;
39616
- /**
39617
- * @remarks
39618
- * The fields in rate limiting rules.
39619
- */
39620
- characteristicsFields?: string[];
39621
- /**
39622
- * @remarks
39623
- * The configuration of the rule.
39624
- */
39625
- config?: WafRuleConfig;
39626
- /**
39627
- * @remarks
39628
- * The fields in the rule.
39629
- */
39630
- fields?: string[];
39631
- /**
39632
- * @remarks
39633
- * The rule ID.
39634
- *
39635
- * @example
39636
- * 20000001
39637
- */
39638
- id?: number;
39639
- /**
39640
- * @remarks
39641
- * The rule name.
39642
- *
39643
- * @example
39644
- * example
39645
- */
39646
- name?: string;
39647
- /**
39648
- * @remarks
39649
- * The WAF rule category.
39650
- *
39651
- * @example
39652
- * http_custom
39653
- */
39654
- phase?: string;
39655
- /**
39656
- * @remarks
39657
- * The position of the rule in the ruleset.
39658
- *
39659
- * @example
39660
- * 1
39661
- */
39662
- position?: number;
39663
- /**
39664
- * @remarks
39665
- * The ruleset ID.
39666
- *
39667
- * @example
39668
- * 10000001
39669
- */
39670
- rulesetId?: number;
39671
- /**
39672
- * @remarks
39673
- * The skip scope applied when requests match conditions defined in the whitelist rule.
39674
- *
39675
- * @example
39676
- * part
39677
- */
39678
- skip?: string;
39679
- /**
39680
- * @remarks
39681
- * Indicates whether the rule is enabled.
39682
- *
39683
- * @example
39684
- * on
39685
- */
39686
- status?: string;
39687
- /**
39688
- * @remarks
39689
- * The skipped WAF rule categories when requests match conditions defined in the whitelist rule.
39690
- */
39691
- tags?: string[];
39692
- /**
39693
- * @remarks
39694
- * The time when the rule takes effect.
39695
- */
39696
- timer?: WafTimer;
39697
- /**
39698
- * @remarks
39699
- * The WAF rule type.
39700
- *
39701
- * @example
39702
- * http_custom
39703
- */
39704
- type?: string;
39705
- /**
39706
- * @remarks
39707
- * The time when the rule was modified.
39708
- *
39709
- * @example
39710
- * 2024-01-01T00:00:00Z
39711
- */
39712
- updateTime?: string;
39713
- static names(): { [key: string]: string } {
39714
- return {
39715
- action: 'Action',
39716
- characteristicsFields: 'CharacteristicsFields',
39717
- config: 'Config',
39718
- fields: 'Fields',
39719
- id: 'Id',
39720
- name: 'Name',
39721
- phase: 'Phase',
39722
- position: 'Position',
39723
- rulesetId: 'RulesetId',
39724
- skip: 'Skip',
39725
- status: 'Status',
39726
- tags: 'Tags',
39727
- timer: 'Timer',
39728
- type: 'Type',
39729
- updateTime: 'UpdateTime',
39730
- };
39731
- }
39732
-
39733
- static types(): { [key: string]: any } {
39734
- return {
39735
- action: 'string',
39736
- characteristicsFields: { 'type': 'array', 'itemType': 'string' },
39737
- config: WafRuleConfig,
39738
- fields: { 'type': 'array', 'itemType': 'string' },
39739
- id: 'number',
39740
- name: 'string',
39741
- phase: 'string',
39742
- position: 'number',
39743
- rulesetId: 'number',
39744
- skip: 'string',
39745
- status: 'string',
39746
- tags: { 'type': 'array', 'itemType': 'string' },
39747
- timer: WafTimer,
39748
- type: 'string',
39749
- updateTime: 'string',
39750
- };
39751
- }
39752
-
39753
- constructor(map?: { [key: string]: any }) {
39754
- super(map);
39755
- }
39756
- }
39757
-
39758
- export class ListWafRulesetsRequestQueryArgs extends $tea.Model {
39759
- /**
39760
- * @remarks
39761
- * The ruleset ID, ruleset name, rule ID, or rule name for fuzzy search.
39762
- *
39763
- * @example
39764
- * example
39765
- */
39766
- anyLike?: string;
39767
- /**
39768
- * @remarks
39769
- * Specifies whether to sort the returned data in descending order.
39770
- */
39771
- desc?: boolean;
39772
- /**
39773
- * @remarks
39774
- * The ruleset name for fuzzy search.
39775
- *
39776
- * @example
39777
- * example
39778
- */
39779
- nameLike?: string;
39780
- /**
39781
- * @remarks
39782
- * The column by which you want to sort the returned data.
39783
- *
39784
- * @example
39785
- * id
39786
- */
39787
- orderBy?: string;
39788
- static names(): { [key: string]: string } {
39789
- return {
39790
- anyLike: 'AnyLike',
39791
- desc: 'Desc',
39792
- nameLike: 'NameLike',
39793
- orderBy: 'OrderBy',
39794
- };
39795
- }
39796
-
39797
- static types(): { [key: string]: any } {
39798
- return {
39799
- anyLike: 'string',
39800
- desc: 'boolean',
39801
- nameLike: 'string',
39802
- orderBy: 'string',
39803
- };
39804
- }
39805
-
39806
- constructor(map?: { [key: string]: any }) {
39807
- super(map);
39808
- }
39809
- }
39810
-
39811
- export class ListWafRulesetsResponseBodyRulesets extends $tea.Model {
39812
- /**
39813
- * @remarks
39814
- * The matched objects.
39815
- */
39816
- fields?: string[];
39817
- /**
39818
- * @remarks
39819
- * The ID of the WAF ruleset.[](~~2850233~~)
39820
- *
39821
- * @example
39822
- * 10000001
39823
- */
39824
- id?: number;
39825
- /**
39826
- * @remarks
39827
- * The ruleset name.
39828
- *
39829
- * @example
39830
- * example
39831
- */
39832
- name?: string;
39833
- /**
39834
- * @remarks
39835
- * The WAF rule category.
39836
- *
39837
- * @example
39838
- * http_bot
39839
- */
39840
- phase?: string;
39841
- /**
39842
- * @remarks
39843
- * The ruleset status.
39844
- *
39845
- * @example
39846
- * on
39847
- */
39848
- status?: string;
39849
- /**
39850
- * @remarks
39851
- * The type of the protection target in the http_bot rule category.
39852
- *
39853
- * @example
39854
- * web
39855
- */
39856
- target?: string;
39857
- /**
39858
- * @remarks
39859
- * The types of rules.
39860
- */
39861
- types?: string[];
39862
- /**
39863
- * @remarks
39864
- * The time when the ruleset was last modified.
39865
- *
39866
- * @example
39867
- * 2024-01-01T00:00:00Z
39868
- */
39869
- updateTime?: string;
39870
- static names(): { [key: string]: string } {
39871
- return {
39872
- fields: 'Fields',
39873
- id: 'Id',
39874
- name: 'Name',
39875
- phase: 'Phase',
39876
- status: 'Status',
39877
- target: 'Target',
39878
- types: 'Types',
39879
- updateTime: 'UpdateTime',
39880
- };
39881
- }
39882
-
39883
- static types(): { [key: string]: any } {
39884
- return {
39885
- fields: { 'type': 'array', 'itemType': 'string' },
39886
- id: 'number',
39887
- name: 'string',
39888
- phase: 'string',
39889
- status: 'string',
39890
- target: 'string',
39891
- types: { 'type': 'array', 'itemType': 'string' },
39892
- updateTime: 'string',
39893
- };
39894
- }
39895
-
39896
- constructor(map?: { [key: string]: any }) {
39897
- super(map);
39898
- }
39899
- }
39900
-
39901
37635
  export class ListWafTemplateRulesRequestQueryArgs extends $tea.Model {
39902
37636
  /**
39903
37637
  * @remarks
@@ -41052,76 +38786,6 @@ export default class Client extends OpenApi {
41052
38786
  return await this.batchCreateRecordsWithOptions(request, runtime);
41053
38787
  }
41054
38788
 
41055
- /**
41056
- * Creates multiple rules of a specific Web Application Firewall (WAF) rule category at a time. You can also configure shared settings for the rules.
41057
- *
41058
- * @param tmpReq - BatchCreateWafRulesRequest
41059
- * @param runtime - runtime options for this request RuntimeOptions
41060
- * @returns BatchCreateWafRulesResponse
41061
- */
41062
- async batchCreateWafRulesWithOptions(tmpReq: BatchCreateWafRulesRequest, runtime: $Util.RuntimeOptions): Promise<BatchCreateWafRulesResponse> {
41063
- Util.validateModel(tmpReq);
41064
- let request = new BatchCreateWafRulesShrinkRequest({ });
41065
- OpenApiUtil.convert(tmpReq, request);
41066
- if (!Util.isUnset(tmpReq.configs)) {
41067
- request.configsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.configs, "Configs", "json");
41068
- }
41069
-
41070
- if (!Util.isUnset(tmpReq.shared)) {
41071
- request.sharedShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.shared, "Shared", "json");
41072
- }
41073
-
41074
- let query = { };
41075
- if (!Util.isUnset(request.siteId)) {
41076
- query["SiteId"] = request.siteId;
41077
- }
41078
-
41079
- if (!Util.isUnset(request.siteVersion)) {
41080
- query["SiteVersion"] = request.siteVersion;
41081
- }
41082
-
41083
- let body : {[key: string ]: any} = { };
41084
- if (!Util.isUnset(request.configsShrink)) {
41085
- body["Configs"] = request.configsShrink;
41086
- }
41087
-
41088
- if (!Util.isUnset(request.phase)) {
41089
- body["Phase"] = request.phase;
41090
- }
41091
-
41092
- if (!Util.isUnset(request.sharedShrink)) {
41093
- body["Shared"] = request.sharedShrink;
41094
- }
41095
-
41096
- let req = new $OpenApi.OpenApiRequest({
41097
- query: OpenApiUtil.query(query),
41098
- body: OpenApiUtil.parseToMap(body),
41099
- });
41100
- let params = new $OpenApi.Params({
41101
- action: "BatchCreateWafRules",
41102
- version: "2024-09-10",
41103
- protocol: "HTTPS",
41104
- pathname: "/",
41105
- method: "POST",
41106
- authType: "AK",
41107
- style: "RPC",
41108
- reqBodyType: "formData",
41109
- bodyType: "json",
41110
- });
41111
- return $tea.cast<BatchCreateWafRulesResponse>(await this.callApi(params, req, runtime), new BatchCreateWafRulesResponse({}));
41112
- }
41113
-
41114
- /**
41115
- * Creates multiple rules of a specific Web Application Firewall (WAF) rule category at a time. You can also configure shared settings for the rules.
41116
- *
41117
- * @param request - BatchCreateWafRulesRequest
41118
- * @returns BatchCreateWafRulesResponse
41119
- */
41120
- async batchCreateWafRules(request: BatchCreateWafRulesRequest): Promise<BatchCreateWafRulesResponse> {
41121
- let runtime = new $Util.RuntimeOptions({ });
41122
- return await this.batchCreateWafRulesWithOptions(request, runtime);
41123
- }
41124
-
41125
38789
  /**
41126
38790
  * Deletes key-value pairs from a namespace at a time based on keys.
41127
38791
  *
@@ -41364,353 +39028,26 @@ export default class Client extends OpenApi {
41364
39028
  header: ossHeader,
41365
39029
  });
41366
39030
  await ossClient.postObject(uploadRequest, ossRuntime);
41367
- batchDeleteKvWithHighCapacityReq.url = `http://${authResponse.body.bucket}.${authResponse.body.endpoint}/${authResponse.body.objectKey}`;
41368
- }
41369
-
41370
- let batchDeleteKvWithHighCapacityResp = await this.batchDeleteKvWithHighCapacityWithOptions(batchDeleteKvWithHighCapacityReq, runtime);
41371
- return batchDeleteKvWithHighCapacityResp;
41372
- }
41373
-
41374
- /**
41375
- * Batch queries the objects that match specific expressions.
41376
- *
41377
- * @param tmpReq - BatchGetExpressionFieldsRequest
41378
- * @param runtime - runtime options for this request RuntimeOptions
41379
- * @returns BatchGetExpressionFieldsResponse
41380
- */
41381
- async batchGetExpressionFieldsWithOptions(tmpReq: BatchGetExpressionFieldsRequest, runtime: $Util.RuntimeOptions): Promise<BatchGetExpressionFieldsResponse> {
41382
- Util.validateModel(tmpReq);
41383
- let request = new BatchGetExpressionFieldsShrinkRequest({ });
41384
- OpenApiUtil.convert(tmpReq, request);
41385
- if (!Util.isUnset(tmpReq.expressions)) {
41386
- request.expressionsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.expressions, "Expressions", "json");
41387
- }
41388
-
41389
- let query = { };
41390
- if (!Util.isUnset(request.siteId)) {
41391
- query["SiteId"] = request.siteId;
41392
- }
41393
-
41394
- let body : {[key: string ]: any} = { };
41395
- if (!Util.isUnset(request.expressionsShrink)) {
41396
- body["Expressions"] = request.expressionsShrink;
41397
- }
41398
-
41399
- if (!Util.isUnset(request.phase)) {
41400
- body["Phase"] = request.phase;
41401
- }
41402
-
41403
- let req = new $OpenApi.OpenApiRequest({
41404
- query: OpenApiUtil.query(query),
41405
- body: OpenApiUtil.parseToMap(body),
41406
- });
41407
- let params = new $OpenApi.Params({
41408
- action: "BatchGetExpressionFields",
41409
- version: "2024-09-10",
41410
- protocol: "HTTPS",
41411
- pathname: "/",
41412
- method: "POST",
41413
- authType: "AK",
41414
- style: "RPC",
41415
- reqBodyType: "formData",
41416
- bodyType: "json",
41417
- });
41418
- return $tea.cast<BatchGetExpressionFieldsResponse>(await this.callApi(params, req, runtime), new BatchGetExpressionFieldsResponse({}));
41419
- }
41420
-
41421
- /**
41422
- * Batch queries the objects that match specific expressions.
41423
- *
41424
- * @param request - BatchGetExpressionFieldsRequest
41425
- * @returns BatchGetExpressionFieldsResponse
41426
- */
41427
- async batchGetExpressionFields(request: BatchGetExpressionFieldsRequest): Promise<BatchGetExpressionFieldsResponse> {
41428
- let runtime = new $Util.RuntimeOptions({ });
41429
- return await this.batchGetExpressionFieldsWithOptions(request, runtime);
41430
- }
41431
-
41432
- /**
41433
- * Configures key-value pairs for a namespace at a time based on specified keys.
41434
- *
41435
- * @param tmpReq - BatchPutKvRequest
41436
- * @param runtime - runtime options for this request RuntimeOptions
41437
- * @returns BatchPutKvResponse
41438
- */
41439
- async batchPutKvWithOptions(tmpReq: BatchPutKvRequest, runtime: $Util.RuntimeOptions): Promise<BatchPutKvResponse> {
41440
- Util.validateModel(tmpReq);
41441
- let request = new BatchPutKvShrinkRequest({ });
41442
- OpenApiUtil.convert(tmpReq, request);
41443
- if (!Util.isUnset(tmpReq.kvList)) {
41444
- request.kvListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.kvList, "KvList", "json");
41445
- }
41446
-
41447
- let query = { };
41448
- if (!Util.isUnset(request.namespace)) {
41449
- query["Namespace"] = request.namespace;
41450
- }
41451
-
41452
- let body : {[key: string ]: any} = { };
41453
- if (!Util.isUnset(request.kvListShrink)) {
41454
- body["KvList"] = request.kvListShrink;
41455
- }
41456
-
41457
- let req = new $OpenApi.OpenApiRequest({
41458
- query: OpenApiUtil.query(query),
41459
- body: OpenApiUtil.parseToMap(body),
41460
- });
41461
- let params = new $OpenApi.Params({
41462
- action: "BatchPutKv",
41463
- version: "2024-09-10",
41464
- protocol: "HTTPS",
41465
- pathname: "/",
41466
- method: "POST",
41467
- authType: "AK",
41468
- style: "RPC",
41469
- reqBodyType: "formData",
41470
- bodyType: "json",
41471
- });
41472
- return $tea.cast<BatchPutKvResponse>(await this.callApi(params, req, runtime), new BatchPutKvResponse({}));
41473
- }
41474
-
41475
- /**
41476
- * Configures key-value pairs for a namespace at a time based on specified keys.
41477
- *
41478
- * @param request - BatchPutKvRequest
41479
- * @returns BatchPutKvResponse
41480
- */
41481
- async batchPutKv(request: BatchPutKvRequest): Promise<BatchPutKvResponse> {
41482
- let runtime = new $Util.RuntimeOptions({ });
41483
- return await this.batchPutKvWithOptions(request, runtime);
41484
- }
41485
-
41486
- /**
41487
- * Configures key-value pairs for a namespace at a time based on specified keys. The request body can be up to 100 MB.
41488
- *
41489
- * @remarks
41490
- * This operation allows you to upload a larger request body than by using [BatchPutKv](https://help.aliyun.com/document_detail/2850203.html). For small request bodies, we recommend that you use [BatchPutKv](https://help.aliyun.com/document_detail/2850203.html) to minimize the server processing time. This operation must be called by using SDKs. The following sample code uses the Golang SDK and BatchPutKvWithHighCapacityAdvance to call the operation.
41491
- * func TestBatchPutKvWithHighCapacity() error {
41492
- * // Initialize the configurations.
41493
- * cfg := new(openapi.Config)
41494
- * cfg.SetAccessKeyId("xxxxxxxxx")
41495
- * cfg.SetAccessKeySecret("xxxxxxxxxx")
41496
- * cli, err := NewClient(cfg)
41497
- * if err != nil {
41498
- * return err
41499
- * }
41500
- * runtime := &util.RuntimeOptions{}
41501
- * // Construct a request for uploading key-value pairs at a time.
41502
- * namespace := "test_batch_put"
41503
- * numKv := 10000
41504
- * kvList := make([]*BatchPutKvRequestKvList, numKv)
41505
- * test_value := strings.Repeat("a", 10*1024)
41506
- * for i := 0; i < numKv; i++ {
41507
- * key := fmt.Sprintf("test_key_%d", i)
41508
- * value := test_value
41509
- * kvList[i] = &BatchPutKvRequestKvList{
41510
- * Key: &key,
41511
- * Value: &value,
41512
- * }
41513
- * }
41514
- * rawReq := BatchPutKvRequest{
41515
- * Namespace: &namespace,
41516
- * KvList: kvList,
41517
- * }
41518
- * payload, err := json.Marshal(rawReq)
41519
- * if err != nil {
41520
- * return err
41521
- * }
41522
- * // If the payload is greater than 2 MB, call the BatchPutKvWithHighCapacity operation for upload.
41523
- * reqHighCapacity := BatchPutKvWithHighCapacityAdvanceRequest{
41524
- * Namespace: &namespace,
41525
- * UrlObject: bytes.NewReader(payload),
41526
- * }
41527
- * resp, err := cli.BatchPutKvWithHighCapacityAdvance(&reqHighCapacity, runtime)
41528
- * if err != nil {
41529
- * return err
41530
- * }
41531
- * return nil
41532
- * }
41533
- *
41534
- * @param request - BatchPutKvWithHighCapacityRequest
41535
- * @param runtime - runtime options for this request RuntimeOptions
41536
- * @returns BatchPutKvWithHighCapacityResponse
41537
- */
41538
- async batchPutKvWithHighCapacityWithOptions(request: BatchPutKvWithHighCapacityRequest, runtime: $Util.RuntimeOptions): Promise<BatchPutKvWithHighCapacityResponse> {
41539
- Util.validateModel(request);
41540
- let query = { };
41541
- if (!Util.isUnset(request.namespace)) {
41542
- query["Namespace"] = request.namespace;
41543
- }
41544
-
41545
- if (!Util.isUnset(request.url)) {
41546
- query["Url"] = request.url;
41547
- }
41548
-
41549
- let req = new $OpenApi.OpenApiRequest({
41550
- query: OpenApiUtil.query(query),
41551
- });
41552
- let params = new $OpenApi.Params({
41553
- action: "BatchPutKvWithHighCapacity",
41554
- version: "2024-09-10",
41555
- protocol: "HTTPS",
41556
- pathname: "/",
41557
- method: "POST",
41558
- authType: "AK",
41559
- style: "RPC",
41560
- reqBodyType: "formData",
41561
- bodyType: "json",
41562
- });
41563
- return $tea.cast<BatchPutKvWithHighCapacityResponse>(await this.callApi(params, req, runtime), new BatchPutKvWithHighCapacityResponse({}));
41564
- }
41565
-
41566
- /**
41567
- * Configures key-value pairs for a namespace at a time based on specified keys. The request body can be up to 100 MB.
41568
- *
41569
- * @remarks
41570
- * This operation allows you to upload a larger request body than by using [BatchPutKv](https://help.aliyun.com/document_detail/2850203.html). For small request bodies, we recommend that you use [BatchPutKv](https://help.aliyun.com/document_detail/2850203.html) to minimize the server processing time. This operation must be called by using SDKs. The following sample code uses the Golang SDK and BatchPutKvWithHighCapacityAdvance to call the operation.
41571
- * func TestBatchPutKvWithHighCapacity() error {
41572
- * // Initialize the configurations.
41573
- * cfg := new(openapi.Config)
41574
- * cfg.SetAccessKeyId("xxxxxxxxx")
41575
- * cfg.SetAccessKeySecret("xxxxxxxxxx")
41576
- * cli, err := NewClient(cfg)
41577
- * if err != nil {
41578
- * return err
41579
- * }
41580
- * runtime := &util.RuntimeOptions{}
41581
- * // Construct a request for uploading key-value pairs at a time.
41582
- * namespace := "test_batch_put"
41583
- * numKv := 10000
41584
- * kvList := make([]*BatchPutKvRequestKvList, numKv)
41585
- * test_value := strings.Repeat("a", 10*1024)
41586
- * for i := 0; i < numKv; i++ {
41587
- * key := fmt.Sprintf("test_key_%d", i)
41588
- * value := test_value
41589
- * kvList[i] = &BatchPutKvRequestKvList{
41590
- * Key: &key,
41591
- * Value: &value,
41592
- * }
41593
- * }
41594
- * rawReq := BatchPutKvRequest{
41595
- * Namespace: &namespace,
41596
- * KvList: kvList,
41597
- * }
41598
- * payload, err := json.Marshal(rawReq)
41599
- * if err != nil {
41600
- * return err
41601
- * }
41602
- * // If the payload is greater than 2 MB, call the BatchPutKvWithHighCapacity operation for upload.
41603
- * reqHighCapacity := BatchPutKvWithHighCapacityAdvanceRequest{
41604
- * Namespace: &namespace,
41605
- * UrlObject: bytes.NewReader(payload),
41606
- * }
41607
- * resp, err := cli.BatchPutKvWithHighCapacityAdvance(&reqHighCapacity, runtime)
41608
- * if err != nil {
41609
- * return err
41610
- * }
41611
- * return nil
41612
- * }
41613
- *
41614
- * @param request - BatchPutKvWithHighCapacityRequest
41615
- * @returns BatchPutKvWithHighCapacityResponse
41616
- */
41617
- async batchPutKvWithHighCapacity(request: BatchPutKvWithHighCapacityRequest): Promise<BatchPutKvWithHighCapacityResponse> {
41618
- let runtime = new $Util.RuntimeOptions({ });
41619
- return await this.batchPutKvWithHighCapacityWithOptions(request, runtime);
41620
- }
41621
-
41622
- async batchPutKvWithHighCapacityAdvance(request: BatchPutKvWithHighCapacityAdvanceRequest, runtime: $Util.RuntimeOptions): Promise<BatchPutKvWithHighCapacityResponse> {
41623
- // Step 0: init client
41624
- let accessKeyId = await this._credential.getAccessKeyId();
41625
- let accessKeySecret = await this._credential.getAccessKeySecret();
41626
- let securityToken = await this._credential.getSecurityToken();
41627
- let credentialType = this._credential.getType();
41628
- let openPlatformEndpoint = this._openPlatformEndpoint;
41629
- if (Util.empty(openPlatformEndpoint)) {
41630
- openPlatformEndpoint = "openplatform.aliyuncs.com";
41631
- }
41632
-
41633
- if (Util.isUnset(credentialType)) {
41634
- credentialType = "access_key";
41635
- }
41636
-
41637
- let authConfig = new $OpenApi.Config({
41638
- accessKeyId: accessKeyId,
41639
- accessKeySecret: accessKeySecret,
41640
- securityToken: securityToken,
41641
- type: credentialType,
41642
- endpoint: openPlatformEndpoint,
41643
- protocol: this._protocol,
41644
- regionId: this._regionId,
41645
- });
41646
- let authClient = new OpenPlatform(authConfig);
41647
- let authRequest = new $OpenPlatform.AuthorizeFileUploadRequest({
41648
- product: "ESA",
41649
- regionId: this._regionId,
41650
- });
41651
- let authResponse = new $OpenPlatform.AuthorizeFileUploadResponse({ });
41652
- let ossConfig = new $OSS.Config({
41653
- accessKeyId: accessKeyId,
41654
- accessKeySecret: accessKeySecret,
41655
- type: "access_key",
41656
- protocol: this._protocol,
41657
- regionId: this._regionId,
41658
- });
41659
- let ossClient : OSS = new OSS(ossConfig);
41660
- let fileObj = new $FileForm.FileField({ });
41661
- let ossHeader = new $OSS.PostObjectRequestHeader({ });
41662
- let uploadRequest = new $OSS.PostObjectRequest({ });
41663
- let ossRuntime = new $OSSUtil.RuntimeOptions({ });
41664
- OpenApiUtil.convert(runtime, ossRuntime);
41665
- let batchPutKvWithHighCapacityReq = new BatchPutKvWithHighCapacityRequest({ });
41666
- OpenApiUtil.convert(request, batchPutKvWithHighCapacityReq);
41667
- if (!Util.isUnset(request.urlObject)) {
41668
- authResponse = await authClient.authorizeFileUploadWithOptions(authRequest, runtime);
41669
- ossConfig.accessKeyId = authResponse.body.accessKeyId;
41670
- ossConfig.endpoint = OpenApiUtil.getEndpoint(authResponse.body.endpoint, authResponse.body.useAccelerate, this._endpointType);
41671
- ossClient = new OSS(ossConfig);
41672
- fileObj = new $FileForm.FileField({
41673
- filename: authResponse.body.objectKey,
41674
- content: request.urlObject,
41675
- contentType: "",
41676
- });
41677
- ossHeader = new $OSS.PostObjectRequestHeader({
41678
- accessKeyId: authResponse.body.accessKeyId,
41679
- policy: authResponse.body.encodedPolicy,
41680
- signature: authResponse.body.signature,
41681
- key: authResponse.body.objectKey,
41682
- file: fileObj,
41683
- successActionStatus: "201",
41684
- });
41685
- uploadRequest = new $OSS.PostObjectRequest({
41686
- bucketName: authResponse.body.bucket,
41687
- header: ossHeader,
41688
- });
41689
- await ossClient.postObject(uploadRequest, ossRuntime);
41690
- batchPutKvWithHighCapacityReq.url = `http://${authResponse.body.bucket}.${authResponse.body.endpoint}/${authResponse.body.objectKey}`;
39031
+ batchDeleteKvWithHighCapacityReq.url = `http://${authResponse.body.bucket}.${authResponse.body.endpoint}/${authResponse.body.objectKey}`;
41691
39032
  }
41692
39033
 
41693
- let batchPutKvWithHighCapacityResp = await this.batchPutKvWithHighCapacityWithOptions(batchPutKvWithHighCapacityReq, runtime);
41694
- return batchPutKvWithHighCapacityResp;
39034
+ let batchDeleteKvWithHighCapacityResp = await this.batchDeleteKvWithHighCapacityWithOptions(batchDeleteKvWithHighCapacityReq, runtime);
39035
+ return batchDeleteKvWithHighCapacityResp;
41695
39036
  }
41696
39037
 
41697
39038
  /**
41698
- * Modifies multiple rules in a specific Web Application Firewall (WAF) ruleset at a time.
39039
+ * Batch queries the objects that match specific expressions.
41699
39040
  *
41700
- * @param tmpReq - BatchUpdateWafRulesRequest
39041
+ * @param tmpReq - BatchGetExpressionFieldsRequest
41701
39042
  * @param runtime - runtime options for this request RuntimeOptions
41702
- * @returns BatchUpdateWafRulesResponse
39043
+ * @returns BatchGetExpressionFieldsResponse
41703
39044
  */
41704
- async batchUpdateWafRulesWithOptions(tmpReq: BatchUpdateWafRulesRequest, runtime: $Util.RuntimeOptions): Promise<BatchUpdateWafRulesResponse> {
39045
+ async batchGetExpressionFieldsWithOptions(tmpReq: BatchGetExpressionFieldsRequest, runtime: $Util.RuntimeOptions): Promise<BatchGetExpressionFieldsResponse> {
41705
39046
  Util.validateModel(tmpReq);
41706
- let request = new BatchUpdateWafRulesShrinkRequest({ });
39047
+ let request = new BatchGetExpressionFieldsShrinkRequest({ });
41707
39048
  OpenApiUtil.convert(tmpReq, request);
41708
- if (!Util.isUnset(tmpReq.configs)) {
41709
- request.configsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.configs, "Configs", "json");
41710
- }
41711
-
41712
- if (!Util.isUnset(tmpReq.shared)) {
41713
- request.sharedShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.shared, "Shared", "json");
39049
+ if (!Util.isUnset(tmpReq.expressions)) {
39050
+ request.expressionsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.expressions, "Expressions", "json");
41714
39051
  }
41715
39052
 
41716
39053
  let query = { };
@@ -41718,25 +39055,67 @@ export default class Client extends OpenApi {
41718
39055
  query["SiteId"] = request.siteId;
41719
39056
  }
41720
39057
 
41721
- if (!Util.isUnset(request.siteVersion)) {
41722
- query["SiteVersion"] = request.siteVersion;
41723
- }
41724
-
41725
39058
  let body : {[key: string ]: any} = { };
41726
- if (!Util.isUnset(request.configsShrink)) {
41727
- body["Configs"] = request.configsShrink;
39059
+ if (!Util.isUnset(request.expressionsShrink)) {
39060
+ body["Expressions"] = request.expressionsShrink;
41728
39061
  }
41729
39062
 
41730
39063
  if (!Util.isUnset(request.phase)) {
41731
39064
  body["Phase"] = request.phase;
41732
39065
  }
41733
39066
 
41734
- if (!Util.isUnset(request.rulesetId)) {
41735
- body["RulesetId"] = request.rulesetId;
39067
+ let req = new $OpenApi.OpenApiRequest({
39068
+ query: OpenApiUtil.query(query),
39069
+ body: OpenApiUtil.parseToMap(body),
39070
+ });
39071
+ let params = new $OpenApi.Params({
39072
+ action: "BatchGetExpressionFields",
39073
+ version: "2024-09-10",
39074
+ protocol: "HTTPS",
39075
+ pathname: "/",
39076
+ method: "POST",
39077
+ authType: "AK",
39078
+ style: "RPC",
39079
+ reqBodyType: "formData",
39080
+ bodyType: "json",
39081
+ });
39082
+ return $tea.cast<BatchGetExpressionFieldsResponse>(await this.callApi(params, req, runtime), new BatchGetExpressionFieldsResponse({}));
39083
+ }
39084
+
39085
+ /**
39086
+ * Batch queries the objects that match specific expressions.
39087
+ *
39088
+ * @param request - BatchGetExpressionFieldsRequest
39089
+ * @returns BatchGetExpressionFieldsResponse
39090
+ */
39091
+ async batchGetExpressionFields(request: BatchGetExpressionFieldsRequest): Promise<BatchGetExpressionFieldsResponse> {
39092
+ let runtime = new $Util.RuntimeOptions({ });
39093
+ return await this.batchGetExpressionFieldsWithOptions(request, runtime);
39094
+ }
39095
+
39096
+ /**
39097
+ * Configures key-value pairs for a namespace at a time based on specified keys.
39098
+ *
39099
+ * @param tmpReq - BatchPutKvRequest
39100
+ * @param runtime - runtime options for this request RuntimeOptions
39101
+ * @returns BatchPutKvResponse
39102
+ */
39103
+ async batchPutKvWithOptions(tmpReq: BatchPutKvRequest, runtime: $Util.RuntimeOptions): Promise<BatchPutKvResponse> {
39104
+ Util.validateModel(tmpReq);
39105
+ let request = new BatchPutKvShrinkRequest({ });
39106
+ OpenApiUtil.convert(tmpReq, request);
39107
+ if (!Util.isUnset(tmpReq.kvList)) {
39108
+ request.kvListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.kvList, "KvList", "json");
39109
+ }
39110
+
39111
+ let query = { };
39112
+ if (!Util.isUnset(request.namespace)) {
39113
+ query["Namespace"] = request.namespace;
41736
39114
  }
41737
39115
 
41738
- if (!Util.isUnset(request.sharedShrink)) {
41739
- body["Shared"] = request.sharedShrink;
39116
+ let body : {[key: string ]: any} = { };
39117
+ if (!Util.isUnset(request.kvListShrink)) {
39118
+ body["KvList"] = request.kvListShrink;
41740
39119
  }
41741
39120
 
41742
39121
  let req = new $OpenApi.OpenApiRequest({
@@ -41744,7 +39123,7 @@ export default class Client extends OpenApi {
41744
39123
  body: OpenApiUtil.parseToMap(body),
41745
39124
  });
41746
39125
  let params = new $OpenApi.Params({
41747
- action: "BatchUpdateWafRules",
39126
+ action: "BatchPutKv",
41748
39127
  version: "2024-09-10",
41749
39128
  protocol: "HTTPS",
41750
39129
  pathname: "/",
@@ -41754,18 +39133,229 @@ export default class Client extends OpenApi {
41754
39133
  reqBodyType: "formData",
41755
39134
  bodyType: "json",
41756
39135
  });
41757
- return $tea.cast<BatchUpdateWafRulesResponse>(await this.callApi(params, req, runtime), new BatchUpdateWafRulesResponse({}));
39136
+ return $tea.cast<BatchPutKvResponse>(await this.callApi(params, req, runtime), new BatchPutKvResponse({}));
41758
39137
  }
41759
39138
 
41760
39139
  /**
41761
- * Modifies multiple rules in a specific Web Application Firewall (WAF) ruleset at a time.
39140
+ * Configures key-value pairs for a namespace at a time based on specified keys.
41762
39141
  *
41763
- * @param request - BatchUpdateWafRulesRequest
41764
- * @returns BatchUpdateWafRulesResponse
39142
+ * @param request - BatchPutKvRequest
39143
+ * @returns BatchPutKvResponse
41765
39144
  */
41766
- async batchUpdateWafRules(request: BatchUpdateWafRulesRequest): Promise<BatchUpdateWafRulesResponse> {
39145
+ async batchPutKv(request: BatchPutKvRequest): Promise<BatchPutKvResponse> {
41767
39146
  let runtime = new $Util.RuntimeOptions({ });
41768
- return await this.batchUpdateWafRulesWithOptions(request, runtime);
39147
+ return await this.batchPutKvWithOptions(request, runtime);
39148
+ }
39149
+
39150
+ /**
39151
+ * Configures key-value pairs for a namespace at a time based on specified keys. The request body can be up to 100 MB.
39152
+ *
39153
+ * @remarks
39154
+ * This operation allows you to upload a larger request body than by using [BatchPutKv](https://help.aliyun.com/document_detail/2850203.html). For small request bodies, we recommend that you use [BatchPutKv](https://help.aliyun.com/document_detail/2850203.html) to minimize the server processing time. This operation must be called by using SDKs. The following sample code uses the Golang SDK and BatchPutKvWithHighCapacityAdvance to call the operation.
39155
+ * func TestBatchPutKvWithHighCapacity() error {
39156
+ * // Initialize the configurations.
39157
+ * cfg := new(openapi.Config)
39158
+ * cfg.SetAccessKeyId("xxxxxxxxx")
39159
+ * cfg.SetAccessKeySecret("xxxxxxxxxx")
39160
+ * cli, err := NewClient(cfg)
39161
+ * if err != nil {
39162
+ * return err
39163
+ * }
39164
+ * runtime := &util.RuntimeOptions{}
39165
+ * // Construct a request for uploading key-value pairs at a time.
39166
+ * namespace := "test_batch_put"
39167
+ * numKv := 10000
39168
+ * kvList := make([]*BatchPutKvRequestKvList, numKv)
39169
+ * test_value := strings.Repeat("a", 10*1024)
39170
+ * for i := 0; i < numKv; i++ {
39171
+ * key := fmt.Sprintf("test_key_%d", i)
39172
+ * value := test_value
39173
+ * kvList[i] = &BatchPutKvRequestKvList{
39174
+ * Key: &key,
39175
+ * Value: &value,
39176
+ * }
39177
+ * }
39178
+ * rawReq := BatchPutKvRequest{
39179
+ * Namespace: &namespace,
39180
+ * KvList: kvList,
39181
+ * }
39182
+ * payload, err := json.Marshal(rawReq)
39183
+ * if err != nil {
39184
+ * return err
39185
+ * }
39186
+ * // If the payload is greater than 2 MB, call the BatchPutKvWithHighCapacity operation for upload.
39187
+ * reqHighCapacity := BatchPutKvWithHighCapacityAdvanceRequest{
39188
+ * Namespace: &namespace,
39189
+ * UrlObject: bytes.NewReader(payload),
39190
+ * }
39191
+ * resp, err := cli.BatchPutKvWithHighCapacityAdvance(&reqHighCapacity, runtime)
39192
+ * if err != nil {
39193
+ * return err
39194
+ * }
39195
+ * return nil
39196
+ * }
39197
+ *
39198
+ * @param request - BatchPutKvWithHighCapacityRequest
39199
+ * @param runtime - runtime options for this request RuntimeOptions
39200
+ * @returns BatchPutKvWithHighCapacityResponse
39201
+ */
39202
+ async batchPutKvWithHighCapacityWithOptions(request: BatchPutKvWithHighCapacityRequest, runtime: $Util.RuntimeOptions): Promise<BatchPutKvWithHighCapacityResponse> {
39203
+ Util.validateModel(request);
39204
+ let query = { };
39205
+ if (!Util.isUnset(request.namespace)) {
39206
+ query["Namespace"] = request.namespace;
39207
+ }
39208
+
39209
+ if (!Util.isUnset(request.url)) {
39210
+ query["Url"] = request.url;
39211
+ }
39212
+
39213
+ let req = new $OpenApi.OpenApiRequest({
39214
+ query: OpenApiUtil.query(query),
39215
+ });
39216
+ let params = new $OpenApi.Params({
39217
+ action: "BatchPutKvWithHighCapacity",
39218
+ version: "2024-09-10",
39219
+ protocol: "HTTPS",
39220
+ pathname: "/",
39221
+ method: "POST",
39222
+ authType: "AK",
39223
+ style: "RPC",
39224
+ reqBodyType: "formData",
39225
+ bodyType: "json",
39226
+ });
39227
+ return $tea.cast<BatchPutKvWithHighCapacityResponse>(await this.callApi(params, req, runtime), new BatchPutKvWithHighCapacityResponse({}));
39228
+ }
39229
+
39230
+ /**
39231
+ * Configures key-value pairs for a namespace at a time based on specified keys. The request body can be up to 100 MB.
39232
+ *
39233
+ * @remarks
39234
+ * This operation allows you to upload a larger request body than by using [BatchPutKv](https://help.aliyun.com/document_detail/2850203.html). For small request bodies, we recommend that you use [BatchPutKv](https://help.aliyun.com/document_detail/2850203.html) to minimize the server processing time. This operation must be called by using SDKs. The following sample code uses the Golang SDK and BatchPutKvWithHighCapacityAdvance to call the operation.
39235
+ * func TestBatchPutKvWithHighCapacity() error {
39236
+ * // Initialize the configurations.
39237
+ * cfg := new(openapi.Config)
39238
+ * cfg.SetAccessKeyId("xxxxxxxxx")
39239
+ * cfg.SetAccessKeySecret("xxxxxxxxxx")
39240
+ * cli, err := NewClient(cfg)
39241
+ * if err != nil {
39242
+ * return err
39243
+ * }
39244
+ * runtime := &util.RuntimeOptions{}
39245
+ * // Construct a request for uploading key-value pairs at a time.
39246
+ * namespace := "test_batch_put"
39247
+ * numKv := 10000
39248
+ * kvList := make([]*BatchPutKvRequestKvList, numKv)
39249
+ * test_value := strings.Repeat("a", 10*1024)
39250
+ * for i := 0; i < numKv; i++ {
39251
+ * key := fmt.Sprintf("test_key_%d", i)
39252
+ * value := test_value
39253
+ * kvList[i] = &BatchPutKvRequestKvList{
39254
+ * Key: &key,
39255
+ * Value: &value,
39256
+ * }
39257
+ * }
39258
+ * rawReq := BatchPutKvRequest{
39259
+ * Namespace: &namespace,
39260
+ * KvList: kvList,
39261
+ * }
39262
+ * payload, err := json.Marshal(rawReq)
39263
+ * if err != nil {
39264
+ * return err
39265
+ * }
39266
+ * // If the payload is greater than 2 MB, call the BatchPutKvWithHighCapacity operation for upload.
39267
+ * reqHighCapacity := BatchPutKvWithHighCapacityAdvanceRequest{
39268
+ * Namespace: &namespace,
39269
+ * UrlObject: bytes.NewReader(payload),
39270
+ * }
39271
+ * resp, err := cli.BatchPutKvWithHighCapacityAdvance(&reqHighCapacity, runtime)
39272
+ * if err != nil {
39273
+ * return err
39274
+ * }
39275
+ * return nil
39276
+ * }
39277
+ *
39278
+ * @param request - BatchPutKvWithHighCapacityRequest
39279
+ * @returns BatchPutKvWithHighCapacityResponse
39280
+ */
39281
+ async batchPutKvWithHighCapacity(request: BatchPutKvWithHighCapacityRequest): Promise<BatchPutKvWithHighCapacityResponse> {
39282
+ let runtime = new $Util.RuntimeOptions({ });
39283
+ return await this.batchPutKvWithHighCapacityWithOptions(request, runtime);
39284
+ }
39285
+
39286
+ async batchPutKvWithHighCapacityAdvance(request: BatchPutKvWithHighCapacityAdvanceRequest, runtime: $Util.RuntimeOptions): Promise<BatchPutKvWithHighCapacityResponse> {
39287
+ // Step 0: init client
39288
+ let accessKeyId = await this._credential.getAccessKeyId();
39289
+ let accessKeySecret = await this._credential.getAccessKeySecret();
39290
+ let securityToken = await this._credential.getSecurityToken();
39291
+ let credentialType = this._credential.getType();
39292
+ let openPlatformEndpoint = this._openPlatformEndpoint;
39293
+ if (Util.empty(openPlatformEndpoint)) {
39294
+ openPlatformEndpoint = "openplatform.aliyuncs.com";
39295
+ }
39296
+
39297
+ if (Util.isUnset(credentialType)) {
39298
+ credentialType = "access_key";
39299
+ }
39300
+
39301
+ let authConfig = new $OpenApi.Config({
39302
+ accessKeyId: accessKeyId,
39303
+ accessKeySecret: accessKeySecret,
39304
+ securityToken: securityToken,
39305
+ type: credentialType,
39306
+ endpoint: openPlatformEndpoint,
39307
+ protocol: this._protocol,
39308
+ regionId: this._regionId,
39309
+ });
39310
+ let authClient = new OpenPlatform(authConfig);
39311
+ let authRequest = new $OpenPlatform.AuthorizeFileUploadRequest({
39312
+ product: "ESA",
39313
+ regionId: this._regionId,
39314
+ });
39315
+ let authResponse = new $OpenPlatform.AuthorizeFileUploadResponse({ });
39316
+ let ossConfig = new $OSS.Config({
39317
+ accessKeyId: accessKeyId,
39318
+ accessKeySecret: accessKeySecret,
39319
+ type: "access_key",
39320
+ protocol: this._protocol,
39321
+ regionId: this._regionId,
39322
+ });
39323
+ let ossClient : OSS = new OSS(ossConfig);
39324
+ let fileObj = new $FileForm.FileField({ });
39325
+ let ossHeader = new $OSS.PostObjectRequestHeader({ });
39326
+ let uploadRequest = new $OSS.PostObjectRequest({ });
39327
+ let ossRuntime = new $OSSUtil.RuntimeOptions({ });
39328
+ OpenApiUtil.convert(runtime, ossRuntime);
39329
+ let batchPutKvWithHighCapacityReq = new BatchPutKvWithHighCapacityRequest({ });
39330
+ OpenApiUtil.convert(request, batchPutKvWithHighCapacityReq);
39331
+ if (!Util.isUnset(request.urlObject)) {
39332
+ authResponse = await authClient.authorizeFileUploadWithOptions(authRequest, runtime);
39333
+ ossConfig.accessKeyId = authResponse.body.accessKeyId;
39334
+ ossConfig.endpoint = OpenApiUtil.getEndpoint(authResponse.body.endpoint, authResponse.body.useAccelerate, this._endpointType);
39335
+ ossClient = new OSS(ossConfig);
39336
+ fileObj = new $FileForm.FileField({
39337
+ filename: authResponse.body.objectKey,
39338
+ content: request.urlObject,
39339
+ contentType: "",
39340
+ });
39341
+ ossHeader = new $OSS.PostObjectRequestHeader({
39342
+ accessKeyId: authResponse.body.accessKeyId,
39343
+ policy: authResponse.body.encodedPolicy,
39344
+ signature: authResponse.body.signature,
39345
+ key: authResponse.body.objectKey,
39346
+ file: fileObj,
39347
+ successActionStatus: "201",
39348
+ });
39349
+ uploadRequest = new $OSS.PostObjectRequest({
39350
+ bucketName: authResponse.body.bucket,
39351
+ header: ossHeader,
39352
+ });
39353
+ await ossClient.postObject(uploadRequest, ossRuntime);
39354
+ batchPutKvWithHighCapacityReq.url = `http://${authResponse.body.bucket}.${authResponse.body.endpoint}/${authResponse.body.objectKey}`;
39355
+ }
39356
+
39357
+ let batchPutKvWithHighCapacityResp = await this.batchPutKvWithHighCapacityWithOptions(batchPutKvWithHighCapacityReq, runtime);
39358
+ return batchPutKvWithHighCapacityResp;
41769
39359
  }
41770
39360
 
41771
39361
  /**
@@ -43306,68 +40896,6 @@ export default class Client extends OpenApi {
43306
40896
  return await this.createUserDeliveryTaskWithOptions(request, runtime);
43307
40897
  }
43308
40898
 
43309
- /**
43310
- * Creates a Web Application Firewall (WAF) rule. This allows you to configure fine-grained WAF settings to improve the security of your website or application.
43311
- *
43312
- * @param tmpReq - CreateWafRuleRequest
43313
- * @param runtime - runtime options for this request RuntimeOptions
43314
- * @returns CreateWafRuleResponse
43315
- */
43316
- async createWafRuleWithOptions(tmpReq: CreateWafRuleRequest, runtime: $Util.RuntimeOptions): Promise<CreateWafRuleResponse> {
43317
- Util.validateModel(tmpReq);
43318
- let request = new CreateWafRuleShrinkRequest({ });
43319
- OpenApiUtil.convert(tmpReq, request);
43320
- if (!Util.isUnset(tmpReq.config)) {
43321
- request.configShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.config, "Config", "json");
43322
- }
43323
-
43324
- let query = { };
43325
- if (!Util.isUnset(request.siteId)) {
43326
- query["SiteId"] = request.siteId;
43327
- }
43328
-
43329
- if (!Util.isUnset(request.siteVersion)) {
43330
- query["SiteVersion"] = request.siteVersion;
43331
- }
43332
-
43333
- let body : {[key: string ]: any} = { };
43334
- if (!Util.isUnset(request.configShrink)) {
43335
- body["Config"] = request.configShrink;
43336
- }
43337
-
43338
- if (!Util.isUnset(request.phase)) {
43339
- body["Phase"] = request.phase;
43340
- }
43341
-
43342
- let req = new $OpenApi.OpenApiRequest({
43343
- query: OpenApiUtil.query(query),
43344
- body: OpenApiUtil.parseToMap(body),
43345
- });
43346
- let params = new $OpenApi.Params({
43347
- action: "CreateWafRule",
43348
- version: "2024-09-10",
43349
- protocol: "HTTPS",
43350
- pathname: "/",
43351
- method: "POST",
43352
- authType: "AK",
43353
- style: "RPC",
43354
- reqBodyType: "formData",
43355
- bodyType: "json",
43356
- });
43357
- return $tea.cast<CreateWafRuleResponse>(await this.callApi(params, req, runtime), new CreateWafRuleResponse({}));
43358
- }
43359
-
43360
- /**
43361
- * Creates a Web Application Firewall (WAF) rule. This allows you to configure fine-grained WAF settings to improve the security of your website or application.
43362
- *
43363
- * @param request - CreateWafRuleRequest
43364
- * @returns CreateWafRuleResponse
43365
- */
43366
- async createWafRule(request: CreateWafRuleRequest): Promise<CreateWafRuleResponse> {
43367
- let runtime = new $Util.RuntimeOptions({ });
43368
- return await this.createWafRuleWithOptions(request, runtime);
43369
- }
43370
-
43371
40899
  /**
43372
40900
  * Creates a waiting room for a website.
43373
40901
  *
@@ -44630,110 +42158,6 @@ export default class Client extends OpenApi {
44630
42158
  return await this.deleteUserDeliveryTaskWithOptions(request, runtime);
44631
42159
  }
44632
42160
 
44633
- /**
44634
- * Deletes a Web Application Firewall (WAF) rule, including its configurations and match conditions.
44635
- *
44636
- * @param request - DeleteWafRuleRequest
44637
- * @param runtime - runtime options for this request RuntimeOptions
44638
- * @returns DeleteWafRuleResponse
44639
- */
44640
- async deleteWafRuleWithOptions(request: DeleteWafRuleRequest, runtime: $Util.RuntimeOptions): Promise<DeleteWafRuleResponse> {
44641
- Util.validateModel(request);
44642
- let query = { };
44643
- if (!Util.isUnset(request.siteId)) {
44644
- query["SiteId"] = request.siteId;
44645
- }
44646
-
44647
- if (!Util.isUnset(request.siteVersion)) {
44648
- query["SiteVersion"] = request.siteVersion;
44649
- }
44650
-
44651
- let body : {[key: string ]: any} = { };
44652
- if (!Util.isUnset(request.id)) {
44653
- body["Id"] = request.id;
44654
- }
44655
-
44656
- let req = new $OpenApi.OpenApiRequest({
44657
- query: OpenApiUtil.query(query),
44658
- body: OpenApiUtil.parseToMap(body),
44659
- });
44660
- let params = new $OpenApi.Params({
44661
- action: "DeleteWafRule",
44662
- version: "2024-09-10",
44663
- protocol: "HTTPS",
44664
- pathname: "/",
44665
- method: "POST",
44666
- authType: "AK",
44667
- style: "RPC",
44668
- reqBodyType: "formData",
44669
- bodyType: "json",
44670
- });
44671
- return $tea.cast<DeleteWafRuleResponse>(await this.callApi(params, req, runtime), new DeleteWafRuleResponse({}));
44672
- }
44673
-
44674
- /**
44675
- * Deletes a Web Application Firewall (WAF) rule, including its configurations and match conditions.
44676
- *
44677
- * @param request - DeleteWafRuleRequest
44678
- * @returns DeleteWafRuleResponse
44679
- */
44680
- async deleteWafRule(request: DeleteWafRuleRequest): Promise<DeleteWafRuleResponse> {
44681
- let runtime = new $Util.RuntimeOptions({ });
44682
- return await this.deleteWafRuleWithOptions(request, runtime);
44683
- }
44684
-
44685
- /**
44686
- * Deletes a Web Application Firewall (WAF) ruleset that is no longer needed.
44687
- *
44688
- * @param request - DeleteWafRulesetRequest
44689
- * @param runtime - runtime options for this request RuntimeOptions
44690
- * @returns DeleteWafRulesetResponse
44691
- */
44692
- async deleteWafRulesetWithOptions(request: DeleteWafRulesetRequest, runtime: $Util.RuntimeOptions): Promise<DeleteWafRulesetResponse> {
44693
- Util.validateModel(request);
44694
- let query = { };
44695
- if (!Util.isUnset(request.siteId)) {
44696
- query["SiteId"] = request.siteId;
44697
- }
44698
-
44699
- if (!Util.isUnset(request.siteVersion)) {
44700
- query["SiteVersion"] = request.siteVersion;
44701
- }
44702
-
44703
- let body : {[key: string ]: any} = { };
44704
- if (!Util.isUnset(request.id)) {
44705
- body["Id"] = request.id;
44706
- }
44707
-
44708
- let req = new $OpenApi.OpenApiRequest({
44709
- query: OpenApiUtil.query(query),
44710
- body: OpenApiUtil.parseToMap(body),
44711
- });
44712
- let params = new $OpenApi.Params({
44713
- action: "DeleteWafRuleset",
44714
- version: "2024-09-10",
44715
- protocol: "HTTPS",
44716
- pathname: "/",
44717
- method: "POST",
44718
- authType: "AK",
44719
- style: "RPC",
44720
- reqBodyType: "formData",
44721
- bodyType: "json",
44722
- });
44723
- return $tea.cast<DeleteWafRulesetResponse>(await this.callApi(params, req, runtime), new DeleteWafRulesetResponse({}));
44724
- }
44725
-
44726
- /**
44727
- * Deletes a Web Application Firewall (WAF) ruleset that is no longer needed.
44728
- *
44729
- * @param request - DeleteWafRulesetRequest
44730
- * @returns DeleteWafRulesetResponse
44731
- */
44732
- async deleteWafRuleset(request: DeleteWafRulesetRequest): Promise<DeleteWafRulesetResponse> {
44733
- let runtime = new $Util.RuntimeOptions({ });
44734
- return await this.deleteWafRulesetWithOptions(request, runtime);
44735
- }
44736
-
44737
42161
  /**
44738
42162
  * Deletes a waiting room.
44739
42163
  *
@@ -45503,7 +42927,7 @@ export default class Client extends OpenApi {
45503
42927
  }
45504
42928
 
45505
42929
  /**
45506
- * 获取客户端证书绑定的域名列表
42930
+ * Queries domain names associated with a client CA certificate. If no certificate is specified, domain names associated with an Edge Security Acceleration(ESA)-managed CA certificate are returned.
45507
42931
  *
45508
42932
  * @param request - GetClientCertificateHostnamesRequest
45509
42933
  * @param runtime - runtime options for this request RuntimeOptions
@@ -45530,7 +42954,7 @@ export default class Client extends OpenApi {
45530
42954
  }
45531
42955
 
45532
42956
  /**
45533
- * 获取客户端证书绑定的域名列表
42957
+ * Queries domain names associated with a client CA certificate. If no certificate is specified, domain names associated with an Edge Security Acceleration(ESA)-managed CA certificate are returned.
45534
42958
  *
45535
42959
  * @param request - GetClientCertificateHostnamesRequest
45536
42960
  * @returns GetClientCertificateHostnamesResponse
@@ -46928,102 +44352,6 @@ export default class Client extends OpenApi {
46928
44352
  return await this.getWafQuotaWithOptions(request, runtime);
46929
44353
  }
46930
44354
 
46931
- /**
46932
- * Queries the details of a Web Application Firewall (WAF) rule, such as its configuration and status.
46933
- *
46934
- * @param request - GetWafRuleRequest
46935
- * @param runtime - runtime options for this request RuntimeOptions
46936
- * @returns GetWafRuleResponse
46937
- */
46938
- async getWafRuleWithOptions(request: GetWafRuleRequest, runtime: $Util.RuntimeOptions): Promise<GetWafRuleResponse> {
46939
- Util.validateModel(request);
46940
- let query = { };
46941
- if (!Util.isUnset(request.id)) {
46942
- query["Id"] = request.id;
46943
- }
46944
-
46945
- if (!Util.isUnset(request.siteId)) {
46946
- query["SiteId"] = request.siteId;
46947
- }
46948
-
46949
- let req = new $OpenApi.OpenApiRequest({
46950
- query: OpenApiUtil.query(query),
46951
- });
46952
- let params = new $OpenApi.Params({
46953
- action: "GetWafRule",
46954
- version: "2024-09-10",
46955
- protocol: "HTTPS",
46956
- pathname: "/",
46957
- method: "POST",
46958
- authType: "AK",
46959
- style: "RPC",
46960
- reqBodyType: "formData",
46961
- bodyType: "json",
46962
- });
46963
- return $tea.cast<GetWafRuleResponse>(await this.callApi(params, req, runtime), new GetWafRuleResponse({}));
46964
- }
46965
-
46966
- /**
46967
- * Queries the details of a Web Application Firewall (WAF) rule, such as its configuration and status.
46968
- *
46969
- * @param request - GetWafRuleRequest
46970
- * @returns GetWafRuleResponse
46971
- */
46972
- async getWafRule(request: GetWafRuleRequest): Promise<GetWafRuleResponse> {
46973
- let runtime = new $Util.RuntimeOptions({ });
46974
- return await this.getWafRuleWithOptions(request, runtime);
46975
- }
46976
-
46977
- /**
46978
- * Queries the details of a Web Application Firewall (WAF) ruleset, such as the configuration and status.
46979
- *
46980
- * @param request - GetWafRulesetRequest
46981
- * @param runtime - runtime options for this request RuntimeOptions
46982
- * @returns GetWafRulesetResponse
46983
- */
46984
- async getWafRulesetWithOptions(request: GetWafRulesetRequest, runtime: $Util.RuntimeOptions): Promise<GetWafRulesetResponse> {
46985
- Util.validateModel(request);
46986
- let query = { };
46987
- if (!Util.isUnset(request.id)) {
46988
- query["Id"] = request.id;
46989
- }
46990
-
46991
- if (!Util.isUnset(request.phase)) {
46992
- query["Phase"] = request.phase;
46993
- }
46994
-
46995
- if (!Util.isUnset(request.siteId)) {
46996
- query["SiteId"] = request.siteId;
46997
- }
46998
-
46999
- let req = new $OpenApi.OpenApiRequest({
47000
- query: OpenApiUtil.query(query),
47001
- });
47002
- let params = new $OpenApi.Params({
47003
- action: "GetWafRuleset",
47004
- version: "2024-09-10",
47005
- protocol: "HTTPS",
47006
- pathname: "/",
47007
- method: "POST",
47008
- authType: "AK",
47009
- style: "RPC",
47010
- reqBodyType: "formData",
47011
- bodyType: "json",
47012
- });
47013
- return $tea.cast<GetWafRulesetResponse>(await this.callApi(params, req, runtime), new GetWafRulesetResponse({}));
47014
- }
47015
-
47016
- /**
47017
- * Queries the details of a Web Application Firewall (WAF) ruleset, such as the configuration and status.
47018
- *
47019
- * @param request - GetWafRulesetRequest
47020
- * @returns GetWafRulesetResponse
47021
- */
47022
- async getWafRuleset(request: GetWafRulesetRequest): Promise<GetWafRulesetResponse> {
47023
- let runtime = new $Util.RuntimeOptions({ });
47024
- return await this.getWafRulesetWithOptions(request, runtime);
47025
- }
47026
-
47027
44355
  /**
47028
44356
  * Queries the cache reserve instances in your Alibaba Cloud account.
47029
44357
  *
@@ -48312,142 +45640,6 @@ export default class Client extends OpenApi {
48312
45640
  return await this.listWafPhasesWithOptions(request, runtime);
48313
45641
  }
48314
45642
 
48315
- /**
48316
- * Lists all Web Application Firewall (WAF) rules or some of them based on specific conditions. You can call this operation to query the details of WAF rules by page.
48317
- *
48318
- * @param tmpReq - ListWafRulesRequest
48319
- * @param runtime - runtime options for this request RuntimeOptions
48320
- * @returns ListWafRulesResponse
48321
- */
48322
- async listWafRulesWithOptions(tmpReq: ListWafRulesRequest, runtime: $Util.RuntimeOptions): Promise<ListWafRulesResponse> {
48323
- Util.validateModel(tmpReq);
48324
- let request = new ListWafRulesShrinkRequest({ });
48325
- OpenApiUtil.convert(tmpReq, request);
48326
- if (!Util.isUnset(tmpReq.queryArgs)) {
48327
- request.queryArgsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.queryArgs, "QueryArgs", "json");
48328
- }
48329
-
48330
- let query = { };
48331
- if (!Util.isUnset(request.pageNumber)) {
48332
- query["PageNumber"] = request.pageNumber;
48333
- }
48334
-
48335
- if (!Util.isUnset(request.pageSize)) {
48336
- query["PageSize"] = request.pageSize;
48337
- }
48338
-
48339
- if (!Util.isUnset(request.phase)) {
48340
- query["Phase"] = request.phase;
48341
- }
48342
-
48343
- if (!Util.isUnset(request.queryArgsShrink)) {
48344
- query["QueryArgs"] = request.queryArgsShrink;
48345
- }
48346
-
48347
- if (!Util.isUnset(request.siteId)) {
48348
- query["SiteId"] = request.siteId;
48349
- }
48350
-
48351
- if (!Util.isUnset(request.siteVersion)) {
48352
- query["SiteVersion"] = request.siteVersion;
48353
- }
48354
-
48355
- let req = new $OpenApi.OpenApiRequest({
48356
- query: OpenApiUtil.query(query),
48357
- });
48358
- let params = new $OpenApi.Params({
48359
- action: "ListWafRules",
48360
- version: "2024-09-10",
48361
- protocol: "HTTPS",
48362
- pathname: "/",
48363
- method: "POST",
48364
- authType: "AK",
48365
- style: "RPC",
48366
- reqBodyType: "formData",
48367
- bodyType: "json",
48368
- });
48369
- return $tea.cast<ListWafRulesResponse>(await this.callApi(params, req, runtime), new ListWafRulesResponse({}));
48370
- }
48371
-
48372
- /**
48373
- * Lists all Web Application Firewall (WAF) rules or some of them based on specific conditions. You can call this operation to query the details of WAF rules by page.
48374
- *
48375
- * @param request - ListWafRulesRequest
48376
- * @returns ListWafRulesResponse
48377
- */
48378
- async listWafRules(request: ListWafRulesRequest): Promise<ListWafRulesResponse> {
48379
- let runtime = new $Util.RuntimeOptions({ });
48380
- return await this.listWafRulesWithOptions(request, runtime);
48381
- }
48382
-
48383
- /**
48384
- * Lists the rulesets in a Web Application Firewall (WAF) rule category. You can call this operation to query the basic information about and status of rulesets by page.
48385
- *
48386
- * @param tmpReq - ListWafRulesetsRequest
48387
- * @param runtime - runtime options for this request RuntimeOptions
48388
- * @returns ListWafRulesetsResponse
48389
- */
48390
- async listWafRulesetsWithOptions(tmpReq: ListWafRulesetsRequest, runtime: $Util.RuntimeOptions): Promise<ListWafRulesetsResponse> {
48391
- Util.validateModel(tmpReq);
48392
- let request = new ListWafRulesetsShrinkRequest({ });
48393
- OpenApiUtil.convert(tmpReq, request);
48394
- if (!Util.isUnset(tmpReq.queryArgs)) {
48395
- request.queryArgsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.queryArgs, "QueryArgs", "json");
48396
- }
48397
-
48398
- let query = { };
48399
- if (!Util.isUnset(request.pageNumber)) {
48400
- query["PageNumber"] = request.pageNumber;
48401
- }
48402
-
48403
- if (!Util.isUnset(request.pageSize)) {
48404
- query["PageSize"] = request.pageSize;
48405
- }
48406
-
48407
- if (!Util.isUnset(request.phase)) {
48408
- query["Phase"] = request.phase;
48409
- }
48410
-
48411
- if (!Util.isUnset(request.queryArgsShrink)) {
48412
- query["QueryArgs"] = request.queryArgsShrink;
48413
- }
48414
-
48415
- if (!Util.isUnset(request.siteId)) {
48416
- query["SiteId"] = request.siteId;
48417
- }
48418
-
48419
- if (!Util.isUnset(request.siteVersion)) {
48420
- query["SiteVersion"] = request.siteVersion;
48421
- }
48422
-
48423
- let req = new $OpenApi.OpenApiRequest({
48424
- query: OpenApiUtil.query(query),
48425
- });
48426
- let params = new $OpenApi.Params({
48427
- action: "ListWafRulesets",
48428
- version: "2024-09-10",
48429
- protocol: "HTTPS",
48430
- pathname: "/",
48431
- method: "POST",
48432
- authType: "AK",
48433
- style: "RPC",
48434
- reqBodyType: "formData",
48435
- bodyType: "json",
48436
- });
48437
- return $tea.cast<ListWafRulesetsResponse>(await this.callApi(params, req, runtime), new ListWafRulesetsResponse({}));
48438
- }
48439
-
48440
- /**
48441
- * Lists the rulesets in a Web Application Firewall (WAF) rule category. You can call this operation to query the basic information about and status of rulesets by page.
48442
- *
48443
- * @param request - ListWafRulesetsRequest
48444
- * @returns ListWafRulesetsResponse
48445
- */
48446
- async listWafRulesets(request: ListWafRulesetsRequest): Promise<ListWafRulesetsResponse> {
48447
- let runtime = new $Util.RuntimeOptions({ });
48448
- return await this.listWafRulesetsWithOptions(request, runtime);
48449
- }
48450
-
48451
45643
  /**
48452
45644
  * Queries template rules in Web Application Firewall (WAF). In most cases, these rules are pre-defined rulesets that are used to quickly enable protection against common types of attacks.
48453
45645
  *
@@ -49476,7 +46668,7 @@ export default class Client extends OpenApi {
49476
46668
  }
49477
46669
 
49478
46670
  /**
49479
- * 为客户端证书绑定域名
46671
+ * Associates domain names with a client CA certificate. If no certificate is specified, domain names are associated with an Edge Security Acceleration (ESA)-managed CA certificate.
49480
46672
  *
49481
46673
  * @param tmpReq - SetClientCertificateHostnamesRequest
49482
46674
  * @param runtime - runtime options for this request RuntimeOptions
@@ -49523,7 +46715,7 @@ export default class Client extends OpenApi {
49523
46715
  }
49524
46716
 
49525
46717
  /**
49526
- * 为客户端证书绑定域名
46718
+ * Associates domain names with a client CA certificate. If no certificate is specified, domain names are associated with an Edge Security Acceleration (ESA)-managed CA certificate.
49527
46719
  *
49528
46720
  * @param request - SetClientCertificateHostnamesRequest
49529
46721
  * @returns SetClientCertificateHostnamesResponse
@@ -50667,132 +47859,6 @@ export default class Client extends OpenApi {
50667
47859
  return await this.updateUserDeliveryTaskStatusWithOptions(request, runtime);
50668
47860
  }
50669
47861
 
50670
- /**
50671
- * Modifies the configuration or status of a Web Application Firewall (WAF) rule.
50672
- *
50673
- * @param tmpReq - UpdateWafRuleRequest
50674
- * @param runtime - runtime options for this request RuntimeOptions
50675
- * @returns UpdateWafRuleResponse
50676
- */
50677
- async updateWafRuleWithOptions(tmpReq: UpdateWafRuleRequest, runtime: $Util.RuntimeOptions): Promise<UpdateWafRuleResponse> {
50678
- Util.validateModel(tmpReq);
50679
- let request = new UpdateWafRuleShrinkRequest({ });
50680
- OpenApiUtil.convert(tmpReq, request);
50681
- if (!Util.isUnset(tmpReq.config)) {
50682
- request.configShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.config, "Config", "json");
50683
- }
50684
-
50685
- let query = { };
50686
- if (!Util.isUnset(request.siteId)) {
50687
- query["SiteId"] = request.siteId;
50688
- }
50689
-
50690
- if (!Util.isUnset(request.siteVersion)) {
50691
- query["SiteVersion"] = request.siteVersion;
50692
- }
50693
-
50694
- let body : {[key: string ]: any} = { };
50695
- if (!Util.isUnset(request.configShrink)) {
50696
- body["Config"] = request.configShrink;
50697
- }
50698
-
50699
- if (!Util.isUnset(request.id)) {
50700
- body["Id"] = request.id;
50701
- }
50702
-
50703
- if (!Util.isUnset(request.position)) {
50704
- body["Position"] = request.position;
50705
- }
50706
-
50707
- if (!Util.isUnset(request.status)) {
50708
- body["Status"] = request.status;
50709
- }
50710
-
50711
- let req = new $OpenApi.OpenApiRequest({
50712
- query: OpenApiUtil.query(query),
50713
- body: OpenApiUtil.parseToMap(body),
50714
- });
50715
- let params = new $OpenApi.Params({
50716
- action: "UpdateWafRule",
50717
- version: "2024-09-10",
50718
- protocol: "HTTPS",
50719
- pathname: "/",
50720
- method: "POST",
50721
- authType: "AK",
50722
- style: "RPC",
50723
- reqBodyType: "formData",
50724
- bodyType: "json",
50725
- });
50726
- return $tea.cast<UpdateWafRuleResponse>(await this.callApi(params, req, runtime), new UpdateWafRuleResponse({}));
50727
- }
50728
-
50729
- /**
50730
- * Modifies the configuration or status of a Web Application Firewall (WAF) rule.
50731
- *
50732
- * @param request - UpdateWafRuleRequest
50733
- * @returns UpdateWafRuleResponse
50734
- */
50735
- async updateWafRule(request: UpdateWafRuleRequest): Promise<UpdateWafRuleResponse> {
50736
- let runtime = new $Util.RuntimeOptions({ });
50737
- return await this.updateWafRuleWithOptions(request, runtime);
50738
- }
50739
-
50740
- /**
50741
- * Updates a WAF ruleset based on its ID.
50742
- *
50743
- * @param request - UpdateWafRulesetRequest
50744
- * @param runtime - runtime options for this request RuntimeOptions
50745
- * @returns UpdateWafRulesetResponse
50746
- */
50747
- async updateWafRulesetWithOptions(request: UpdateWafRulesetRequest, runtime: $Util.RuntimeOptions): Promise<UpdateWafRulesetResponse> {
50748
- Util.validateModel(request);
50749
- let query = { };
50750
- if (!Util.isUnset(request.siteId)) {
50751
- query["SiteId"] = request.siteId;
50752
- }
50753
-
50754
- if (!Util.isUnset(request.siteVersion)) {
50755
- query["SiteVersion"] = request.siteVersion;
50756
- }
50757
-
50758
- let body : {[key: string ]: any} = { };
50759
- if (!Util.isUnset(request.id)) {
50760
- body["Id"] = request.id;
50761
- }
50762
-
50763
- if (!Util.isUnset(request.status)) {
50764
- body["Status"] = request.status;
50765
- }
50766
-
50767
- let req = new $OpenApi.OpenApiRequest({
50768
- query: OpenApiUtil.query(query),
50769
- body: OpenApiUtil.parseToMap(body),
50770
- });
50771
- let params = new $OpenApi.Params({
50772
- action: "UpdateWafRuleset",
50773
- version: "2024-09-10",
50774
- protocol: "HTTPS",
50775
- pathname: "/",
50776
- method: "POST",
50777
- authType: "AK",
50778
- style: "RPC",
50779
- reqBodyType: "formData",
50780
- bodyType: "json",
50781
- });
50782
- return $tea.cast<UpdateWafRulesetResponse>(await this.callApi(params, req, runtime), new UpdateWafRulesetResponse({}));
50783
- }
50784
-
50785
- /**
50786
- * Updates a WAF ruleset based on its ID.
50787
- *
50788
- * @param request - UpdateWafRulesetRequest
50789
- * @returns UpdateWafRulesetResponse
50790
- */
50791
- async updateWafRuleset(request: UpdateWafRulesetRequest): Promise<UpdateWafRulesetResponse> {
50792
- let runtime = new $Util.RuntimeOptions({ });
50793
- return await this.updateWafRulesetWithOptions(request, runtime);
50794
- }
50795
-
50796
47862
  /**
50797
47863
  * Modifies the configurations of a waiting room.
50798
47864
  *