@aws-sdk/client-wafv2 3.826.0 → 3.828.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (14) hide show
  1. package/dist-cjs/index.js +23 -0
  2. package/dist-es/models/models_0.js +14 -0
  3. package/dist-es/protocols/Aws_json1_1.js +3 -0
  4. package/dist-types/commands/CheckCapacityCommand.d.ts +28 -0
  5. package/dist-types/commands/CreateRuleGroupCommand.d.ts +28 -0
  6. package/dist-types/commands/CreateWebACLCommand.d.ts +31 -0
  7. package/dist-types/commands/GetRuleGroupCommand.d.ts +28 -0
  8. package/dist-types/commands/GetWebACLCommand.d.ts +59 -0
  9. package/dist-types/commands/GetWebACLForResourceCommand.d.ts +59 -0
  10. package/dist-types/commands/UpdateRuleGroupCommand.d.ts +28 -0
  11. package/dist-types/commands/UpdateWebACLCommand.d.ts +31 -0
  12. package/dist-types/models/models_0.d.ts +252 -13
  13. package/dist-types/ts3.4/models/models_0.d.ts +41 -3
  14. package/package.json +5 -5
package/dist-cjs/index.js CHANGED
@@ -83,6 +83,7 @@ __export(index_exports, {
83
83
  ListWebACLsCommand: () => ListWebACLsCommand,
84
84
  LogScope: () => LogScope,
85
85
  LogType: () => LogType,
86
+ LowReputationMode: () => LowReputationMode,
86
87
  MapMatchScope: () => MapMatchScope,
87
88
  OversizeHandling: () => OversizeHandling,
88
89
  ParameterExceptionField: () => ParameterExceptionField,
@@ -97,6 +98,7 @@ __export(index_exports, {
97
98
  ResponseContentType: () => ResponseContentType,
98
99
  Scope: () => Scope,
99
100
  SensitivityLevel: () => SensitivityLevel,
101
+ SensitivityToAct: () => SensitivityToAct,
100
102
  SizeInspectionLimit: () => SizeInspectionLimit,
101
103
  TagResourceCommand: () => TagResourceCommand,
102
104
  TextTransformationType: () => TextTransformationType,
@@ -106,6 +108,7 @@ __export(index_exports, {
106
108
  UpdateRegexPatternSetCommand: () => UpdateRegexPatternSetCommand,
107
109
  UpdateRuleGroupCommand: () => UpdateRuleGroupCommand,
108
110
  UpdateWebACLCommand: () => UpdateWebACLCommand,
111
+ UsageOfAction: () => UsageOfAction,
109
112
  WAFAssociatedItemException: () => WAFAssociatedItemException,
110
113
  WAFConfigurationWarningException: () => WAFConfigurationWarningException,
111
114
  WAFDuplicateItemException: () => WAFDuplicateItemException,
@@ -629,6 +632,15 @@ var PayloadType = {
629
632
  FORM_ENCODED: "FORM_ENCODED",
630
633
  JSON: "JSON"
631
634
  };
635
+ var SensitivityToAct = {
636
+ HIGH: "HIGH",
637
+ LOW: "LOW",
638
+ MEDIUM: "MEDIUM"
639
+ };
640
+ var UsageOfAction = {
641
+ DISABLED: "DISABLED",
642
+ ENABLED: "ENABLED"
643
+ };
632
644
  var InspectionLevel = {
633
645
  COMMON: "COMMON",
634
646
  TARGETED: "TARGETED"
@@ -736,6 +748,7 @@ var ParameterExceptionField = {
736
748
  LABEL_MATCH_STATEMENT: "LABEL_MATCH_STATEMENT",
737
749
  LOGGING_FILTER: "LOGGING_FILTER",
738
750
  LOG_DESTINATION: "LOG_DESTINATION",
751
+ LOW_REPUTATION_MODE: "LOW_REPUTATION_MODE",
739
752
  MANAGED_RULE_GROUP_CONFIG: "MANAGED_RULE_GROUP_CONFIG",
740
753
  MANAGED_RULE_SET: "MANAGED_RULE_SET",
741
754
  MANAGED_RULE_SET_STATEMENT: "MANAGED_RULE_SET_STATEMENT",
@@ -1043,6 +1056,10 @@ var FieldToProtectType = {
1043
1056
  SINGLE_HEADER: "SINGLE_HEADER",
1044
1057
  SINGLE_QUERY_ARGUMENT: "SINGLE_QUERY_ARGUMENT"
1045
1058
  };
1059
+ var LowReputationMode = {
1060
+ ACTIVE_UNDER_DDOS: "ACTIVE_UNDER_DDOS",
1061
+ ALWAYS_ON: "ALWAYS_ON"
1062
+ };
1046
1063
  var WAFConfigurationWarningException = class _WAFConfigurationWarningException extends WAFV2ServiceException {
1047
1064
  static {
1048
1065
  __name(this, "WAFConfigurationWarningException");
@@ -2508,6 +2525,7 @@ var se_CreateWebACLRequest = /* @__PURE__ */ __name((input, context) => {
2508
2525
  DefaultAction: import_smithy_client._json,
2509
2526
  Description: [],
2510
2527
  Name: [],
2528
+ OnSourceDDoSProtectionConfig: import_smithy_client._json,
2511
2529
  Rules: /* @__PURE__ */ __name((_) => se_Rules(_, context), "Rules"),
2512
2530
  Scope: [],
2513
2531
  Tags: import_smithy_client._json,
@@ -2638,6 +2656,7 @@ var se_UpdateWebACLRequest = /* @__PURE__ */ __name((input, context) => {
2638
2656
  Id: [],
2639
2657
  LockToken: [],
2640
2658
  Name: [],
2659
+ OnSourceDDoSProtectionConfig: import_smithy_client._json,
2641
2660
  Rules: /* @__PURE__ */ __name((_) => se_Rules(_, context), "Rules"),
2642
2661
  Scope: [],
2643
2662
  TokenDomains: import_smithy_client._json,
@@ -2956,6 +2975,7 @@ var de_WebACL = /* @__PURE__ */ __name((output, context) => {
2956
2975
  LabelNamespace: import_smithy_client.expectString,
2957
2976
  ManagedByFirewallManager: import_smithy_client.expectBoolean,
2958
2977
  Name: import_smithy_client.expectString,
2978
+ OnSourceDDoSProtectionConfig: import_smithy_client._json,
2959
2979
  PostProcessFirewallManagerRuleGroups: /* @__PURE__ */ __name((_) => de_FirewallManagerRuleGroups(_, context), "PostProcessFirewallManagerRuleGroups"),
2960
2980
  PreProcessFirewallManagerRuleGroups: /* @__PURE__ */ __name((_) => de_FirewallManagerRuleGroups(_, context), "PreProcessFirewallManagerRuleGroups"),
2961
2981
  RetrofittedByFirewallManager: import_smithy_client.expectBoolean,
@@ -3941,6 +3961,8 @@ var WAFV2 = class extends WAFV2Client {
3941
3961
  ForwardedIPPosition,
3942
3962
  LabelMatchScope,
3943
3963
  PayloadType,
3964
+ SensitivityToAct,
3965
+ UsageOfAction,
3944
3966
  InspectionLevel,
3945
3967
  RateBasedStatementAggregateKeyType,
3946
3968
  ComparisonOperator,
@@ -3966,6 +3988,7 @@ var WAFV2 = class extends WAFV2Client {
3966
3988
  ResponseContentType,
3967
3989
  DataProtectionAction,
3968
3990
  FieldToProtectType,
3991
+ LowReputationMode,
3969
3992
  WAFConfigurationWarningException,
3970
3993
  WAFAssociatedItemException,
3971
3994
  LogScope,
package/dist-es/models/models_0.js CHANGED
@@ -326,6 +326,15 @@ export const PayloadType = {
326
326
  FORM_ENCODED: "FORM_ENCODED",
327
327
  JSON: "JSON",
328
328
  };
329
+ export const SensitivityToAct = {
330
+ HIGH: "HIGH",
331
+ LOW: "LOW",
332
+ MEDIUM: "MEDIUM",
333
+ };
334
+ export const UsageOfAction = {
335
+ DISABLED: "DISABLED",
336
+ ENABLED: "ENABLED",
337
+ };
329
338
  export const InspectionLevel = {
330
339
  COMMON: "COMMON",
331
340
  TARGETED: "TARGETED",
@@ -421,6 +430,7 @@ export const ParameterExceptionField = {
421
430
  LABEL_MATCH_STATEMENT: "LABEL_MATCH_STATEMENT",
422
431
  LOGGING_FILTER: "LOGGING_FILTER",
423
432
  LOG_DESTINATION: "LOG_DESTINATION",
433
+ LOW_REPUTATION_MODE: "LOW_REPUTATION_MODE",
424
434
  MANAGED_RULE_GROUP_CONFIG: "MANAGED_RULE_GROUP_CONFIG",
425
435
  MANAGED_RULE_SET: "MANAGED_RULE_SET",
426
436
  MANAGED_RULE_SET_STATEMENT: "MANAGED_RULE_SET_STATEMENT",
@@ -646,6 +656,10 @@ export const FieldToProtectType = {
646
656
  SINGLE_HEADER: "SINGLE_HEADER",
647
657
  SINGLE_QUERY_ARGUMENT: "SINGLE_QUERY_ARGUMENT",
648
658
  };
659
+ export const LowReputationMode = {
660
+ ACTIVE_UNDER_DDOS: "ACTIVE_UNDER_DDOS",
661
+ ALWAYS_ON: "ALWAYS_ON",
662
+ };
649
663
  export class WAFConfigurationWarningException extends __BaseException {
650
664
  name = "WAFConfigurationWarningException";
651
665
  $fault = "client";
package/dist-es/protocols/Aws_json1_1.js CHANGED
@@ -1314,6 +1314,7 @@ const se_CreateWebACLRequest = (input, context) => {
1314
1314
  DefaultAction: _json,
1315
1315
  Description: [],
1316
1316
  Name: [],
1317
+ OnSourceDDoSProtectionConfig: _json,
1317
1318
  Rules: (_) => se_Rules(_, context),
1318
1319
  Scope: [],
1319
1320
  Tags: _json,
@@ -1448,6 +1449,7 @@ const se_UpdateWebACLRequest = (input, context) => {
1448
1449
  Id: [],
1449
1450
  LockToken: [],
1450
1451
  Name: [],
1452
+ OnSourceDDoSProtectionConfig: _json,
1451
1453
  Rules: (_) => se_Rules(_, context),
1452
1454
  Scope: [],
1453
1455
  TokenDomains: _json,
@@ -1780,6 +1782,7 @@ const de_WebACL = (output, context) => {
1780
1782
  LabelNamespace: __expectString,
1781
1783
  ManagedByFirewallManager: __expectBoolean,
1782
1784
  Name: __expectString,
1785
+ OnSourceDDoSProtectionConfig: _json,
1783
1786
  PostProcessFirewallManagerRuleGroups: (_) => de_FirewallManagerRuleGroups(_, context),
1784
1787
  PreProcessFirewallManagerRuleGroups: (_) => de_FirewallManagerRuleGroups(_, context),
1785
1788
  RetrofittedByFirewallManager: __expectBoolean,
package/dist-types/commands/CheckCapacityCommand.d.ts CHANGED
@@ -760,6 +760,20 @@ declare const CheckCapacityCommand_base: {
760
760
  * },
761
761
  * EnableRegexInPath: true || false,
762
762
  * },
763
+ * AWSManagedRulesAntiDDoSRuleSet: { // AWSManagedRulesAntiDDoSRuleSet
764
+ * ClientSideActionConfig: { // ClientSideActionConfig
765
+ * Challenge: { // ClientSideAction
766
+ * UsageOfAction: "ENABLED" || "DISABLED", // required
767
+ * Sensitivity: "LOW" || "MEDIUM" || "HIGH",
768
+ * ExemptUriRegularExpressions: [ // RegularExpressionList
769
+ * { // Regex
770
+ * RegexString: "STRING_VALUE",
771
+ * },
772
+ * ],
773
+ * },
774
+ * },
775
+ * SensitivityToBlock: "LOW" || "MEDIUM" || "HIGH",
776
+ * },
763
777
  * },
764
778
  * ],
765
779
  * RuleActionOverrides: [
@@ -985,6 +999,20 @@ declare const CheckCapacityCommand_base: {
985
999
  * },
986
1000
  * EnableRegexInPath: true || false,
987
1001
  * },
1002
+ * AWSManagedRulesAntiDDoSRuleSet: {
1003
+ * ClientSideActionConfig: {
1004
+ * Challenge: {
1005
+ * UsageOfAction: "ENABLED" || "DISABLED", // required
1006
+ * Sensitivity: "LOW" || "MEDIUM" || "HIGH",
1007
+ * ExemptUriRegularExpressions: [
1008
+ * {
1009
+ * RegexString: "STRING_VALUE",
1010
+ * },
1011
+ * ],
1012
+ * },
1013
+ * },
1014
+ * SensitivityToBlock: "LOW" || "MEDIUM" || "HIGH",
1015
+ * },
988
1016
  * },
989
1017
  * ],
990
1018
  * RuleActionOverrides: [
package/dist-types/commands/CreateRuleGroupCommand.d.ts CHANGED
@@ -753,6 +753,20 @@ declare const CreateRuleGroupCommand_base: {
753
753
  * },
754
754
  * EnableRegexInPath: true || false,
755
755
  * },
756
+ * AWSManagedRulesAntiDDoSRuleSet: { // AWSManagedRulesAntiDDoSRuleSet
757
+ * ClientSideActionConfig: { // ClientSideActionConfig
758
+ * Challenge: { // ClientSideAction
759
+ * UsageOfAction: "ENABLED" || "DISABLED", // required
760
+ * Sensitivity: "LOW" || "MEDIUM" || "HIGH",
761
+ * ExemptUriRegularExpressions: [ // RegularExpressionList
762
+ * { // Regex
763
+ * RegexString: "STRING_VALUE",
764
+ * },
765
+ * ],
766
+ * },
767
+ * },
768
+ * SensitivityToBlock: "LOW" || "MEDIUM" || "HIGH",
769
+ * },
756
770
  * },
757
771
  * ],
758
772
  * RuleActionOverrides: [
@@ -978,6 +992,20 @@ declare const CreateRuleGroupCommand_base: {
978
992
  * },
979
993
  * EnableRegexInPath: true || false,
980
994
  * },
995
+ * AWSManagedRulesAntiDDoSRuleSet: {
996
+ * ClientSideActionConfig: {
997
+ * Challenge: {
998
+ * UsageOfAction: "ENABLED" || "DISABLED", // required
999
+ * Sensitivity: "LOW" || "MEDIUM" || "HIGH",
1000
+ * ExemptUriRegularExpressions: [
1001
+ * {
1002
+ * RegexString: "STRING_VALUE",
1003
+ * },
1004
+ * ],
1005
+ * },
1006
+ * },
1007
+ * SensitivityToBlock: "LOW" || "MEDIUM" || "HIGH",
1008
+ * },
981
1009
  * },
982
1010
  * ],
983
1011
  * RuleActionOverrides: [
package/dist-types/commands/CreateWebACLCommand.d.ts CHANGED
@@ -756,6 +756,20 @@ declare const CreateWebACLCommand_base: {
756
756
  * },
757
757
  * EnableRegexInPath: true || false,
758
758
  * },
759
+ * AWSManagedRulesAntiDDoSRuleSet: { // AWSManagedRulesAntiDDoSRuleSet
760
+ * ClientSideActionConfig: { // ClientSideActionConfig
761
+ * Challenge: { // ClientSideAction
762
+ * UsageOfAction: "ENABLED" || "DISABLED", // required
763
+ * Sensitivity: "LOW" || "MEDIUM" || "HIGH",
764
+ * ExemptUriRegularExpressions: [ // RegularExpressionList
765
+ * { // Regex
766
+ * RegexString: "STRING_VALUE",
767
+ * },
768
+ * ],
769
+ * },
770
+ * },
771
+ * SensitivityToBlock: "LOW" || "MEDIUM" || "HIGH",
772
+ * },
759
773
  * },
760
774
  * ],
761
775
  * RuleActionOverrides: [
@@ -973,6 +987,20 @@ declare const CreateWebACLCommand_base: {
973
987
  * },
974
988
  * EnableRegexInPath: true || false,
975
989
  * },
990
+ * AWSManagedRulesAntiDDoSRuleSet: {
991
+ * ClientSideActionConfig: {
992
+ * Challenge: {
993
+ * UsageOfAction: "ENABLED" || "DISABLED", // required
994
+ * Sensitivity: "LOW" || "MEDIUM" || "HIGH",
995
+ * ExemptUriRegularExpressions: [
996
+ * {
997
+ * RegexString: "STRING_VALUE",
998
+ * },
999
+ * ],
1000
+ * },
1001
+ * },
1002
+ * SensitivityToBlock: "LOW" || "MEDIUM" || "HIGH",
1003
+ * },
976
1004
  * },
977
1005
  * ],
978
1006
  * RuleActionOverrides: [
@@ -1089,6 +1117,9 @@ declare const CreateWebACLCommand_base: {
1089
1117
  * },
1090
1118
  * },
1091
1119
  * },
1120
+ * OnSourceDDoSProtectionConfig: { // OnSourceDDoSProtectionConfig
1121
+ * ALBLowReputationMode: "ACTIVE_UNDER_DDOS" || "ALWAYS_ON", // required
1122
+ * },
1092
1123
  * };
1093
1124
  * const command = new CreateWebACLCommand(input);
1094
1125
  * const response = await client.send(command);
package/dist-types/commands/GetRuleGroupCommand.d.ts CHANGED
@@ -762,6 +762,20 @@ declare const GetRuleGroupCommand_base: {
762
762
  * // },
763
763
  * // EnableRegexInPath: true || false,
764
764
  * // },
765
+ * // AWSManagedRulesAntiDDoSRuleSet: { // AWSManagedRulesAntiDDoSRuleSet
766
+ * // ClientSideActionConfig: { // ClientSideActionConfig
767
+ * // Challenge: { // ClientSideAction
768
+ * // UsageOfAction: "ENABLED" || "DISABLED", // required
769
+ * // Sensitivity: "LOW" || "MEDIUM" || "HIGH",
770
+ * // ExemptUriRegularExpressions: [ // RegularExpressionList
771
+ * // { // Regex
772
+ * // RegexString: "STRING_VALUE",
773
+ * // },
774
+ * // ],
775
+ * // },
776
+ * // },
777
+ * // SensitivityToBlock: "LOW" || "MEDIUM" || "HIGH",
778
+ * // },
765
779
  * // },
766
780
  * // ],
767
781
  * // RuleActionOverrides: [
@@ -987,6 +1001,20 @@ declare const GetRuleGroupCommand_base: {
987
1001
  * // },
988
1002
  * // EnableRegexInPath: true || false,
989
1003
  * // },
1004
+ * // AWSManagedRulesAntiDDoSRuleSet: {
1005
+ * // ClientSideActionConfig: {
1006
+ * // Challenge: {
1007
+ * // UsageOfAction: "ENABLED" || "DISABLED", // required
1008
+ * // Sensitivity: "LOW" || "MEDIUM" || "HIGH",
1009
+ * // ExemptUriRegularExpressions: [
1010
+ * // {
1011
+ * // RegexString: "STRING_VALUE",
1012
+ * // },
1013
+ * // ],
1014
+ * // },
1015
+ * // },
1016
+ * // SensitivityToBlock: "LOW" || "MEDIUM" || "HIGH",
1017
+ * // },
990
1018
  * // },
991
1019
  * // ],
992
1020
  * // RuleActionOverrides: [
package/dist-types/commands/GetWebACLCommand.d.ts CHANGED
@@ -765,6 +765,20 @@ declare const GetWebACLCommand_base: {
765
765
  * // },
766
766
  * // EnableRegexInPath: true || false,
767
767
  * // },
768
+ * // AWSManagedRulesAntiDDoSRuleSet: { // AWSManagedRulesAntiDDoSRuleSet
769
+ * // ClientSideActionConfig: { // ClientSideActionConfig
770
+ * // Challenge: { // ClientSideAction
771
+ * // UsageOfAction: "ENABLED" || "DISABLED", // required
772
+ * // Sensitivity: "LOW" || "MEDIUM" || "HIGH",
773
+ * // ExemptUriRegularExpressions: [ // RegularExpressionList
774
+ * // { // Regex
775
+ * // RegexString: "STRING_VALUE",
776
+ * // },
777
+ * // ],
778
+ * // },
779
+ * // },
780
+ * // SensitivityToBlock: "LOW" || "MEDIUM" || "HIGH",
781
+ * // },
768
782
  * // },
769
783
  * // ],
770
784
  * // RuleActionOverrides: [
@@ -982,6 +996,20 @@ declare const GetWebACLCommand_base: {
982
996
  * // },
983
997
  * // EnableRegexInPath: true || false,
984
998
  * // },
999
+ * // AWSManagedRulesAntiDDoSRuleSet: {
1000
+ * // ClientSideActionConfig: {
1001
+ * // Challenge: {
1002
+ * // UsageOfAction: "ENABLED" || "DISABLED", // required
1003
+ * // Sensitivity: "LOW" || "MEDIUM" || "HIGH",
1004
+ * // ExemptUriRegularExpressions: [
1005
+ * // {
1006
+ * // RegexString: "STRING_VALUE",
1007
+ * // },
1008
+ * // ],
1009
+ * // },
1010
+ * // },
1011
+ * // SensitivityToBlock: "LOW" || "MEDIUM" || "HIGH",
1012
+ * // },
985
1013
  * // },
986
1014
  * // ],
987
1015
  * // RuleActionOverrides: [
@@ -1161,6 +1189,20 @@ declare const GetWebACLCommand_base: {
1161
1189
  * // ResponseInspection: "<ResponseInspection>",
1162
1190
  * // EnableRegexInPath: true || false,
1163
1191
  * // },
1192
+ * // AWSManagedRulesAntiDDoSRuleSet: {
1193
+ * // ClientSideActionConfig: {
1194
+ * // Challenge: {
1195
+ * // UsageOfAction: "ENABLED" || "DISABLED", // required
1196
+ * // Sensitivity: "LOW" || "MEDIUM" || "HIGH",
1197
+ * // ExemptUriRegularExpressions: [
1198
+ * // {
1199
+ * // RegexString: "STRING_VALUE",
1200
+ * // },
1201
+ * // ],
1202
+ * // },
1203
+ * // },
1204
+ * // SensitivityToBlock: "LOW" || "MEDIUM" || "HIGH",
1205
+ * // },
1164
1206
  * // },
1165
1207
  * // ],
1166
1208
  * // RuleActionOverrides: [
@@ -1242,6 +1284,20 @@ declare const GetWebACLCommand_base: {
1242
1284
  * // ResponseInspection: "<ResponseInspection>",
1243
1285
  * // EnableRegexInPath: true || false,
1244
1286
  * // },
1287
+ * // AWSManagedRulesAntiDDoSRuleSet: {
1288
+ * // ClientSideActionConfig: {
1289
+ * // Challenge: {
1290
+ * // UsageOfAction: "ENABLED" || "DISABLED", // required
1291
+ * // Sensitivity: "LOW" || "MEDIUM" || "HIGH",
1292
+ * // ExemptUriRegularExpressions: [
1293
+ * // {
1294
+ * // RegexString: "STRING_VALUE",
1295
+ * // },
1296
+ * // ],
1297
+ * // },
1298
+ * // },
1299
+ * // SensitivityToBlock: "LOW" || "MEDIUM" || "HIGH",
1300
+ * // },
1245
1301
  * // },
1246
1302
  * // ],
1247
1303
  * // RuleActionOverrides: "<RuleActionOverrides>",
@@ -1292,6 +1348,9 @@ declare const GetWebACLCommand_base: {
1292
1348
  * // },
1293
1349
  * // },
1294
1350
  * // RetrofittedByFirewallManager: true || false,
1351
+ * // OnSourceDDoSProtectionConfig: { // OnSourceDDoSProtectionConfig
1352
+ * // ALBLowReputationMode: "ACTIVE_UNDER_DDOS" || "ALWAYS_ON", // required
1353
+ * // },
1295
1354
  * // },
1296
1355
  * // LockToken: "STRING_VALUE",
1297
1356
  * // ApplicationIntegrationURL: "STRING_VALUE",
package/dist-types/commands/GetWebACLForResourceCommand.d.ts CHANGED
@@ -772,6 +772,20 @@ declare const GetWebACLForResourceCommand_base: {
772
772
  * // },
773
773
  * // EnableRegexInPath: true || false,
774
774
  * // },
775
+ * // AWSManagedRulesAntiDDoSRuleSet: { // AWSManagedRulesAntiDDoSRuleSet
776
+ * // ClientSideActionConfig: { // ClientSideActionConfig
777
+ * // Challenge: { // ClientSideAction
778
+ * // UsageOfAction: "ENABLED" || "DISABLED", // required
779
+ * // Sensitivity: "LOW" || "MEDIUM" || "HIGH",
780
+ * // ExemptUriRegularExpressions: [ // RegularExpressionList
781
+ * // { // Regex
782
+ * // RegexString: "STRING_VALUE",
783
+ * // },
784
+ * // ],
785
+ * // },
786
+ * // },
787
+ * // SensitivityToBlock: "LOW" || "MEDIUM" || "HIGH",
788
+ * // },
775
789
  * // },
776
790
  * // ],
777
791
  * // RuleActionOverrides: [
@@ -989,6 +1003,20 @@ declare const GetWebACLForResourceCommand_base: {
989
1003
  * // },
990
1004
  * // EnableRegexInPath: true || false,
991
1005
  * // },
1006
+ * // AWSManagedRulesAntiDDoSRuleSet: {
1007
+ * // ClientSideActionConfig: {
1008
+ * // Challenge: {
1009
+ * // UsageOfAction: "ENABLED" || "DISABLED", // required
1010
+ * // Sensitivity: "LOW" || "MEDIUM" || "HIGH",
1011
+ * // ExemptUriRegularExpressions: [
1012
+ * // {
1013
+ * // RegexString: "STRING_VALUE",
1014
+ * // },
1015
+ * // ],
1016
+ * // },
1017
+ * // },
1018
+ * // SensitivityToBlock: "LOW" || "MEDIUM" || "HIGH",
1019
+ * // },
992
1020
  * // },
993
1021
  * // ],
994
1022
  * // RuleActionOverrides: [
@@ -1168,6 +1196,20 @@ declare const GetWebACLForResourceCommand_base: {
1168
1196
  * // ResponseInspection: "<ResponseInspection>",
1169
1197
  * // EnableRegexInPath: true || false,
1170
1198
  * // },
1199
+ * // AWSManagedRulesAntiDDoSRuleSet: {
1200
+ * // ClientSideActionConfig: {
1201
+ * // Challenge: {
1202
+ * // UsageOfAction: "ENABLED" || "DISABLED", // required
1203
+ * // Sensitivity: "LOW" || "MEDIUM" || "HIGH",
1204
+ * // ExemptUriRegularExpressions: [
1205
+ * // {
1206
+ * // RegexString: "STRING_VALUE",
1207
+ * // },
1208
+ * // ],
1209
+ * // },
1210
+ * // },
1211
+ * // SensitivityToBlock: "LOW" || "MEDIUM" || "HIGH",
1212
+ * // },
1171
1213
  * // },
1172
1214
  * // ],
1173
1215
  * // RuleActionOverrides: [
@@ -1249,6 +1291,20 @@ declare const GetWebACLForResourceCommand_base: {
1249
1291
  * // ResponseInspection: "<ResponseInspection>",
1250
1292
  * // EnableRegexInPath: true || false,
1251
1293
  * // },
1294
+ * // AWSManagedRulesAntiDDoSRuleSet: {
1295
+ * // ClientSideActionConfig: {
1296
+ * // Challenge: {
1297
+ * // UsageOfAction: "ENABLED" || "DISABLED", // required
1298
+ * // Sensitivity: "LOW" || "MEDIUM" || "HIGH",
1299
+ * // ExemptUriRegularExpressions: [
1300
+ * // {
1301
+ * // RegexString: "STRING_VALUE",
1302
+ * // },
1303
+ * // ],
1304
+ * // },
1305
+ * // },
1306
+ * // SensitivityToBlock: "LOW" || "MEDIUM" || "HIGH",
1307
+ * // },
1252
1308
  * // },
1253
1309
  * // ],
1254
1310
  * // RuleActionOverrides: "<RuleActionOverrides>",
@@ -1299,6 +1355,9 @@ declare const GetWebACLForResourceCommand_base: {
1299
1355
  * // },
1300
1356
  * // },
1301
1357
  * // RetrofittedByFirewallManager: true || false,
1358
+ * // OnSourceDDoSProtectionConfig: { // OnSourceDDoSProtectionConfig
1359
+ * // ALBLowReputationMode: "ACTIVE_UNDER_DDOS" || "ALWAYS_ON", // required
1360
+ * // },
1302
1361
  * // },
1303
1362
  * // };
1304
1363
  *
package/dist-types/commands/UpdateRuleGroupCommand.d.ts CHANGED
@@ -788,6 +788,20 @@ declare const UpdateRuleGroupCommand_base: {
788
788
  * },
789
789
  * EnableRegexInPath: true || false,
790
790
  * },
791
+ * AWSManagedRulesAntiDDoSRuleSet: { // AWSManagedRulesAntiDDoSRuleSet
792
+ * ClientSideActionConfig: { // ClientSideActionConfig
793
+ * Challenge: { // ClientSideAction
794
+ * UsageOfAction: "ENABLED" || "DISABLED", // required
795
+ * Sensitivity: "LOW" || "MEDIUM" || "HIGH",
796
+ * ExemptUriRegularExpressions: [ // RegularExpressionList
797
+ * { // Regex
798
+ * RegexString: "STRING_VALUE",
799
+ * },
800
+ * ],
801
+ * },
802
+ * },
803
+ * SensitivityToBlock: "LOW" || "MEDIUM" || "HIGH",
804
+ * },
791
805
  * },
792
806
  * ],
793
807
  * RuleActionOverrides: [
@@ -1013,6 +1027,20 @@ declare const UpdateRuleGroupCommand_base: {
1013
1027
  * },
1014
1028
  * EnableRegexInPath: true || false,
1015
1029
  * },
1030
+ * AWSManagedRulesAntiDDoSRuleSet: {
1031
+ * ClientSideActionConfig: {
1032
+ * Challenge: {
1033
+ * UsageOfAction: "ENABLED" || "DISABLED", // required
1034
+ * Sensitivity: "LOW" || "MEDIUM" || "HIGH",
1035
+ * ExemptUriRegularExpressions: [
1036
+ * {
1037
+ * RegexString: "STRING_VALUE",
1038
+ * },
1039
+ * ],
1040
+ * },
1041
+ * },
1042
+ * SensitivityToBlock: "LOW" || "MEDIUM" || "HIGH",
1043
+ * },
1016
1044
  * },
1017
1045
  * ],
1018
1046
  * RuleActionOverrides: [
package/dist-types/commands/UpdateWebACLCommand.d.ts CHANGED
@@ -793,6 +793,20 @@ declare const UpdateWebACLCommand_base: {
793
793
  * },
794
794
  * EnableRegexInPath: true || false,
795
795
  * },
796
+ * AWSManagedRulesAntiDDoSRuleSet: { // AWSManagedRulesAntiDDoSRuleSet
797
+ * ClientSideActionConfig: { // ClientSideActionConfig
798
+ * Challenge: { // ClientSideAction
799
+ * UsageOfAction: "ENABLED" || "DISABLED", // required
800
+ * Sensitivity: "LOW" || "MEDIUM" || "HIGH",
801
+ * ExemptUriRegularExpressions: [ // RegularExpressionList
802
+ * { // Regex
803
+ * RegexString: "STRING_VALUE",
804
+ * },
805
+ * ],
806
+ * },
807
+ * },
808
+ * SensitivityToBlock: "LOW" || "MEDIUM" || "HIGH",
809
+ * },
796
810
  * },
797
811
  * ],
798
812
  * RuleActionOverrides: [
@@ -1010,6 +1024,20 @@ declare const UpdateWebACLCommand_base: {
1010
1024
  * },
1011
1025
  * EnableRegexInPath: true || false,
1012
1026
  * },
1027
+ * AWSManagedRulesAntiDDoSRuleSet: {
1028
+ * ClientSideActionConfig: {
1029
+ * Challenge: {
1030
+ * UsageOfAction: "ENABLED" || "DISABLED", // required
1031
+ * Sensitivity: "LOW" || "MEDIUM" || "HIGH",
1032
+ * ExemptUriRegularExpressions: [
1033
+ * {
1034
+ * RegexString: "STRING_VALUE",
1035
+ * },
1036
+ * ],
1037
+ * },
1038
+ * },
1039
+ * SensitivityToBlock: "LOW" || "MEDIUM" || "HIGH",
1040
+ * },
1013
1041
  * },
1014
1042
  * ],
1015
1043
  * RuleActionOverrides: [
@@ -1121,6 +1149,9 @@ declare const UpdateWebACLCommand_base: {
1121
1149
  * },
1122
1150
  * },
1123
1151
  * },
1152
+ * OnSourceDDoSProtectionConfig: { // OnSourceDDoSProtectionConfig
1153
+ * ALBLowReputationMode: "ACTIVE_UNDER_DDOS" || "ALWAYS_ON", // required
1154
+ * },
1124
1155
  * };
1125
1156
  * const command = new UpdateWebACLCommand(input);
1126
1157
  * const response = await client.send(command);
package/dist-types/models/models_0.d.ts CHANGED
@@ -2068,6 +2068,10 @@ export interface ResponseInspection {
2068
2068
  }
2069
2069
  /**
2070
2070
  * <p>Details for your use of the account creation fraud prevention managed rule group, <code>AWSManagedRulesACFPRuleSet</code>. This configuration is used in <code>ManagedRuleGroupConfig</code>. </p>
2071
+ * <p>For additional information about this and the other intelligent threat mitigation rule groups,
2072
+ * see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/waf-managed-protections">Intelligent threat mitigation in WAF</a>
2073
+ * and <a href="https://docs.aws.amazon.com/waf/latest/developerguide/aws-managed-rule-groups-list">Amazon Web Services Managed Rules rule groups list</a>
2074
+ * in the <i>WAF Developer Guide</i>. </p>
2071
2075
  * @public
2072
2076
  */
2073
2077
  export interface AWSManagedRulesACFPRuleSet {
@@ -2123,6 +2127,185 @@ export interface AWSManagedRulesACFPRuleSet {
2123
2127
  */
2124
2128
  EnableRegexInPath?: boolean | undefined;
2125
2129
  }
2130
+ /**
2131
+ * <p>A single regular expression. This is used in a <a>RegexPatternSet</a> and
2132
+ * also in the configuration for the Amazon Web Services Managed Rules rule group <code>AWSManagedRulesAntiDDoSRuleSet</code>.</p>
2133
+ * @public
2134
+ */
2135
+ export interface Regex {
2136
+ /**
2137
+ * <p>The string representing the regular expression.</p>
2138
+ * @public
2139
+ */
2140
+ RegexString?: string | undefined;
2141
+ }
2142
+ /**
2143
+ * @public
2144
+ * @enum
2145
+ */
2146
+ export declare const SensitivityToAct: {
2147
+ readonly HIGH: "HIGH";
2148
+ readonly LOW: "LOW";
2149
+ readonly MEDIUM: "MEDIUM";
2150
+ };
2151
+ /**
2152
+ * @public
2153
+ */
2154
+ export type SensitivityToAct = (typeof SensitivityToAct)[keyof typeof SensitivityToAct];
2155
+ /**
2156
+ * @public
2157
+ * @enum
2158
+ */
2159
+ export declare const UsageOfAction: {
2160
+ readonly DISABLED: "DISABLED";
2161
+ readonly ENABLED: "ENABLED";
2162
+ };
2163
+ /**
2164
+ * @public
2165
+ */
2166
+ export type UsageOfAction = (typeof UsageOfAction)[keyof typeof UsageOfAction];
2167
+ /**
2168
+ * <p>This is part of the <code>AWSManagedRulesAntiDDoSRuleSet</code>
2169
+ * <code>ClientSideActionConfig</code> configuration in <code>ManagedRuleGroupConfig</code>.</p>
2170
+ * @public
2171
+ */
2172
+ export interface ClientSideAction {
2173
+ /**
2174
+ * <p>Determines whether to use the <code>AWSManagedRulesAntiDDoSRuleSet</code> rules <code>ChallengeAllDuringEvent</code> and <code>ChallengeDDoSRequests</code> in the rule group evaluation and the related label <code>awswaf:managed:aws:anti-ddos:challengeable-request</code>. </p>
2175
+ * <ul>
2176
+ * <li>
2177
+ * <p>If usage is enabled: </p>
2178
+ * <ul>
2179
+ * <li>
2180
+ * <p>The managed rule group adds the label <code>awswaf:managed:aws:anti-ddos:challengeable-request</code> to any web request whose URL does <i>NOT</i> match the regular expressions provided in the
2181
+ * <code>ClientSideAction</code> setting <code>ExemptUriRegularExpressions</code>. </p>
2182
+ * </li>
2183
+ * <li>
2184
+ * <p>The two rules are evaluated against web requests for protected resources that are experiencing a DDoS attack.
2185
+ * The two rules only apply their action to matching requests that have the label <code>awswaf:managed:aws:anti-ddos:challengeable-request</code>.
2186
+ * </p>
2187
+ * </li>
2188
+ * </ul>
2189
+ * </li>
2190
+ * <li>
2191
+ * <p>If usage is disabled: </p>
2192
+ * <ul>
2193
+ * <li>
2194
+ * <p>The managed rule group doesn't add the label <code>awswaf:managed:aws:anti-ddos:challengeable-request</code> to any web requests. </p>
2195
+ * </li>
2196
+ * <li>
2197
+ * <p>The two rules are not evaluated.</p>
2198
+ * </li>
2199
+ * <li>
2200
+ * <p>None of the other <code>ClientSideAction</code> settings have any effect.</p>
2201
+ * </li>
2202
+ * </ul>
2203
+ * </li>
2204
+ * </ul>
2205
+ * <note>
2206
+ * <p>This setting only enables or disables the use of the two anti-DDOS rules <code>ChallengeAllDuringEvent</code> and <code>ChallengeDDoSRequests</code> in the anti-DDoS managed rule group. </p>
2207
+ * <p>This setting doesn't alter the action setting in the two rules. To override the actions
2208
+ * used by the rules <code>ChallengeAllDuringEvent</code> and <code>ChallengeDDoSRequests</code>,
2209
+ * enable this setting, and then override the rule actions in the usual way, in your managed rule group configuration. </p>
2210
+ * </note>
2211
+ * @public
2212
+ */
2213
+ UsageOfAction: UsageOfAction | undefined;
2214
+ /**
2215
+ * <p>The sensitivity that the rule group rule <code>ChallengeDDoSRequests</code> uses when matching against the
2216
+ * DDoS suspicion labeling on a request. The managed rule group adds the labeling during DDoS events, before the <code>ChallengeDDoSRequests</code> rule runs.
2217
+ * </p>
2218
+ * <p>The higher the sensitivity, the more levels of labeling that the rule matches: </p>
2219
+ * <ul>
2220
+ * <li>
2221
+ * <p>Low sensitivity is less sensitive, causing the rule to match only on the most likely participants in an attack, which are the requests with the high suspicion label <code>awswaf:managed:aws:anti-ddos:high-suspicion-ddos-request</code>.</p>
2222
+ * </li>
2223
+ * <li>
2224
+ * <p>Medium sensitivity causes the rule to match on the medium and high suspicion labels.</p>
2225
+ * </li>
2226
+ * <li>
2227
+ * <p>High sensitivity causes the rule to match on all of the suspicion labels: low, medium, and high.</p>
2228
+ * </li>
2229
+ * </ul>
2230
+ * <p>Default: <code>HIGH</code>
2231
+ * </p>
2232
+ * @public
2233
+ */
2234
+ Sensitivity?: SensitivityToAct | undefined;
2235
+ /**
2236
+ * <p>The regular expression to match against the web request URI, used to identify requests
2237
+ * that can't handle a silent browser challenge. When the <code>ClientSideAction</code> setting <code>UsageOfAction</code> is enabled,
2238
+ * the managed rule group uses this setting to determine which requests to label with
2239
+ * <code>awswaf:managed:aws:anti-ddos:challengeable-request</code>. If <code>UsageOfAction</code> is disabled, this setting
2240
+ * has no effect and the managed rule group doesn't add the label to any requests.</p>
2241
+ * <p>The anti-DDoS managed rule group doesn't
2242
+ * evaluate the rules <code>ChallengeDDoSRequests</code> or <code>ChallengeAllDuringEvent</code> for web requests whose URIs match this regex. This
2243
+ * is true regardless of whether you override the rule action for either of the rules in your web ACL configuration. </p>
2244
+ * <p>Amazon Web Services recommends using a regular expression. </p>
2245
+ * <p>This setting is required if <code>UsageOfAction</code> is set to <code>ENABLED</code>. If required, you can provide
2246
+ * between 1 and 5 regex objects in the array of settings. </p>
2247
+ * <p>Amazon Web Services recommends starting with the following setting. Review and update it for your application's needs:</p>
2248
+ * <p>
2249
+ * <code>\/api\/|\.(acc|avi|css|gif|jpe?g|js|mp[34]|ogg|otf|pdf|png|tiff?|ttf|webm|webp|woff2?)$</code>
2250
+ * </p>
2251
+ * @public
2252
+ */
2253
+ ExemptUriRegularExpressions?: Regex[] | undefined;
2254
+ }
2255
+ /**
2256
+ * <p>This is part of the configuration for the managed rules <code>AWSManagedRulesAntiDDoSRuleSet</code>
2257
+ * in <code>ManagedRuleGroupConfig</code>.</p>
2258
+ * @public
2259
+ */
2260
+ export interface ClientSideActionConfig {
2261
+ /**
2262
+ * <p>Configuration for the use of the <code>AWSManagedRulesAntiDDoSRuleSet</code> rules <code>ChallengeAllDuringEvent</code> and <code>ChallengeDDoSRequests</code>. </p>
2263
+ * <note>
2264
+ * <p>This setting isn't related to the configuration of the <code>Challenge</code> action itself. It only
2265
+ * configures the use of the two anti-DDoS rules named here. </p>
2266
+ * </note>
2267
+ * <p>You can enable or disable the use of these rules, and you can configure how to use them when they are enabled. </p>
2268
+ * @public
2269
+ */
2270
+ Challenge: ClientSideAction | undefined;
2271
+ }
2272
+ /**
2273
+ * <p>Configures the use of the anti-DDoS managed rule group, <code>AWSManagedRulesAntiDDoSRuleSet</code>. This configuration is used in <code>ManagedRuleGroupConfig</code>. </p>
2274
+ * <p>The configuration that you provide here determines whether and how the rules in the rule group are used. </p>
2275
+ * <p>For additional information about this and the other intelligent threat mitigation rule groups,
2276
+ * see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/waf-managed-protections">Intelligent threat mitigation in WAF</a>
2277
+ * and <a href="https://docs.aws.amazon.com/waf/latest/developerguide/aws-managed-rule-groups-list">Amazon Web Services Managed Rules rule groups list</a>
2278
+ * in the <i>WAF Developer Guide</i>. </p>
2279
+ * @public
2280
+ */
2281
+ export interface AWSManagedRulesAntiDDoSRuleSet {
2282
+ /**
2283
+ * <p>Configures the request handling that's applied by the managed rule group rules <code>ChallengeAllDuringEvent</code> and <code>ChallengeDDoSRequests</code> during a distributed denial of service (DDoS) attack.</p>
2284
+ * @public
2285
+ */
2286
+ ClientSideActionConfig: ClientSideActionConfig | undefined;
2287
+ /**
2288
+ * <p>The sensitivity that the rule group rule <code>DDoSRequests</code> uses when matching against the
2289
+ * DDoS suspicion labeling on a request. The managed rule group adds the labeling during DDoS events, before the <code>DDoSRequests</code> rule runs.
2290
+ * </p>
2291
+ * <p>The higher the sensitivity, the more levels of labeling that the rule matches: </p>
2292
+ * <ul>
2293
+ * <li>
2294
+ * <p>Low sensitivity is less sensitive, causing the rule to match only on the most likely participants in an attack, which are the requests with the high suspicion label <code>awswaf:managed:aws:anti-ddos:high-suspicion-ddos-request</code>.</p>
2295
+ * </li>
2296
+ * <li>
2297
+ * <p>Medium sensitivity causes the rule to match on the medium and high suspicion labels.</p>
2298
+ * </li>
2299
+ * <li>
2300
+ * <p>High sensitivity causes the rule to match on all of the suspicion labels: low, medium, and high.</p>
2301
+ * </li>
2302
+ * </ul>
2303
+ * <p>Default: <code>LOW</code>
2304
+ * </p>
2305
+ * @public
2306
+ */
2307
+ SensitivityToBlock?: SensitivityToAct | undefined;
2308
+ }
2126
2309
  /**
2127
2310
  * <p>The criteria for inspecting login requests, used by the ATP rule group to validate credentials usage. </p>
2128
2311
  * <p>This is part of the <code>AWSManagedRulesATPRuleSet</code> configuration in <code>ManagedRuleGroupConfig</code>.</p>
@@ -2186,6 +2369,10 @@ export interface RequestInspection {
2186
2369
  }
2187
2370
  /**
2188
2371
  * <p>Details for your use of the account takeover prevention managed rule group, <code>AWSManagedRulesATPRuleSet</code>. This configuration is used in <code>ManagedRuleGroupConfig</code>. </p>
2372
+ * <p>For additional information about this and the other intelligent threat mitigation rule groups,
2373
+ * see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/waf-managed-protections">Intelligent threat mitigation in WAF</a>
2374
+ * and <a href="https://docs.aws.amazon.com/waf/latest/developerguide/aws-managed-rule-groups-list">Amazon Web Services Managed Rules rule groups list</a>
2375
+ * in the <i>WAF Developer Guide</i>. </p>
2189
2376
  * @public
2190
2377
  */
2191
2378
  export interface AWSManagedRulesATPRuleSet {
@@ -2232,6 +2419,10 @@ export declare const InspectionLevel: {
2232
2419
  export type InspectionLevel = (typeof InspectionLevel)[keyof typeof InspectionLevel];
2233
2420
  /**
2234
2421
  * <p>Details for your use of the Bot Control managed rule group, <code>AWSManagedRulesBotControlRuleSet</code>. This configuration is used in <code>ManagedRuleGroupConfig</code>. </p>
2422
+ * <p>For additional information about this and the other intelligent threat mitigation rule groups,
2423
+ * see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/waf-managed-protections">Intelligent threat mitigation in WAF</a>
2424
+ * and <a href="https://docs.aws.amazon.com/waf/latest/developerguide/aws-managed-rule-groups-list">Amazon Web Services Managed Rules rule groups list</a>
2425
+ * in the <i>WAF Developer Guide</i>. </p>
2235
2426
  * @public
2236
2427
  */
2237
2428
  export interface AWSManagedRulesBotControlRuleSet {
@@ -2264,6 +2455,9 @@ export interface AWSManagedRulesBotControlRuleSet {
2264
2455
  * <p>Use the <code>AWSManagedRulesACFPRuleSet</code> configuration object to configure the account creation fraud prevention managed rule group. The configuration includes the registration and sign-up pages of your application and the locations in the account creation request payload of data, such as the user email and phone number fields. </p>
2265
2456
  * </li>
2266
2457
  * <li>
2458
+ * <p>Use the <code>AWSManagedRulesAntiDDoSRuleSet</code> configuration object to configure the anti-DDoS managed rule group. The configuration includes the sensitivity levels to use in the rules that typically block and challenge requests that might be participating in DDoS attacks and the specification to use to indicate whether a request can handle a silent browser challenge. </p>
2459
+ * </li>
2460
+ * <li>
2267
2461
  * <p>Use the <code>AWSManagedRulesATPRuleSet</code> configuration object to configure the account takeover prevention managed rule group. The configuration includes the sign-in page of your application and the locations in the login request payload of data such as the username and password. </p>
2268
2462
  * </li>
2269
2463
  * <li>
@@ -2343,6 +2537,16 @@ export interface ManagedRuleGroupConfig {
2343
2537
  * @public
2344
2538
  */
2345
2539
  AWSManagedRulesACFPRuleSet?: AWSManagedRulesACFPRuleSet | undefined;
2540
+ /**
2541
+ * <p>Additional configuration for using the anti-DDoS managed rule group, <code>AWSManagedRulesAntiDDoSRuleSet</code>.
2542
+ * Use this to configure anti-DDoS behavior for the rule group. </p>
2543
+ * <p>For information
2544
+ * about using the anti-DDoS managed rule group, see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/aws-managed-rule-groups-anti-ddos.html">WAF Anti-DDoS rule group</a>
2545
+ * and <a href="https://docs.aws.amazon.com/waf/latest/developerguide/waf-anti-ddos.html">Distributed Denial of Service (DDoS) prevention</a>
2546
+ * in the <i>WAF Developer Guide</i>.</p>
2547
+ * @public
2548
+ */
2549
+ AWSManagedRulesAntiDDoSRuleSet?: AWSManagedRulesAntiDDoSRuleSet | undefined;
2346
2550
  }
2347
2551
  /**
2348
2552
  * <p>A custom response to send to the client. You can define a custom response for rule
@@ -2899,7 +3103,7 @@ export interface RuleGroupReferenceStatement {
2899
3103
  /**
2900
3104
  * <p>Action settings to use in the place of the rule actions that are configured inside the rule group. You specify one override for each rule whose action you want to change. </p>
2901
3105
  * <note>
2902
- * <p>Take care to verify the rule names in your overrides. If you provide a rule name that doesn't match the name of any rule in the rule group, WAF doesn't return an error and doesn't apply the override setting.</p>
3106
+ * <p>Verify the rule names in your overrides carefully. With managed rule groups, WAF silently ignores any override that uses an invalid rule name. With customer-owned rule groups, invalid rule names in your overrides will cause web ACL updates to fail. An invalid rule name is any name that doesn't exactly match the case-sensitive name of an existing rule in the rule group.</p>
2903
3107
  * </note>
2904
3108
  * <p>You can use overrides for testing, for example you can override all of rule actions to <code>Count</code> and then monitor the resulting count metrics to understand how the rule group would handle your web traffic. You can also permanently override some or all actions, to modify how the rule group manages your web traffic.</p>
2905
3109
  * @public
@@ -3183,6 +3387,7 @@ export declare const ParameterExceptionField: {
3183
3387
  readonly LABEL_MATCH_STATEMENT: "LABEL_MATCH_STATEMENT";
3184
3388
  readonly LOGGING_FILTER: "LOGGING_FILTER";
3185
3389
  readonly LOG_DESTINATION: "LOG_DESTINATION";
3390
+ readonly LOW_REPUTATION_MODE: "LOW_REPUTATION_MODE";
3186
3391
  readonly MANAGED_RULE_GROUP_CONFIG: "MANAGED_RULE_GROUP_CONFIG";
3187
3392
  readonly MANAGED_RULE_SET: "MANAGED_RULE_SET";
3188
3393
  readonly MANAGED_RULE_SET_STATEMENT: "MANAGED_RULE_SET_STATEMENT";
@@ -3828,17 +4033,6 @@ export declare class WAFTagOperationInternalErrorException extends __BaseExcepti
3828
4033
  */
3829
4034
  constructor(opts: __ExceptionOptionType<WAFTagOperationInternalErrorException, __BaseException>);
3830
4035
  }
3831
- /**
3832
- * <p>A single regular expression. This is used in a <a>RegexPatternSet</a>.</p>
3833
- * @public
3834
- */
3835
- export interface Regex {
3836
- /**
3837
- * <p>The string representing the regular expression.</p>
3838
- * @public
3839
- */
3840
- RegexString?: string | undefined;
3841
- }
3842
4036
  /**
3843
4037
  * @public
3844
4038
  */
@@ -4118,6 +4312,31 @@ export interface DefaultAction {
4118
4312
  */
4119
4313
  Allow?: AllowAction | undefined;
4120
4314
  }
4315
+ /**
4316
+ * @public
4317
+ * @enum
4318
+ */
4319
+ export declare const LowReputationMode: {
4320
+ readonly ACTIVE_UNDER_DDOS: "ACTIVE_UNDER_DDOS";
4321
+ readonly ALWAYS_ON: "ALWAYS_ON";
4322
+ };
4323
+ /**
4324
+ * @public
4325
+ */
4326
+ export type LowReputationMode = (typeof LowReputationMode)[keyof typeof LowReputationMode];
4327
+ /**
4328
+ * <p>Configures the level of DDoS protection that applies to web ACLs associated with Application Load Balancers.</p>
4329
+ * @public
4330
+ */
4331
+ export interface OnSourceDDoSProtectionConfig {
4332
+ /**
4333
+ * <p>The level of DDoS protection that applies to web ACLs associated with Application Load Balancers. <code>ACTIVE_UNDER_DDOS</code> protection is enabled by default whenever a web ACL is associated with an Application Load Balancer.
4334
+ * In the event that an Application Load Balancer experiences high-load conditions or suspected DDoS attacks, the <code>ACTIVE_UNDER_DDOS</code> protection automatically rate limits traffic from known low reputation sources without disrupting Application Load Balancer availability.
4335
+ * <code>ALWAYS_ON</code> protection provides constant, always-on monitoring of known low reputation sources for suspected DDoS attacks. While this provides a higher level of protection, there may be potential impacts on legitimate traffic.</p>
4336
+ * @public
4337
+ */
4338
+ ALBLowReputationMode: LowReputationMode | undefined;
4339
+ }
4121
4340
  /**
4122
4341
  * <p>High-level information about a <a>WebACL</a>, returned by operations like create and list. This provides information like the ID, that you can use to retrieve and manage a <code>WebACL</code>, and the ARN, that you provide to operations like <a>AssociateWebACL</a>.</p>
4123
4342
  * @public
@@ -7539,6 +7758,9 @@ export interface ManagedRuleGroupStatement {
7539
7758
  * <p>Use the <code>AWSManagedRulesACFPRuleSet</code> configuration object to configure the account creation fraud prevention managed rule group. The configuration includes the registration and sign-up pages of your application and the locations in the account creation request payload of data, such as the user email and phone number fields. </p>
7540
7759
  * </li>
7541
7760
  * <li>
7761
+ * <p>Use the <code>AWSManagedRulesAntiDDoSRuleSet</code> configuration object to configure the anti-DDoS managed rule group. The configuration includes the sensitivity levels to use in the rules that typically block and challenge requests that might be participating in DDoS attacks and the specification to use to indicate whether a request can handle a silent browser challenge. </p>
7762
+ * </li>
7763
+ * <li>
7542
7764
  * <p>Use the <code>AWSManagedRulesATPRuleSet</code> configuration object to configure the account takeover prevention managed rule group. The configuration includes the sign-in page of your application and the locations in the login request payload of data such as the username and password. </p>
7543
7765
  * </li>
7544
7766
  * <li>
@@ -7552,7 +7774,7 @@ export interface ManagedRuleGroupStatement {
7552
7774
  /**
7553
7775
  * <p>Action settings to use in the place of the rule actions that are configured inside the rule group. You specify one override for each rule whose action you want to change. </p>
7554
7776
  * <note>
7555
- * <p>Take care to verify the rule names in your overrides. If you provide a rule name that doesn't match the name of any rule in the rule group, WAF doesn't return an error and doesn't apply the override setting.</p>
7777
+ * <p>Verify the rule names in your overrides carefully. With managed rule groups, WAF silently ignores any override that uses an invalid rule name. With customer-owned rule groups, invalid rule names in your overrides will cause web ACL updates to fail. An invalid rule name is any name that doesn't exactly match the case-sensitive name of an existing rule in the rule group.</p>
7556
7778
  * </note>
7557
7779
  * <p>You can use overrides for testing, for example you can override all of rule actions to <code>Count</code> and then monitor the resulting count metrics to understand how the rule group would handle your web traffic. You can also permanently override some or all actions, to modify how the rule group manages your web traffic.</p>
7558
7780
  * @public
@@ -8113,6 +8335,12 @@ export interface CreateWebACLRequest {
8113
8335
  * @public
8114
8336
  */
8115
8337
  AssociationConfig?: AssociationConfig | undefined;
8338
+ /**
8339
+ * <p>Specifies the type of DDoS protection to apply to web request data for a web ACL. For most scenarios, it is recommended to use the default protection level, <code>ACTIVE_UNDER_DDOS</code>.
8340
+ * If a web ACL is associated with multiple Application Load Balancers, the changes you make to DDoS protection in that web ACL will apply to all associated Application Load Balancers.</p>
8341
+ * @public
8342
+ */
8343
+ OnSourceDDoSProtectionConfig?: OnSourceDDoSProtectionConfig | undefined;
8116
8344
  }
8117
8345
  /**
8118
8346
  * <p> A rule group defines a collection of rules to inspect and control web requests that you can use in a <a>WebACL</a>. When you create a rule group, you define an immutable capacity limit. If you update a rule group, you must stay within the capacity. This allows others to reuse the rule group with confidence in its capacity requirements. </p>
@@ -8373,6 +8601,12 @@ export interface UpdateWebACLRequest {
8373
8601
  * @public
8374
8602
  */
8375
8603
  AssociationConfig?: AssociationConfig | undefined;
8604
+ /**
8605
+ * <p>Specifies the type of DDoS protection to apply to web request data for a web ACL. For most scenarios, it is recommended to use the default protection level, <code>ACTIVE_UNDER_DDOS</code>.
8606
+ * If a web ACL is associated with multiple Application Load Balancers, the changes you make to DDoS protection in that web ACL will apply to all associated Application Load Balancers.</p>
8607
+ * @public
8608
+ */
8609
+ OnSourceDDoSProtectionConfig?: OnSourceDDoSProtectionConfig | undefined;
8376
8610
  }
8377
8611
  /**
8378
8612
  * @public
@@ -8547,6 +8781,11 @@ export interface WebACL {
8547
8781
  * @public
8548
8782
  */
8549
8783
  RetrofittedByFirewallManager?: boolean | undefined;
8784
+ /**
8785
+ * <p>Configures the level of DDoS protection that applies to web ACLs associated with Application Load Balancers.</p>
8786
+ * @public
8787
+ */
8788
+ OnSourceDDoSProtectionConfig?: OnSourceDDoSProtectionConfig | undefined;
8550
8789
  }
8551
8790
  /**
8552
8791
  * @public
package/dist-types/ts3.4/models/models_0.d.ts CHANGED
@@ -524,6 +524,33 @@ export interface AWSManagedRulesACFPRuleSet {
524
524
  ResponseInspection?: ResponseInspection | undefined;
525
525
  EnableRegexInPath?: boolean | undefined;
526
526
  }
527
+ export interface Regex {
528
+ RegexString?: string | undefined;
529
+ }
530
+ export declare const SensitivityToAct: {
531
+ readonly HIGH: "HIGH";
532
+ readonly LOW: "LOW";
533
+ readonly MEDIUM: "MEDIUM";
534
+ };
535
+ export type SensitivityToAct =
536
+ (typeof SensitivityToAct)[keyof typeof SensitivityToAct];
537
+ export declare const UsageOfAction: {
538
+ readonly DISABLED: "DISABLED";
539
+ readonly ENABLED: "ENABLED";
540
+ };
541
+ export type UsageOfAction = (typeof UsageOfAction)[keyof typeof UsageOfAction];
542
+ export interface ClientSideAction {
543
+ UsageOfAction: UsageOfAction | undefined;
544
+ Sensitivity?: SensitivityToAct | undefined;
545
+ ExemptUriRegularExpressions?: Regex[] | undefined;
546
+ }
547
+ export interface ClientSideActionConfig {
548
+ Challenge: ClientSideAction | undefined;
549
+ }
550
+ export interface AWSManagedRulesAntiDDoSRuleSet {
551
+ ClientSideActionConfig: ClientSideActionConfig | undefined;
552
+ SensitivityToBlock?: SensitivityToAct | undefined;
553
+ }
527
554
  export interface RequestInspection {
528
555
  PayloadType: PayloadType | undefined;
529
556
  UsernameField: UsernameField | undefined;
@@ -555,6 +582,7 @@ export interface ManagedRuleGroupConfig {
555
582
  | undefined;
556
583
  AWSManagedRulesATPRuleSet?: AWSManagedRulesATPRuleSet | undefined;
557
584
  AWSManagedRulesACFPRuleSet?: AWSManagedRulesACFPRuleSet | undefined;
585
+ AWSManagedRulesAntiDDoSRuleSet?: AWSManagedRulesAntiDDoSRuleSet | undefined;
558
586
  }
559
587
  export interface CustomResponse {
560
588
  ResponseCode: number | undefined;
@@ -757,6 +785,7 @@ export declare const ParameterExceptionField: {
757
785
  readonly LABEL_MATCH_STATEMENT: "LABEL_MATCH_STATEMENT";
758
786
  readonly LOGGING_FILTER: "LOGGING_FILTER";
759
787
  readonly LOG_DESTINATION: "LOG_DESTINATION";
788
+ readonly LOW_REPUTATION_MODE: "LOW_REPUTATION_MODE";
760
789
  readonly MANAGED_RULE_GROUP_CONFIG: "MANAGED_RULE_GROUP_CONFIG";
761
790
  readonly MANAGED_RULE_SET: "MANAGED_RULE_SET";
762
791
  readonly MANAGED_RULE_SET_STATEMENT: "MANAGED_RULE_SET_STATEMENT";
@@ -977,9 +1006,6 @@ export declare class WAFTagOperationInternalErrorException extends __BaseExcepti
977
1006
  >
978
1007
  );
979
1008
  }
980
- export interface Regex {
981
- RegexString?: string | undefined;
982
- }
983
1009
  export interface CreateRegexPatternSetRequest {
984
1010
  Name: string | undefined;
985
1011
  Scope: Scope | undefined;
@@ -1050,6 +1076,15 @@ export interface DefaultAction {
1050
1076
  Block?: BlockAction | undefined;
1051
1077
  Allow?: AllowAction | undefined;
1052
1078
  }
1079
+ export declare const LowReputationMode: {
1080
+ readonly ACTIVE_UNDER_DDOS: "ACTIVE_UNDER_DDOS";
1081
+ readonly ALWAYS_ON: "ALWAYS_ON";
1082
+ };
1083
+ export type LowReputationMode =
1084
+ (typeof LowReputationMode)[keyof typeof LowReputationMode];
1085
+ export interface OnSourceDDoSProtectionConfig {
1086
+ ALBLowReputationMode: LowReputationMode | undefined;
1087
+ }
1053
1088
  export interface WebACLSummary {
1054
1089
  Name?: string | undefined;
1055
1090
  Id?: string | undefined;
@@ -1782,6 +1817,7 @@ export interface CreateWebACLRequest {
1782
1817
  ChallengeConfig?: ChallengeConfig | undefined;
1783
1818
  TokenDomains?: string[] | undefined;
1784
1819
  AssociationConfig?: AssociationConfig | undefined;
1820
+ OnSourceDDoSProtectionConfig?: OnSourceDDoSProtectionConfig | undefined;
1785
1821
  }
1786
1822
  export interface RuleGroup {
1787
1823
  Name: string | undefined;
@@ -1821,6 +1857,7 @@ export interface UpdateWebACLRequest {
1821
1857
  ChallengeConfig?: ChallengeConfig | undefined;
1822
1858
  TokenDomains?: string[] | undefined;
1823
1859
  AssociationConfig?: AssociationConfig | undefined;
1860
+ OnSourceDDoSProtectionConfig?: OnSourceDDoSProtectionConfig | undefined;
1824
1861
  }
1825
1862
  export interface GetRuleGroupResponse {
1826
1863
  RuleGroup?: RuleGroup | undefined;
@@ -1846,6 +1883,7 @@ export interface WebACL {
1846
1883
  TokenDomains?: string[] | undefined;
1847
1884
  AssociationConfig?: AssociationConfig | undefined;
1848
1885
  RetrofittedByFirewallManager?: boolean | undefined;
1886
+ OnSourceDDoSProtectionConfig?: OnSourceDDoSProtectionConfig | undefined;
1849
1887
  }
1850
1888
  export interface GetWebACLForResourceResponse {
1851
1889
  WebACL?: WebACL | undefined;
package/package.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "@aws-sdk/client-wafv2",
3
3
  "description": "AWS SDK for JavaScript Wafv2 Client for Node.js, Browser and React Native",
4
- "version": "3.826.0",
4
+ "version": "3.828.0",
5
5
  "scripts": {
6
6
  "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
7
7
  "build:cjs": "node ../../scripts/compilation/inline client-wafv2",
@@ -21,16 +21,16 @@
21
21
  "@aws-crypto/sha256-browser": "5.2.0",
22
22
  "@aws-crypto/sha256-js": "5.2.0",
23
23
  "@aws-sdk/core": "3.826.0",
24
- "@aws-sdk/credential-provider-node": "3.826.0",
24
+ "@aws-sdk/credential-provider-node": "3.828.0",
25
25
  "@aws-sdk/middleware-host-header": "3.821.0",
26
26
  "@aws-sdk/middleware-logger": "3.821.0",
27
27
  "@aws-sdk/middleware-recursion-detection": "3.821.0",
28
- "@aws-sdk/middleware-user-agent": "3.826.0",
28
+ "@aws-sdk/middleware-user-agent": "3.828.0",
29
29
  "@aws-sdk/region-config-resolver": "3.821.0",
30
30
  "@aws-sdk/types": "3.821.0",
31
- "@aws-sdk/util-endpoints": "3.821.0",
31
+ "@aws-sdk/util-endpoints": "3.828.0",
32
32
  "@aws-sdk/util-user-agent-browser": "3.821.0",
33
- "@aws-sdk/util-user-agent-node": "3.826.0",
33
+ "@aws-sdk/util-user-agent-node": "3.828.0",
34
34
  "@smithy/config-resolver": "^4.1.4",
35
35
  "@smithy/core": "^3.5.3",
36
36
  "@smithy/fetch-http-handler": "^5.0.4",