aws-sdk-wafv2 1.18.0 → 1.19.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.
- checksums.yaml +4 -4
- data/CHANGELOG.md +5 -0
- data/VERSION +1 -1
- data/lib/aws-sdk-wafv2.rb +1 -1
- data/lib/aws-sdk-wafv2/client.rb +405 -9
- data/lib/aws-sdk-wafv2/client_api.rb +43 -0
- data/lib/aws-sdk-wafv2/types.rb +785 -45
- metadata +4 -4
| @@ -42,6 +42,14 @@ module Aws::WAFV2 | |
| 42 42 | 
             
                CreateRuleGroupResponse = Shapes::StructureShape.new(name: 'CreateRuleGroupResponse')
         | 
| 43 43 | 
             
                CreateWebACLRequest = Shapes::StructureShape.new(name: 'CreateWebACLRequest')
         | 
| 44 44 | 
             
                CreateWebACLResponse = Shapes::StructureShape.new(name: 'CreateWebACLResponse')
         | 
| 45 | 
            +
                CustomHTTPHeader = Shapes::StructureShape.new(name: 'CustomHTTPHeader')
         | 
| 46 | 
            +
                CustomHTTPHeaderName = Shapes::StringShape.new(name: 'CustomHTTPHeaderName')
         | 
| 47 | 
            +
                CustomHTTPHeaderValue = Shapes::StringShape.new(name: 'CustomHTTPHeaderValue')
         | 
| 48 | 
            +
                CustomHTTPHeaders = Shapes::ListShape.new(name: 'CustomHTTPHeaders')
         | 
| 49 | 
            +
                CustomRequestHandling = Shapes::StructureShape.new(name: 'CustomRequestHandling')
         | 
| 50 | 
            +
                CustomResponse = Shapes::StructureShape.new(name: 'CustomResponse')
         | 
| 51 | 
            +
                CustomResponseBodies = Shapes::MapShape.new(name: 'CustomResponseBodies')
         | 
| 52 | 
            +
                CustomResponseBody = Shapes::StructureShape.new(name: 'CustomResponseBody')
         | 
| 45 53 | 
             
                DefaultAction = Shapes::StructureShape.new(name: 'DefaultAction')
         | 
| 46 54 | 
             
                DeleteFirewallManagerRuleGroupsRequest = Shapes::StructureShape.new(name: 'DeleteFirewallManagerRuleGroupsRequest')
         | 
| 47 55 | 
             
                DeleteFirewallManagerRuleGroupsResponse = Shapes::StructureShape.new(name: 'DeleteFirewallManagerRuleGroupsResponse')
         | 
| @@ -174,6 +182,9 @@ module Aws::WAFV2 | |
| 174 182 | 
             
                ResourceArn = Shapes::StringShape.new(name: 'ResourceArn')
         | 
| 175 183 | 
             
                ResourceArns = Shapes::ListShape.new(name: 'ResourceArns')
         | 
| 176 184 | 
             
                ResourceType = Shapes::StringShape.new(name: 'ResourceType')
         | 
| 185 | 
            +
                ResponseContent = Shapes::StringShape.new(name: 'ResponseContent')
         | 
| 186 | 
            +
                ResponseContentType = Shapes::StringShape.new(name: 'ResponseContentType')
         | 
| 187 | 
            +
                ResponseStatusCode = Shapes::IntegerShape.new(name: 'ResponseStatusCode')
         | 
| 177 188 | 
             
                Rule = Shapes::StructureShape.new(name: 'Rule')
         | 
| 178 189 | 
             
                RuleAction = Shapes::StructureShape.new(name: 'RuleAction')
         | 
| 179 190 | 
             
                RuleGroup = Shapes::StructureShape.new(name: 'RuleGroup')
         | 
| @@ -248,6 +259,7 @@ module Aws::WAFV2 | |
| 248 259 |  | 
| 249 260 | 
             
                AllQueryArguments.struct_class = Types::AllQueryArguments
         | 
| 250 261 |  | 
| 262 | 
            +
                AllowAction.add_member(:custom_request_handling, Shapes::ShapeRef.new(shape: CustomRequestHandling, location_name: "CustomRequestHandling"))
         | 
| 251 263 | 
             
                AllowAction.struct_class = Types::AllowAction
         | 
| 252 264 |  | 
| 253 265 | 
             
                AndStatement.add_member(:statements, Shapes::ShapeRef.new(shape: Statements, required: true, location_name: "Statements"))
         | 
| @@ -259,6 +271,7 @@ module Aws::WAFV2 | |
| 259 271 |  | 
| 260 272 | 
             
                AssociateWebACLResponse.struct_class = Types::AssociateWebACLResponse
         | 
| 261 273 |  | 
| 274 | 
            +
                BlockAction.add_member(:custom_response, Shapes::ShapeRef.new(shape: CustomResponse, location_name: "CustomResponse"))
         | 
| 262 275 | 
             
                BlockAction.struct_class = Types::BlockAction
         | 
| 263 276 |  | 
| 264 277 | 
             
                Body.struct_class = Types::Body
         | 
| @@ -276,6 +289,7 @@ module Aws::WAFV2 | |
| 276 289 | 
             
                CheckCapacityResponse.add_member(:capacity, Shapes::ShapeRef.new(shape: ConsumedCapacity, location_name: "Capacity"))
         | 
| 277 290 | 
             
                CheckCapacityResponse.struct_class = Types::CheckCapacityResponse
         | 
| 278 291 |  | 
| 292 | 
            +
                CountAction.add_member(:custom_request_handling, Shapes::ShapeRef.new(shape: CustomRequestHandling, location_name: "CustomRequestHandling"))
         | 
| 279 293 | 
             
                CountAction.struct_class = Types::CountAction
         | 
| 280 294 |  | 
| 281 295 | 
             
                CountryCodes.member = Shapes::ShapeRef.new(shape: CountryCode)
         | 
| @@ -308,6 +322,7 @@ module Aws::WAFV2 | |
| 308 322 | 
             
                CreateRuleGroupRequest.add_member(:rules, Shapes::ShapeRef.new(shape: Rules, location_name: "Rules"))
         | 
| 309 323 | 
             
                CreateRuleGroupRequest.add_member(:visibility_config, Shapes::ShapeRef.new(shape: VisibilityConfig, required: true, location_name: "VisibilityConfig"))
         | 
| 310 324 | 
             
                CreateRuleGroupRequest.add_member(:tags, Shapes::ShapeRef.new(shape: TagList, location_name: "Tags"))
         | 
| 325 | 
            +
                CreateRuleGroupRequest.add_member(:custom_response_bodies, Shapes::ShapeRef.new(shape: CustomResponseBodies, location_name: "CustomResponseBodies"))
         | 
| 311 326 | 
             
                CreateRuleGroupRequest.struct_class = Types::CreateRuleGroupRequest
         | 
| 312 327 |  | 
| 313 328 | 
             
                CreateRuleGroupResponse.add_member(:summary, Shapes::ShapeRef.new(shape: RuleGroupSummary, location_name: "Summary"))
         | 
| @@ -320,11 +335,33 @@ module Aws::WAFV2 | |
| 320 335 | 
             
                CreateWebACLRequest.add_member(:rules, Shapes::ShapeRef.new(shape: Rules, location_name: "Rules"))
         | 
| 321 336 | 
             
                CreateWebACLRequest.add_member(:visibility_config, Shapes::ShapeRef.new(shape: VisibilityConfig, required: true, location_name: "VisibilityConfig"))
         | 
| 322 337 | 
             
                CreateWebACLRequest.add_member(:tags, Shapes::ShapeRef.new(shape: TagList, location_name: "Tags"))
         | 
| 338 | 
            +
                CreateWebACLRequest.add_member(:custom_response_bodies, Shapes::ShapeRef.new(shape: CustomResponseBodies, location_name: "CustomResponseBodies"))
         | 
| 323 339 | 
             
                CreateWebACLRequest.struct_class = Types::CreateWebACLRequest
         | 
| 324 340 |  | 
| 325 341 | 
             
                CreateWebACLResponse.add_member(:summary, Shapes::ShapeRef.new(shape: WebACLSummary, location_name: "Summary"))
         | 
| 326 342 | 
             
                CreateWebACLResponse.struct_class = Types::CreateWebACLResponse
         | 
| 327 343 |  | 
| 344 | 
            +
                CustomHTTPHeader.add_member(:name, Shapes::ShapeRef.new(shape: CustomHTTPHeaderName, required: true, location_name: "Name"))
         | 
| 345 | 
            +
                CustomHTTPHeader.add_member(:value, Shapes::ShapeRef.new(shape: CustomHTTPHeaderValue, required: true, location_name: "Value"))
         | 
| 346 | 
            +
                CustomHTTPHeader.struct_class = Types::CustomHTTPHeader
         | 
| 347 | 
            +
             | 
| 348 | 
            +
                CustomHTTPHeaders.member = Shapes::ShapeRef.new(shape: CustomHTTPHeader)
         | 
| 349 | 
            +
             | 
| 350 | 
            +
                CustomRequestHandling.add_member(:insert_headers, Shapes::ShapeRef.new(shape: CustomHTTPHeaders, required: true, location_name: "InsertHeaders"))
         | 
| 351 | 
            +
                CustomRequestHandling.struct_class = Types::CustomRequestHandling
         | 
| 352 | 
            +
             | 
| 353 | 
            +
                CustomResponse.add_member(:response_code, Shapes::ShapeRef.new(shape: ResponseStatusCode, required: true, location_name: "ResponseCode"))
         | 
| 354 | 
            +
                CustomResponse.add_member(:custom_response_body_key, Shapes::ShapeRef.new(shape: EntityName, location_name: "CustomResponseBodyKey"))
         | 
| 355 | 
            +
                CustomResponse.add_member(:response_headers, Shapes::ShapeRef.new(shape: CustomHTTPHeaders, location_name: "ResponseHeaders"))
         | 
| 356 | 
            +
                CustomResponse.struct_class = Types::CustomResponse
         | 
| 357 | 
            +
             | 
| 358 | 
            +
                CustomResponseBodies.key = Shapes::ShapeRef.new(shape: EntityName)
         | 
| 359 | 
            +
                CustomResponseBodies.value = Shapes::ShapeRef.new(shape: CustomResponseBody)
         | 
| 360 | 
            +
             | 
| 361 | 
            +
                CustomResponseBody.add_member(:content_type, Shapes::ShapeRef.new(shape: ResponseContentType, required: true, location_name: "ContentType"))
         | 
| 362 | 
            +
                CustomResponseBody.add_member(:content, Shapes::ShapeRef.new(shape: ResponseContent, required: true, location_name: "Content"))
         | 
| 363 | 
            +
                CustomResponseBody.struct_class = Types::CustomResponseBody
         | 
| 364 | 
            +
             | 
| 328 365 | 
             
                DefaultAction.add_member(:block, Shapes::ShapeRef.new(shape: BlockAction, location_name: "Block"))
         | 
| 329 366 | 
             
                DefaultAction.add_member(:allow, Shapes::ShapeRef.new(shape: AllowAction, location_name: "Allow"))
         | 
| 330 367 | 
             
                DefaultAction.struct_class = Types::DefaultAction
         | 
| @@ -737,6 +774,7 @@ module Aws::WAFV2 | |
| 737 774 | 
             
                RuleGroup.add_member(:description, Shapes::ShapeRef.new(shape: EntityDescription, location_name: "Description"))
         | 
| 738 775 | 
             
                RuleGroup.add_member(:rules, Shapes::ShapeRef.new(shape: Rules, location_name: "Rules"))
         | 
| 739 776 | 
             
                RuleGroup.add_member(:visibility_config, Shapes::ShapeRef.new(shape: VisibilityConfig, required: true, location_name: "VisibilityConfig"))
         | 
| 777 | 
            +
                RuleGroup.add_member(:custom_response_bodies, Shapes::ShapeRef.new(shape: CustomResponseBodies, location_name: "CustomResponseBodies"))
         | 
| 740 778 | 
             
                RuleGroup.struct_class = Types::RuleGroup
         | 
| 741 779 |  | 
| 742 780 | 
             
                RuleGroupReferenceStatement.add_member(:arn, Shapes::ShapeRef.new(shape: ResourceArn, required: true, location_name: "ARN"))
         | 
| @@ -765,6 +803,8 @@ module Aws::WAFV2 | |
| 765 803 | 
             
                SampledHTTPRequest.add_member(:timestamp, Shapes::ShapeRef.new(shape: Timestamp, location_name: "Timestamp"))
         | 
| 766 804 | 
             
                SampledHTTPRequest.add_member(:action, Shapes::ShapeRef.new(shape: Action, location_name: "Action"))
         | 
| 767 805 | 
             
                SampledHTTPRequest.add_member(:rule_name_within_rule_group, Shapes::ShapeRef.new(shape: EntityName, location_name: "RuleNameWithinRuleGroup"))
         | 
| 806 | 
            +
                SampledHTTPRequest.add_member(:request_headers_inserted, Shapes::ShapeRef.new(shape: HTTPHeaders, location_name: "RequestHeadersInserted"))
         | 
| 807 | 
            +
                SampledHTTPRequest.add_member(:response_code_sent, Shapes::ShapeRef.new(shape: ResponseStatusCode, location_name: "ResponseCodeSent"))
         | 
| 768 808 | 
             
                SampledHTTPRequest.struct_class = Types::SampledHTTPRequest
         | 
| 769 809 |  | 
| 770 810 | 
             
                SampledHTTPRequests.member = Shapes::ShapeRef.new(shape: SampledHTTPRequest)
         | 
| @@ -865,6 +905,7 @@ module Aws::WAFV2 | |
| 865 905 | 
             
                UpdateRuleGroupRequest.add_member(:rules, Shapes::ShapeRef.new(shape: Rules, location_name: "Rules"))
         | 
| 866 906 | 
             
                UpdateRuleGroupRequest.add_member(:visibility_config, Shapes::ShapeRef.new(shape: VisibilityConfig, required: true, location_name: "VisibilityConfig"))
         | 
| 867 907 | 
             
                UpdateRuleGroupRequest.add_member(:lock_token, Shapes::ShapeRef.new(shape: LockToken, required: true, location_name: "LockToken"))
         | 
| 908 | 
            +
                UpdateRuleGroupRequest.add_member(:custom_response_bodies, Shapes::ShapeRef.new(shape: CustomResponseBodies, location_name: "CustomResponseBodies"))
         | 
| 868 909 | 
             
                UpdateRuleGroupRequest.struct_class = Types::UpdateRuleGroupRequest
         | 
| 869 910 |  | 
| 870 911 | 
             
                UpdateRuleGroupResponse.add_member(:next_lock_token, Shapes::ShapeRef.new(shape: LockToken, location_name: "NextLockToken"))
         | 
| @@ -878,6 +919,7 @@ module Aws::WAFV2 | |
| 878 919 | 
             
                UpdateWebACLRequest.add_member(:rules, Shapes::ShapeRef.new(shape: Rules, location_name: "Rules"))
         | 
| 879 920 | 
             
                UpdateWebACLRequest.add_member(:visibility_config, Shapes::ShapeRef.new(shape: VisibilityConfig, required: true, location_name: "VisibilityConfig"))
         | 
| 880 921 | 
             
                UpdateWebACLRequest.add_member(:lock_token, Shapes::ShapeRef.new(shape: LockToken, required: true, location_name: "LockToken"))
         | 
| 922 | 
            +
                UpdateWebACLRequest.add_member(:custom_response_bodies, Shapes::ShapeRef.new(shape: CustomResponseBodies, location_name: "CustomResponseBodies"))
         | 
| 881 923 | 
             
                UpdateWebACLRequest.struct_class = Types::UpdateWebACLRequest
         | 
| 882 924 |  | 
| 883 925 | 
             
                UpdateWebACLResponse.add_member(:next_lock_token, Shapes::ShapeRef.new(shape: LockToken, location_name: "NextLockToken"))
         | 
| @@ -949,6 +991,7 @@ module Aws::WAFV2 | |
| 949 991 | 
             
                WebACL.add_member(:pre_process_firewall_manager_rule_groups, Shapes::ShapeRef.new(shape: FirewallManagerRuleGroups, location_name: "PreProcessFirewallManagerRuleGroups"))
         | 
| 950 992 | 
             
                WebACL.add_member(:post_process_firewall_manager_rule_groups, Shapes::ShapeRef.new(shape: FirewallManagerRuleGroups, location_name: "PostProcessFirewallManagerRuleGroups"))
         | 
| 951 993 | 
             
                WebACL.add_member(:managed_by_firewall_manager, Shapes::ShapeRef.new(shape: Boolean, location_name: "ManagedByFirewallManager"))
         | 
| 994 | 
            +
                WebACL.add_member(:custom_response_bodies, Shapes::ShapeRef.new(shape: CustomResponseBodies, location_name: "CustomResponseBodies"))
         | 
| 952 995 | 
             
                WebACL.struct_class = Types::WebACL
         | 
| 953 996 |  | 
| 954 997 | 
             
                WebACLSummaries.member = Shapes::ShapeRef.new(shape: WebACLSummary)
         | 
    
        data/lib/aws-sdk-wafv2/types.rb
    CHANGED
    
    | @@ -34,16 +34,46 @@ module Aws::WAFV2 | |
| 34 34 | 
             
                #
         | 
| 35 35 | 
             
                class AllQueryArguments < Aws::EmptyStructure; end
         | 
| 36 36 |  | 
| 37 | 
            -
                # Specifies that AWS WAF should allow  | 
| 37 | 
            +
                # Specifies that AWS WAF should allow the request and optionally defines
         | 
| 38 | 
            +
                # additional custom handling for the request.
         | 
| 38 39 | 
             
                #
         | 
| 39 | 
            -
                # This is used  | 
| 40 | 
            -
                #  | 
| 40 | 
            +
                # This is used in the context of other settings, for example to specify
         | 
| 41 | 
            +
                # values for RuleAction and web ACL DefaultAction.
         | 
| 41 42 | 
             
                #
         | 
| 42 | 
            -
                # @ | 
| 43 | 
            +
                # @note When making an API call, you may pass AllowAction
         | 
| 44 | 
            +
                #   data as a hash:
         | 
| 45 | 
            +
                #
         | 
| 46 | 
            +
                #       {
         | 
| 47 | 
            +
                #         custom_request_handling: {
         | 
| 48 | 
            +
                #           insert_headers: [ # required
         | 
| 49 | 
            +
                #             {
         | 
| 50 | 
            +
                #               name: "CustomHTTPHeaderName", # required
         | 
| 51 | 
            +
                #               value: "CustomHTTPHeaderValue", # required
         | 
| 52 | 
            +
                #             },
         | 
| 53 | 
            +
                #           ],
         | 
| 54 | 
            +
                #         },
         | 
| 55 | 
            +
                #       }
         | 
| 56 | 
            +
                #
         | 
| 57 | 
            +
                # @!attribute [rw] custom_request_handling
         | 
| 58 | 
            +
                #   Defines custom handling for the web request.
         | 
| 59 | 
            +
                #
         | 
| 60 | 
            +
                #   For information about customizing web requests and responses, see
         | 
| 61 | 
            +
                #   [Customizing web requests and responses in AWS WAF][1] in the [AWS
         | 
| 62 | 
            +
                #   WAF Developer Guide][2].
         | 
| 63 | 
            +
                #
         | 
| 64 | 
            +
                #
         | 
| 65 | 
            +
                #
         | 
| 66 | 
            +
                #   [1]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-custom-request-response.html
         | 
| 67 | 
            +
                #   [2]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html
         | 
| 68 | 
            +
                #   @return [Types::CustomRequestHandling]
         | 
| 43 69 | 
             
                #
         | 
| 44 70 | 
             
                # @see http://docs.aws.amazon.com/goto/WebAPI/wafv2-2019-07-29/AllowAction AWS API Documentation
         | 
| 45 71 | 
             
                #
         | 
| 46 | 
            -
                class AllowAction <  | 
| 72 | 
            +
                class AllowAction < Struct.new(
         | 
| 73 | 
            +
                  :custom_request_handling)
         | 
| 74 | 
            +
                  SENSITIVE = []
         | 
| 75 | 
            +
                  include Aws::Structure
         | 
| 76 | 
            +
                end
         | 
| 47 77 |  | 
| 48 78 | 
             
                # A logical rule statement used to combine other rule statements with
         | 
| 49 79 | 
             
                # AND logic. You provide more than one Statement within the
         | 
| @@ -353,16 +383,48 @@ module Aws::WAFV2 | |
| 353 383 | 
             
                #
         | 
| 354 384 | 
             
                class AssociateWebACLResponse < Aws::EmptyStructure; end
         | 
| 355 385 |  | 
| 356 | 
            -
                # Specifies that AWS WAF should block  | 
| 386 | 
            +
                # Specifies that AWS WAF should block the request and optionally defines
         | 
| 387 | 
            +
                # additional custom handling for the response to the web request.
         | 
| 357 388 | 
             
                #
         | 
| 358 | 
            -
                # This is used  | 
| 359 | 
            -
                #  | 
| 389 | 
            +
                # This is used in the context of other settings, for example to specify
         | 
| 390 | 
            +
                # values for RuleAction and web ACL DefaultAction.
         | 
| 360 391 | 
             
                #
         | 
| 361 | 
            -
                # @ | 
| 392 | 
            +
                # @note When making an API call, you may pass BlockAction
         | 
| 393 | 
            +
                #   data as a hash:
         | 
| 394 | 
            +
                #
         | 
| 395 | 
            +
                #       {
         | 
| 396 | 
            +
                #         custom_response: {
         | 
| 397 | 
            +
                #           response_code: 1, # required
         | 
| 398 | 
            +
                #           custom_response_body_key: "EntityName",
         | 
| 399 | 
            +
                #           response_headers: [
         | 
| 400 | 
            +
                #             {
         | 
| 401 | 
            +
                #               name: "CustomHTTPHeaderName", # required
         | 
| 402 | 
            +
                #               value: "CustomHTTPHeaderValue", # required
         | 
| 403 | 
            +
                #             },
         | 
| 404 | 
            +
                #           ],
         | 
| 405 | 
            +
                #         },
         | 
| 406 | 
            +
                #       }
         | 
| 407 | 
            +
                #
         | 
| 408 | 
            +
                # @!attribute [rw] custom_response
         | 
| 409 | 
            +
                #   Defines a custom response for the web request.
         | 
| 410 | 
            +
                #
         | 
| 411 | 
            +
                #   For information about customizing web requests and responses, see
         | 
| 412 | 
            +
                #   [Customizing web requests and responses in AWS WAF][1] in the [AWS
         | 
| 413 | 
            +
                #   WAF Developer Guide][2].
         | 
| 414 | 
            +
                #
         | 
| 415 | 
            +
                #
         | 
| 416 | 
            +
                #
         | 
| 417 | 
            +
                #   [1]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-custom-request-response.html
         | 
| 418 | 
            +
                #   [2]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html
         | 
| 419 | 
            +
                #   @return [Types::CustomResponse]
         | 
| 362 420 | 
             
                #
         | 
| 363 421 | 
             
                # @see http://docs.aws.amazon.com/goto/WebAPI/wafv2-2019-07-29/BlockAction AWS API Documentation
         | 
| 364 422 | 
             
                #
         | 
| 365 | 
            -
                class BlockAction <  | 
| 423 | 
            +
                class BlockAction < Struct.new(
         | 
| 424 | 
            +
                  :custom_response)
         | 
| 425 | 
            +
                  SENSITIVE = []
         | 
| 426 | 
            +
                  include Aws::Structure
         | 
| 427 | 
            +
                end
         | 
| 366 428 |  | 
| 367 429 | 
             
                # The body of a web request. This immediately follows the request
         | 
| 368 430 | 
             
                # headers.
         | 
| @@ -781,14 +843,48 @@ module Aws::WAFV2 | |
| 781 843 | 
             
                #             },
         | 
| 782 844 | 
             
                #             action: {
         | 
| 783 845 | 
             
                #               block: {
         | 
| 846 | 
            +
                #                 custom_response: {
         | 
| 847 | 
            +
                #                   response_code: 1, # required
         | 
| 848 | 
            +
                #                   custom_response_body_key: "EntityName",
         | 
| 849 | 
            +
                #                   response_headers: [
         | 
| 850 | 
            +
                #                     {
         | 
| 851 | 
            +
                #                       name: "CustomHTTPHeaderName", # required
         | 
| 852 | 
            +
                #                       value: "CustomHTTPHeaderValue", # required
         | 
| 853 | 
            +
                #                     },
         | 
| 854 | 
            +
                #                   ],
         | 
| 855 | 
            +
                #                 },
         | 
| 784 856 | 
             
                #               },
         | 
| 785 857 | 
             
                #               allow: {
         | 
| 858 | 
            +
                #                 custom_request_handling: {
         | 
| 859 | 
            +
                #                   insert_headers: [ # required
         | 
| 860 | 
            +
                #                     {
         | 
| 861 | 
            +
                #                       name: "CustomHTTPHeaderName", # required
         | 
| 862 | 
            +
                #                       value: "CustomHTTPHeaderValue", # required
         | 
| 863 | 
            +
                #                     },
         | 
| 864 | 
            +
                #                   ],
         | 
| 865 | 
            +
                #                 },
         | 
| 786 866 | 
             
                #               },
         | 
| 787 867 | 
             
                #               count: {
         | 
| 868 | 
            +
                #                 custom_request_handling: {
         | 
| 869 | 
            +
                #                   insert_headers: [ # required
         | 
| 870 | 
            +
                #                     {
         | 
| 871 | 
            +
                #                       name: "CustomHTTPHeaderName", # required
         | 
| 872 | 
            +
                #                       value: "CustomHTTPHeaderValue", # required
         | 
| 873 | 
            +
                #                     },
         | 
| 874 | 
            +
                #                   ],
         | 
| 875 | 
            +
                #                 },
         | 
| 788 876 | 
             
                #               },
         | 
| 789 877 | 
             
                #             },
         | 
| 790 878 | 
             
                #             override_action: {
         | 
| 791 879 | 
             
                #               count: {
         | 
| 880 | 
            +
                #                 custom_request_handling: {
         | 
| 881 | 
            +
                #                   insert_headers: [ # required
         | 
| 882 | 
            +
                #                     {
         | 
| 883 | 
            +
                #                       name: "CustomHTTPHeaderName", # required
         | 
| 884 | 
            +
                #                       value: "CustomHTTPHeaderValue", # required
         | 
| 885 | 
            +
                #                     },
         | 
| 886 | 
            +
                #                   ],
         | 
| 887 | 
            +
                #                 },
         | 
| 792 888 | 
             
                #               },
         | 
| 793 889 | 
             
                #               none: {
         | 
| 794 890 | 
             
                #               },
         | 
| @@ -843,16 +939,46 @@ module Aws::WAFV2 | |
| 843 939 | 
             
                  include Aws::Structure
         | 
| 844 940 | 
             
                end
         | 
| 845 941 |  | 
| 846 | 
            -
                # Specifies that AWS WAF should count  | 
| 942 | 
            +
                # Specifies that AWS WAF should count the request. Optionally defines
         | 
| 943 | 
            +
                # additional custom handling for the request.
         | 
| 847 944 | 
             
                #
         | 
| 848 | 
            -
                # This is used  | 
| 849 | 
            -
                #  | 
| 945 | 
            +
                # This is used in the context of other settings, for example to specify
         | 
| 946 | 
            +
                # values for RuleAction and web ACL DefaultAction.
         | 
| 850 947 | 
             
                #
         | 
| 851 | 
            -
                # @ | 
| 948 | 
            +
                # @note When making an API call, you may pass CountAction
         | 
| 949 | 
            +
                #   data as a hash:
         | 
| 950 | 
            +
                #
         | 
| 951 | 
            +
                #       {
         | 
| 952 | 
            +
                #         custom_request_handling: {
         | 
| 953 | 
            +
                #           insert_headers: [ # required
         | 
| 954 | 
            +
                #             {
         | 
| 955 | 
            +
                #               name: "CustomHTTPHeaderName", # required
         | 
| 956 | 
            +
                #               value: "CustomHTTPHeaderValue", # required
         | 
| 957 | 
            +
                #             },
         | 
| 958 | 
            +
                #           ],
         | 
| 959 | 
            +
                #         },
         | 
| 960 | 
            +
                #       }
         | 
| 961 | 
            +
                #
         | 
| 962 | 
            +
                # @!attribute [rw] custom_request_handling
         | 
| 963 | 
            +
                #   Defines custom handling for the web request.
         | 
| 964 | 
            +
                #
         | 
| 965 | 
            +
                #   For information about customizing web requests and responses, see
         | 
| 966 | 
            +
                #   [Customizing web requests and responses in AWS WAF][1] in the [AWS
         | 
| 967 | 
            +
                #   WAF Developer Guide][2].
         | 
| 968 | 
            +
                #
         | 
| 969 | 
            +
                #
         | 
| 970 | 
            +
                #
         | 
| 971 | 
            +
                #   [1]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-custom-request-response.html
         | 
| 972 | 
            +
                #   [2]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html
         | 
| 973 | 
            +
                #   @return [Types::CustomRequestHandling]
         | 
| 852 974 | 
             
                #
         | 
| 853 975 | 
             
                # @see http://docs.aws.amazon.com/goto/WebAPI/wafv2-2019-07-29/CountAction AWS API Documentation
         | 
| 854 976 | 
             
                #
         | 
| 855 | 
            -
                class CountAction <  | 
| 977 | 
            +
                class CountAction < Struct.new(
         | 
| 978 | 
            +
                  :custom_request_handling)
         | 
| 979 | 
            +
                  SENSITIVE = []
         | 
| 980 | 
            +
                  include Aws::Structure
         | 
| 981 | 
            +
                end
         | 
| 856 982 |  | 
| 857 983 | 
             
                # @note When making an API call, you may pass CreateIPSetRequest
         | 
| 858 984 | 
             
                #   data as a hash:
         | 
| @@ -1304,14 +1430,48 @@ module Aws::WAFV2 | |
| 1304 1430 | 
             
                #             },
         | 
| 1305 1431 | 
             
                #             action: {
         | 
| 1306 1432 | 
             
                #               block: {
         | 
| 1433 | 
            +
                #                 custom_response: {
         | 
| 1434 | 
            +
                #                   response_code: 1, # required
         | 
| 1435 | 
            +
                #                   custom_response_body_key: "EntityName",
         | 
| 1436 | 
            +
                #                   response_headers: [
         | 
| 1437 | 
            +
                #                     {
         | 
| 1438 | 
            +
                #                       name: "CustomHTTPHeaderName", # required
         | 
| 1439 | 
            +
                #                       value: "CustomHTTPHeaderValue", # required
         | 
| 1440 | 
            +
                #                     },
         | 
| 1441 | 
            +
                #                   ],
         | 
| 1442 | 
            +
                #                 },
         | 
| 1307 1443 | 
             
                #               },
         | 
| 1308 1444 | 
             
                #               allow: {
         | 
| 1445 | 
            +
                #                 custom_request_handling: {
         | 
| 1446 | 
            +
                #                   insert_headers: [ # required
         | 
| 1447 | 
            +
                #                     {
         | 
| 1448 | 
            +
                #                       name: "CustomHTTPHeaderName", # required
         | 
| 1449 | 
            +
                #                       value: "CustomHTTPHeaderValue", # required
         | 
| 1450 | 
            +
                #                     },
         | 
| 1451 | 
            +
                #                   ],
         | 
| 1452 | 
            +
                #                 },
         | 
| 1309 1453 | 
             
                #               },
         | 
| 1310 1454 | 
             
                #               count: {
         | 
| 1455 | 
            +
                #                 custom_request_handling: {
         | 
| 1456 | 
            +
                #                   insert_headers: [ # required
         | 
| 1457 | 
            +
                #                     {
         | 
| 1458 | 
            +
                #                       name: "CustomHTTPHeaderName", # required
         | 
| 1459 | 
            +
                #                       value: "CustomHTTPHeaderValue", # required
         | 
| 1460 | 
            +
                #                     },
         | 
| 1461 | 
            +
                #                   ],
         | 
| 1462 | 
            +
                #                 },
         | 
| 1311 1463 | 
             
                #               },
         | 
| 1312 1464 | 
             
                #             },
         | 
| 1313 1465 | 
             
                #             override_action: {
         | 
| 1314 1466 | 
             
                #               count: {
         | 
| 1467 | 
            +
                #                 custom_request_handling: {
         | 
| 1468 | 
            +
                #                   insert_headers: [ # required
         | 
| 1469 | 
            +
                #                     {
         | 
| 1470 | 
            +
                #                       name: "CustomHTTPHeaderName", # required
         | 
| 1471 | 
            +
                #                       value: "CustomHTTPHeaderValue", # required
         | 
| 1472 | 
            +
                #                     },
         | 
| 1473 | 
            +
                #                   ],
         | 
| 1474 | 
            +
                #                 },
         | 
| 1315 1475 | 
             
                #               },
         | 
| 1316 1476 | 
             
                #               none: {
         | 
| 1317 1477 | 
             
                #               },
         | 
| @@ -1334,6 +1494,12 @@ module Aws::WAFV2 | |
| 1334 1494 | 
             
                #             value: "TagValue", # required
         | 
| 1335 1495 | 
             
                #           },
         | 
| 1336 1496 | 
             
                #         ],
         | 
| 1497 | 
            +
                #         custom_response_bodies: {
         | 
| 1498 | 
            +
                #           "EntityName" => {
         | 
| 1499 | 
            +
                #             content_type: "TEXT_PLAIN", # required, accepts TEXT_PLAIN, TEXT_HTML, APPLICATION_JSON
         | 
| 1500 | 
            +
                #             content: "ResponseContent", # required
         | 
| 1501 | 
            +
                #           },
         | 
| 1502 | 
            +
                #         },
         | 
| 1337 1503 | 
             
                #       }
         | 
| 1338 1504 | 
             
                #
         | 
| 1339 1505 | 
             
                # @!attribute [rw] name
         | 
| @@ -1394,6 +1560,27 @@ module Aws::WAFV2 | |
| 1394 1560 | 
             
                #   An array of key:value pairs to associate with the resource.
         | 
| 1395 1561 | 
             
                #   @return [Array<Types::Tag>]
         | 
| 1396 1562 | 
             
                #
         | 
| 1563 | 
            +
                # @!attribute [rw] custom_response_bodies
         | 
| 1564 | 
            +
                #   A map of custom response keys and content bodies. When you create a
         | 
| 1565 | 
            +
                #   rule with a block action, you can send a custom response to the web
         | 
| 1566 | 
            +
                #   request. You define these for the rule group, and then use them in
         | 
| 1567 | 
            +
                #   the rules that you define in the rule group.
         | 
| 1568 | 
            +
                #
         | 
| 1569 | 
            +
                #   For information about customizing web requests and responses, see
         | 
| 1570 | 
            +
                #   [Customizing web requests and responses in AWS WAF][1] in the [AWS
         | 
| 1571 | 
            +
                #   WAF Developer Guide][2].
         | 
| 1572 | 
            +
                #
         | 
| 1573 | 
            +
                #   For information about the limits on count and size for custom
         | 
| 1574 | 
            +
                #   request and response settings, see [AWS WAF quotas][3] in the [AWS
         | 
| 1575 | 
            +
                #   WAF Developer Guide][2].
         | 
| 1576 | 
            +
                #
         | 
| 1577 | 
            +
                #
         | 
| 1578 | 
            +
                #
         | 
| 1579 | 
            +
                #   [1]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-custom-request-response.html
         | 
| 1580 | 
            +
                #   [2]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html
         | 
| 1581 | 
            +
                #   [3]: https://docs.aws.amazon.com/waf/latest/developerguide/limits.html
         | 
| 1582 | 
            +
                #   @return [Hash<String,Types::CustomResponseBody>]
         | 
| 1583 | 
            +
                #
         | 
| 1397 1584 | 
             
                # @see http://docs.aws.amazon.com/goto/WebAPI/wafv2-2019-07-29/CreateRuleGroupRequest AWS API Documentation
         | 
| 1398 1585 | 
             
                #
         | 
| 1399 1586 | 
             
                class CreateRuleGroupRequest < Struct.new(
         | 
| @@ -1403,7 +1590,8 @@ module Aws::WAFV2 | |
| 1403 1590 | 
             
                  :description,
         | 
| 1404 1591 | 
             
                  :rules,
         | 
| 1405 1592 | 
             
                  :visibility_config,
         | 
| 1406 | 
            -
                  :tags | 
| 1593 | 
            +
                  :tags,
         | 
| 1594 | 
            +
                  :custom_response_bodies)
         | 
| 1407 1595 | 
             
                  SENSITIVE = []
         | 
| 1408 1596 | 
             
                  include Aws::Structure
         | 
| 1409 1597 | 
             
                end
         | 
| @@ -1432,8 +1620,26 @@ module Aws::WAFV2 | |
| 1432 1620 | 
             
                #         scope: "CLOUDFRONT", # required, accepts CLOUDFRONT, REGIONAL
         | 
| 1433 1621 | 
             
                #         default_action: { # required
         | 
| 1434 1622 | 
             
                #           block: {
         | 
| 1623 | 
            +
                #             custom_response: {
         | 
| 1624 | 
            +
                #               response_code: 1, # required
         | 
| 1625 | 
            +
                #               custom_response_body_key: "EntityName",
         | 
| 1626 | 
            +
                #               response_headers: [
         | 
| 1627 | 
            +
                #                 {
         | 
| 1628 | 
            +
                #                   name: "CustomHTTPHeaderName", # required
         | 
| 1629 | 
            +
                #                   value: "CustomHTTPHeaderValue", # required
         | 
| 1630 | 
            +
                #                 },
         | 
| 1631 | 
            +
                #               ],
         | 
| 1632 | 
            +
                #             },
         | 
| 1435 1633 | 
             
                #           },
         | 
| 1436 1634 | 
             
                #           allow: {
         | 
| 1635 | 
            +
                #             custom_request_handling: {
         | 
| 1636 | 
            +
                #               insert_headers: [ # required
         | 
| 1637 | 
            +
                #                 {
         | 
| 1638 | 
            +
                #                   name: "CustomHTTPHeaderName", # required
         | 
| 1639 | 
            +
                #                   value: "CustomHTTPHeaderValue", # required
         | 
| 1640 | 
            +
                #                 },
         | 
| 1641 | 
            +
                #               ],
         | 
| 1642 | 
            +
                #             },
         | 
| 1437 1643 | 
             
                #           },
         | 
| 1438 1644 | 
             
                #         },
         | 
| 1439 1645 | 
             
                #         description: "EntityDescription",
         | 
| @@ -1687,14 +1893,48 @@ module Aws::WAFV2 | |
| 1687 1893 | 
             
                #             },
         | 
| 1688 1894 | 
             
                #             action: {
         | 
| 1689 1895 | 
             
                #               block: {
         | 
| 1896 | 
            +
                #                 custom_response: {
         | 
| 1897 | 
            +
                #                   response_code: 1, # required
         | 
| 1898 | 
            +
                #                   custom_response_body_key: "EntityName",
         | 
| 1899 | 
            +
                #                   response_headers: [
         | 
| 1900 | 
            +
                #                     {
         | 
| 1901 | 
            +
                #                       name: "CustomHTTPHeaderName", # required
         | 
| 1902 | 
            +
                #                       value: "CustomHTTPHeaderValue", # required
         | 
| 1903 | 
            +
                #                     },
         | 
| 1904 | 
            +
                #                   ],
         | 
| 1905 | 
            +
                #                 },
         | 
| 1690 1906 | 
             
                #               },
         | 
| 1691 1907 | 
             
                #               allow: {
         | 
| 1908 | 
            +
                #                 custom_request_handling: {
         | 
| 1909 | 
            +
                #                   insert_headers: [ # required
         | 
| 1910 | 
            +
                #                     {
         | 
| 1911 | 
            +
                #                       name: "CustomHTTPHeaderName", # required
         | 
| 1912 | 
            +
                #                       value: "CustomHTTPHeaderValue", # required
         | 
| 1913 | 
            +
                #                     },
         | 
| 1914 | 
            +
                #                   ],
         | 
| 1915 | 
            +
                #                 },
         | 
| 1692 1916 | 
             
                #               },
         | 
| 1693 1917 | 
             
                #               count: {
         | 
| 1918 | 
            +
                #                 custom_request_handling: {
         | 
| 1919 | 
            +
                #                   insert_headers: [ # required
         | 
| 1920 | 
            +
                #                     {
         | 
| 1921 | 
            +
                #                       name: "CustomHTTPHeaderName", # required
         | 
| 1922 | 
            +
                #                       value: "CustomHTTPHeaderValue", # required
         | 
| 1923 | 
            +
                #                     },
         | 
| 1924 | 
            +
                #                   ],
         | 
| 1925 | 
            +
                #                 },
         | 
| 1694 1926 | 
             
                #               },
         | 
| 1695 1927 | 
             
                #             },
         | 
| 1696 1928 | 
             
                #             override_action: {
         | 
| 1697 1929 | 
             
                #               count: {
         | 
| 1930 | 
            +
                #                 custom_request_handling: {
         | 
| 1931 | 
            +
                #                   insert_headers: [ # required
         | 
| 1932 | 
            +
                #                     {
         | 
| 1933 | 
            +
                #                       name: "CustomHTTPHeaderName", # required
         | 
| 1934 | 
            +
                #                       value: "CustomHTTPHeaderValue", # required
         | 
| 1935 | 
            +
                #                     },
         | 
| 1936 | 
            +
                #                   ],
         | 
| 1937 | 
            +
                #                 },
         | 
| 1698 1938 | 
             
                #               },
         | 
| 1699 1939 | 
             
                #               none: {
         | 
| 1700 1940 | 
             
                #               },
         | 
| @@ -1717,6 +1957,12 @@ module Aws::WAFV2 | |
| 1717 1957 | 
             
                #             value: "TagValue", # required
         | 
| 1718 1958 | 
             
                #           },
         | 
| 1719 1959 | 
             
                #         ],
         | 
| 1960 | 
            +
                #         custom_response_bodies: {
         | 
| 1961 | 
            +
                #           "EntityName" => {
         | 
| 1962 | 
            +
                #             content_type: "TEXT_PLAIN", # required, accepts TEXT_PLAIN, TEXT_HTML, APPLICATION_JSON
         | 
| 1963 | 
            +
                #             content: "ResponseContent", # required
         | 
| 1964 | 
            +
                #           },
         | 
| 1965 | 
            +
                #         },
         | 
| 1720 1966 | 
             
                #       }
         | 
| 1721 1967 | 
             
                #
         | 
| 1722 1968 | 
             
                # @!attribute [rw] name
         | 
| @@ -1764,6 +2010,27 @@ module Aws::WAFV2 | |
| 1764 2010 | 
             
                #   An array of key:value pairs to associate with the resource.
         | 
| 1765 2011 | 
             
                #   @return [Array<Types::Tag>]
         | 
| 1766 2012 | 
             
                #
         | 
| 2013 | 
            +
                # @!attribute [rw] custom_response_bodies
         | 
| 2014 | 
            +
                #   A map of custom response keys and content bodies. When you create a
         | 
| 2015 | 
            +
                #   rule with a block action, you can send a custom response to the web
         | 
| 2016 | 
            +
                #   request. You define these for the web ACL, and then use them in the
         | 
| 2017 | 
            +
                #   rules and default actions that you define in the web ACL.
         | 
| 2018 | 
            +
                #
         | 
| 2019 | 
            +
                #   For information about customizing web requests and responses, see
         | 
| 2020 | 
            +
                #   [Customizing web requests and responses in AWS WAF][1] in the [AWS
         | 
| 2021 | 
            +
                #   WAF Developer Guide][2].
         | 
| 2022 | 
            +
                #
         | 
| 2023 | 
            +
                #   For information about the limits on count and size for custom
         | 
| 2024 | 
            +
                #   request and response settings, see [AWS WAF quotas][3] in the [AWS
         | 
| 2025 | 
            +
                #   WAF Developer Guide][2].
         | 
| 2026 | 
            +
                #
         | 
| 2027 | 
            +
                #
         | 
| 2028 | 
            +
                #
         | 
| 2029 | 
            +
                #   [1]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-custom-request-response.html
         | 
| 2030 | 
            +
                #   [2]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html
         | 
| 2031 | 
            +
                #   [3]: https://docs.aws.amazon.com/waf/latest/developerguide/limits.html
         | 
| 2032 | 
            +
                #   @return [Hash<String,Types::CustomResponseBody>]
         | 
| 2033 | 
            +
                #
         | 
| 1767 2034 | 
             
                # @see http://docs.aws.amazon.com/goto/WebAPI/wafv2-2019-07-29/CreateWebACLRequest AWS API Documentation
         | 
| 1768 2035 | 
             
                #
         | 
| 1769 2036 | 
             
                class CreateWebACLRequest < Struct.new(
         | 
| @@ -1773,7 +2040,8 @@ module Aws::WAFV2 | |
| 1773 2040 | 
             
                  :description,
         | 
| 1774 2041 | 
             
                  :rules,
         | 
| 1775 2042 | 
             
                  :visibility_config,
         | 
| 1776 | 
            -
                  :tags | 
| 2043 | 
            +
                  :tags,
         | 
| 2044 | 
            +
                  :custom_response_bodies)
         | 
| 1777 2045 | 
             
                  SENSITIVE = []
         | 
| 1778 2046 | 
             
                  include Aws::Structure
         | 
| 1779 2047 | 
             
                end
         | 
| @@ -1793,17 +2061,232 @@ module Aws::WAFV2 | |
| 1793 2061 | 
             
                  include Aws::Structure
         | 
| 1794 2062 | 
             
                end
         | 
| 1795 2063 |  | 
| 2064 | 
            +
                # A custom header for custom request and response handling. This is used
         | 
| 2065 | 
            +
                # in CustomResponse and CustomRequestHandling.
         | 
| 2066 | 
            +
                #
         | 
| 2067 | 
            +
                # @note When making an API call, you may pass CustomHTTPHeader
         | 
| 2068 | 
            +
                #   data as a hash:
         | 
| 2069 | 
            +
                #
         | 
| 2070 | 
            +
                #       {
         | 
| 2071 | 
            +
                #         name: "CustomHTTPHeaderName", # required
         | 
| 2072 | 
            +
                #         value: "CustomHTTPHeaderValue", # required
         | 
| 2073 | 
            +
                #       }
         | 
| 2074 | 
            +
                #
         | 
| 2075 | 
            +
                # @!attribute [rw] name
         | 
| 2076 | 
            +
                #   The name of the custom header.
         | 
| 2077 | 
            +
                #
         | 
| 2078 | 
            +
                #   For custom request header insertion, when AWS WAF inserts the header
         | 
| 2079 | 
            +
                #   into the request, it prefixes this name `x-amzn-waf-`, to avoid
         | 
| 2080 | 
            +
                #   confusion with the headers that are already in the request. For
         | 
| 2081 | 
            +
                #   example, for the header name `sample`, AWS WAF inserts the header
         | 
| 2082 | 
            +
                #   `x-amzn-waf-sample`.
         | 
| 2083 | 
            +
                #   @return [String]
         | 
| 2084 | 
            +
                #
         | 
| 2085 | 
            +
                # @!attribute [rw] value
         | 
| 2086 | 
            +
                #   The value of the custom header.
         | 
| 2087 | 
            +
                #   @return [String]
         | 
| 2088 | 
            +
                #
         | 
| 2089 | 
            +
                # @see http://docs.aws.amazon.com/goto/WebAPI/wafv2-2019-07-29/CustomHTTPHeader AWS API Documentation
         | 
| 2090 | 
            +
                #
         | 
| 2091 | 
            +
                class CustomHTTPHeader < Struct.new(
         | 
| 2092 | 
            +
                  :name,
         | 
| 2093 | 
            +
                  :value)
         | 
| 2094 | 
            +
                  SENSITIVE = []
         | 
| 2095 | 
            +
                  include Aws::Structure
         | 
| 2096 | 
            +
                end
         | 
| 2097 | 
            +
             | 
| 2098 | 
            +
                # Custom request handling behavior that inserts custom headers into a
         | 
| 2099 | 
            +
                # web request. You can add custom request handling for the rule actions
         | 
| 2100 | 
            +
                # allow and count.
         | 
| 2101 | 
            +
                #
         | 
| 2102 | 
            +
                # For information about customizing web requests and responses, see
         | 
| 2103 | 
            +
                # [Customizing web requests and responses in AWS WAF][1] in the [AWS WAF
         | 
| 2104 | 
            +
                # Developer Guide][2].
         | 
| 2105 | 
            +
                #
         | 
| 2106 | 
            +
                #
         | 
| 2107 | 
            +
                #
         | 
| 2108 | 
            +
                # [1]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-custom-request-response.html
         | 
| 2109 | 
            +
                # [2]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html
         | 
| 2110 | 
            +
                #
         | 
| 2111 | 
            +
                # @note When making an API call, you may pass CustomRequestHandling
         | 
| 2112 | 
            +
                #   data as a hash:
         | 
| 2113 | 
            +
                #
         | 
| 2114 | 
            +
                #       {
         | 
| 2115 | 
            +
                #         insert_headers: [ # required
         | 
| 2116 | 
            +
                #           {
         | 
| 2117 | 
            +
                #             name: "CustomHTTPHeaderName", # required
         | 
| 2118 | 
            +
                #             value: "CustomHTTPHeaderValue", # required
         | 
| 2119 | 
            +
                #           },
         | 
| 2120 | 
            +
                #         ],
         | 
| 2121 | 
            +
                #       }
         | 
| 2122 | 
            +
                #
         | 
| 2123 | 
            +
                # @!attribute [rw] insert_headers
         | 
| 2124 | 
            +
                #   The HTTP headers to insert into the request. Duplicate header names
         | 
| 2125 | 
            +
                #   are not allowed.
         | 
| 2126 | 
            +
                #
         | 
| 2127 | 
            +
                #   For information about the limits on count and size for custom
         | 
| 2128 | 
            +
                #   request and response settings, see [AWS WAF quotas][1] in the [AWS
         | 
| 2129 | 
            +
                #   WAF Developer Guide][2].
         | 
| 2130 | 
            +
                #
         | 
| 2131 | 
            +
                #
         | 
| 2132 | 
            +
                #
         | 
| 2133 | 
            +
                #   [1]: https://docs.aws.amazon.com/waf/latest/developerguide/limits.html
         | 
| 2134 | 
            +
                #   [2]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html
         | 
| 2135 | 
            +
                #   @return [Array<Types::CustomHTTPHeader>]
         | 
| 2136 | 
            +
                #
         | 
| 2137 | 
            +
                # @see http://docs.aws.amazon.com/goto/WebAPI/wafv2-2019-07-29/CustomRequestHandling AWS API Documentation
         | 
| 2138 | 
            +
                #
         | 
| 2139 | 
            +
                class CustomRequestHandling < Struct.new(
         | 
| 2140 | 
            +
                  :insert_headers)
         | 
| 2141 | 
            +
                  SENSITIVE = []
         | 
| 2142 | 
            +
                  include Aws::Structure
         | 
| 2143 | 
            +
                end
         | 
| 2144 | 
            +
             | 
| 2145 | 
            +
                # A custom response to send to the client. You can define a custom
         | 
| 2146 | 
            +
                # response for rule actions and default web ACL actions that are set to
         | 
| 2147 | 
            +
                # BlockAction.
         | 
| 2148 | 
            +
                #
         | 
| 2149 | 
            +
                # For information about customizing web requests and responses, see
         | 
| 2150 | 
            +
                # [Customizing web requests and responses in AWS WAF][1] in the [AWS WAF
         | 
| 2151 | 
            +
                # Developer Guide][2].
         | 
| 2152 | 
            +
                #
         | 
| 2153 | 
            +
                #
         | 
| 2154 | 
            +
                #
         | 
| 2155 | 
            +
                # [1]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-custom-request-response.html
         | 
| 2156 | 
            +
                # [2]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html
         | 
| 2157 | 
            +
                #
         | 
| 2158 | 
            +
                # @note When making an API call, you may pass CustomResponse
         | 
| 2159 | 
            +
                #   data as a hash:
         | 
| 2160 | 
            +
                #
         | 
| 2161 | 
            +
                #       {
         | 
| 2162 | 
            +
                #         response_code: 1, # required
         | 
| 2163 | 
            +
                #         custom_response_body_key: "EntityName",
         | 
| 2164 | 
            +
                #         response_headers: [
         | 
| 2165 | 
            +
                #           {
         | 
| 2166 | 
            +
                #             name: "CustomHTTPHeaderName", # required
         | 
| 2167 | 
            +
                #             value: "CustomHTTPHeaderValue", # required
         | 
| 2168 | 
            +
                #           },
         | 
| 2169 | 
            +
                #         ],
         | 
| 2170 | 
            +
                #       }
         | 
| 2171 | 
            +
                #
         | 
| 2172 | 
            +
                # @!attribute [rw] response_code
         | 
| 2173 | 
            +
                #   The HTTP status code to return to the client.
         | 
| 2174 | 
            +
                #
         | 
| 2175 | 
            +
                #   For a list of status codes that you can use in your custom
         | 
| 2176 | 
            +
                #   reqponses, see [Supported status codes for custom response][1] in
         | 
| 2177 | 
            +
                #   the [AWS WAF Developer Guide][2].
         | 
| 2178 | 
            +
                #
         | 
| 2179 | 
            +
                #
         | 
| 2180 | 
            +
                #
         | 
| 2181 | 
            +
                #   [1]: https://docs.aws.amazon.com/waf/latest/developerguide/customizing-the-response-status-codes.html
         | 
| 2182 | 
            +
                #   [2]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html
         | 
| 2183 | 
            +
                #   @return [Integer]
         | 
| 2184 | 
            +
                #
         | 
| 2185 | 
            +
                # @!attribute [rw] custom_response_body_key
         | 
| 2186 | 
            +
                #   References the response body that you want AWS WAF to return to the
         | 
| 2187 | 
            +
                #   web request client. You can define a custom response for a rule
         | 
| 2188 | 
            +
                #   action or a default web ACL action that is set to block. To do this,
         | 
| 2189 | 
            +
                #   you first define the response body key and value in the
         | 
| 2190 | 
            +
                #   `CustomResponseBodies` setting for the WebACL or RuleGroup where you
         | 
| 2191 | 
            +
                #   want to use it. Then, in the rule action or web ACL default action
         | 
| 2192 | 
            +
                #   `BlockAction` setting, you reference the response body using this
         | 
| 2193 | 
            +
                #   key.
         | 
| 2194 | 
            +
                #   @return [String]
         | 
| 2195 | 
            +
                #
         | 
| 2196 | 
            +
                # @!attribute [rw] response_headers
         | 
| 2197 | 
            +
                #   The HTTP headers to use in the response. Duplicate header names are
         | 
| 2198 | 
            +
                #   not allowed.
         | 
| 2199 | 
            +
                #
         | 
| 2200 | 
            +
                #   For information about the limits on count and size for custom
         | 
| 2201 | 
            +
                #   request and response settings, see [AWS WAF quotas][1] in the [AWS
         | 
| 2202 | 
            +
                #   WAF Developer Guide][2].
         | 
| 2203 | 
            +
                #
         | 
| 2204 | 
            +
                #
         | 
| 2205 | 
            +
                #
         | 
| 2206 | 
            +
                #   [1]: https://docs.aws.amazon.com/waf/latest/developerguide/limits.html
         | 
| 2207 | 
            +
                #   [2]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html
         | 
| 2208 | 
            +
                #   @return [Array<Types::CustomHTTPHeader>]
         | 
| 2209 | 
            +
                #
         | 
| 2210 | 
            +
                # @see http://docs.aws.amazon.com/goto/WebAPI/wafv2-2019-07-29/CustomResponse AWS API Documentation
         | 
| 2211 | 
            +
                #
         | 
| 2212 | 
            +
                class CustomResponse < Struct.new(
         | 
| 2213 | 
            +
                  :response_code,
         | 
| 2214 | 
            +
                  :custom_response_body_key,
         | 
| 2215 | 
            +
                  :response_headers)
         | 
| 2216 | 
            +
                  SENSITIVE = []
         | 
| 2217 | 
            +
                  include Aws::Structure
         | 
| 2218 | 
            +
                end
         | 
| 2219 | 
            +
             | 
| 2220 | 
            +
                # The response body to use in a custom response to a web request. This
         | 
| 2221 | 
            +
                # is referenced by key from CustomResponse `CustomResponseBodyKey`.
         | 
| 2222 | 
            +
                #
         | 
| 2223 | 
            +
                # @note When making an API call, you may pass CustomResponseBody
         | 
| 2224 | 
            +
                #   data as a hash:
         | 
| 2225 | 
            +
                #
         | 
| 2226 | 
            +
                #       {
         | 
| 2227 | 
            +
                #         content_type: "TEXT_PLAIN", # required, accepts TEXT_PLAIN, TEXT_HTML, APPLICATION_JSON
         | 
| 2228 | 
            +
                #         content: "ResponseContent", # required
         | 
| 2229 | 
            +
                #       }
         | 
| 2230 | 
            +
                #
         | 
| 2231 | 
            +
                # @!attribute [rw] content_type
         | 
| 2232 | 
            +
                #   The type of content in the payload that you are defining in the
         | 
| 2233 | 
            +
                #   `Content` string.
         | 
| 2234 | 
            +
                #   @return [String]
         | 
| 2235 | 
            +
                #
         | 
| 2236 | 
            +
                # @!attribute [rw] content
         | 
| 2237 | 
            +
                #   The payload of the custom response.
         | 
| 2238 | 
            +
                #
         | 
| 2239 | 
            +
                #   You can use JSON escape strings in JSON content. To do this, you
         | 
| 2240 | 
            +
                #   must specify JSON content in the `ContentType` setting.
         | 
| 2241 | 
            +
                #
         | 
| 2242 | 
            +
                #   For information about the limits on count and size for custom
         | 
| 2243 | 
            +
                #   request and response settings, see [AWS WAF quotas][1] in the [AWS
         | 
| 2244 | 
            +
                #   WAF Developer Guide][2].
         | 
| 2245 | 
            +
                #
         | 
| 2246 | 
            +
                #
         | 
| 2247 | 
            +
                #
         | 
| 2248 | 
            +
                #   [1]: https://docs.aws.amazon.com/waf/latest/developerguide/limits.html
         | 
| 2249 | 
            +
                #   [2]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html
         | 
| 2250 | 
            +
                #   @return [String]
         | 
| 2251 | 
            +
                #
         | 
| 2252 | 
            +
                # @see http://docs.aws.amazon.com/goto/WebAPI/wafv2-2019-07-29/CustomResponseBody AWS API Documentation
         | 
| 2253 | 
            +
                #
         | 
| 2254 | 
            +
                class CustomResponseBody < Struct.new(
         | 
| 2255 | 
            +
                  :content_type,
         | 
| 2256 | 
            +
                  :content)
         | 
| 2257 | 
            +
                  SENSITIVE = []
         | 
| 2258 | 
            +
                  include Aws::Structure
         | 
| 2259 | 
            +
                end
         | 
| 2260 | 
            +
             | 
| 1796 2261 | 
             
                # In a WebACL, this is the action that you want AWS WAF to perform when
         | 
| 1797 2262 | 
             
                # a web request doesn't match any of the rules in the `WebACL`. The
         | 
| 1798 | 
            -
                # default action must be a terminating action, so  | 
| 2263 | 
            +
                # default action must be a terminating action, so you can't use count.
         | 
| 1799 2264 | 
             
                #
         | 
| 1800 2265 | 
             
                # @note When making an API call, you may pass DefaultAction
         | 
| 1801 2266 | 
             
                #   data as a hash:
         | 
| 1802 2267 | 
             
                #
         | 
| 1803 2268 | 
             
                #       {
         | 
| 1804 2269 | 
             
                #         block: {
         | 
| 2270 | 
            +
                #           custom_response: {
         | 
| 2271 | 
            +
                #             response_code: 1, # required
         | 
| 2272 | 
            +
                #             custom_response_body_key: "EntityName",
         | 
| 2273 | 
            +
                #             response_headers: [
         | 
| 2274 | 
            +
                #               {
         | 
| 2275 | 
            +
                #                 name: "CustomHTTPHeaderName", # required
         | 
| 2276 | 
            +
                #                 value: "CustomHTTPHeaderValue", # required
         | 
| 2277 | 
            +
                #               },
         | 
| 2278 | 
            +
                #             ],
         | 
| 2279 | 
            +
                #           },
         | 
| 1805 2280 | 
             
                #         },
         | 
| 1806 2281 | 
             
                #         allow: {
         | 
| 2282 | 
            +
                #           custom_request_handling: {
         | 
| 2283 | 
            +
                #             insert_headers: [ # required
         | 
| 2284 | 
            +
                #               {
         | 
| 2285 | 
            +
                #                 name: "CustomHTTPHeaderName", # required
         | 
| 2286 | 
            +
                #                 value: "CustomHTTPHeaderValue", # required
         | 
| 2287 | 
            +
                #               },
         | 
| 2288 | 
            +
                #             ],
         | 
| 2289 | 
            +
                #           },
         | 
| 1807 2290 | 
             
                #         },
         | 
| 1808 2291 | 
             
                #       }
         | 
| 1809 2292 | 
             
                #
         | 
| @@ -3544,12 +4027,12 @@ module Aws::WAFV2 | |
| 3544 4027 | 
             
                #   @return [String]
         | 
| 3545 4028 | 
             
                #
         | 
| 3546 4029 | 
             
                # @!attribute [rw] invalid_fallback_behavior
         | 
| 3547 | 
            -
                #    | 
| 3548 | 
            -
                #   body.  | 
| 4030 | 
            +
                #   The inspection behavior to fall back to if the JSON in the request
         | 
| 4031 | 
            +
                #   body is invalid. For AWS WAF, invalid JSON is any content that
         | 
| 4032 | 
            +
                #   isn't complete syntactical JSON, content whose root node isn't an
         | 
| 4033 | 
            +
                #   object or an array, and duplicate keys in the content.
         | 
| 3549 4034 | 
             
                #
         | 
| 3550 | 
            -
                #    | 
| 3551 | 
            -
                #     applies the text transformations and inspection criteria that you
         | 
| 3552 | 
            -
                #     defined for the JSON inspection to the body text string.
         | 
| 4035 | 
            +
                #   You can specify the following fallback behaviors:
         | 
| 3553 4036 | 
             
                #
         | 
| 3554 4037 | 
             
                #   * `MATCH` - Treat the web request as matching the rule statement.
         | 
| 3555 4038 | 
             
                #     AWS WAF applies the rule action to the request.
         | 
| @@ -3557,22 +4040,13 @@ module Aws::WAFV2 | |
| 3557 4040 | 
             
                #   * `NO_MATCH` - Treat the web request as not matching the rule
         | 
| 3558 4041 | 
             
                #     statement.
         | 
| 3559 4042 | 
             
                #
         | 
| 3560 | 
            -
                #    | 
| 3561 | 
            -
                # | 
| 3562 | 
            -
                #
         | 
| 3563 | 
            -
                #   AWS WAF does its best to parse the entire JSON body, but might be
         | 
| 3564 | 
            -
                #   forced to stop for reasons such as invalid characters, duplicate
         | 
| 3565 | 
            -
                #   keys, truncation, and any content whose root node isn't an object
         | 
| 3566 | 
            -
                #   or an array.
         | 
| 3567 | 
            -
                #
         | 
| 3568 | 
            -
                #   AWS WAF parses the JSON in the following examples as two valid key,
         | 
| 3569 | 
            -
                #   value pairs:
         | 
| 3570 | 
            -
                #
         | 
| 3571 | 
            -
                #   * Missing comma: `\{"key1":"value1""key2":"value2"\}`
         | 
| 3572 | 
            -
                #
         | 
| 3573 | 
            -
                #   * Missing colon: `\{"key1":"value1","key2""value2"\}`
         | 
| 4043 | 
            +
                #   * `EVALUATE_AS_STRING` - Inspect the body as plain text. This option
         | 
| 4044 | 
            +
                #     applies the text transformations and inspection criteria that you
         | 
| 4045 | 
            +
                #     defined for the JSON inspection to the body text string.
         | 
| 3574 4046 | 
             
                #
         | 
| 3575 | 
            -
                #    | 
| 4047 | 
            +
                #   If you don't provide this setting, when AWS WAF encounters invalid
         | 
| 4048 | 
            +
                #   JSON, it parses and inspects what it can, up to the first invalid
         | 
| 4049 | 
            +
                #   JSON that it encounters.
         | 
| 3576 4050 | 
             
                #   @return [String]
         | 
| 3577 4051 | 
             
                #
         | 
| 3578 4052 | 
             
                # @see http://docs.aws.amazon.com/goto/WebAPI/wafv2-2019-07-29/JsonBody AWS API Documentation
         | 
| @@ -4329,8 +4803,8 @@ module Aws::WAFV2 | |
| 4329 4803 | 
             
                # try out a rule without performing any actions. You set the
         | 
| 4330 4804 | 
             
                # `OverrideAction` on the Rule.
         | 
| 4331 4805 | 
             
                #
         | 
| 4332 | 
            -
                # This is used  | 
| 4333 | 
            -
                #  | 
| 4806 | 
            +
                # This is used in the context of other settings, for example to specify
         | 
| 4807 | 
            +
                # values for RuleAction and web ACL DefaultAction.
         | 
| 4334 4808 | 
             
                #
         | 
| 4335 4809 | 
             
                # @api private
         | 
| 4336 4810 | 
             
                #
         | 
| @@ -4890,6 +5364,14 @@ module Aws::WAFV2 | |
| 4890 5364 | 
             
                #
         | 
| 4891 5365 | 
             
                #       {
         | 
| 4892 5366 | 
             
                #         count: {
         | 
| 5367 | 
            +
                #           custom_request_handling: {
         | 
| 5368 | 
            +
                #             insert_headers: [ # required
         | 
| 5369 | 
            +
                #               {
         | 
| 5370 | 
            +
                #                 name: "CustomHTTPHeaderName", # required
         | 
| 5371 | 
            +
                #                 value: "CustomHTTPHeaderValue", # required
         | 
| 5372 | 
            +
                #               },
         | 
| 5373 | 
            +
                #             ],
         | 
| 5374 | 
            +
                #           },
         | 
| 4893 5375 | 
             
                #         },
         | 
| 4894 5376 | 
             
                #         none: {
         | 
| 4895 5377 | 
             
                #         },
         | 
| @@ -5847,14 +6329,48 @@ module Aws::WAFV2 | |
| 5847 6329 | 
             
                #         },
         | 
| 5848 6330 | 
             
                #         action: {
         | 
| 5849 6331 | 
             
                #           block: {
         | 
| 6332 | 
            +
                #             custom_response: {
         | 
| 6333 | 
            +
                #               response_code: 1, # required
         | 
| 6334 | 
            +
                #               custom_response_body_key: "EntityName",
         | 
| 6335 | 
            +
                #               response_headers: [
         | 
| 6336 | 
            +
                #                 {
         | 
| 6337 | 
            +
                #                   name: "CustomHTTPHeaderName", # required
         | 
| 6338 | 
            +
                #                   value: "CustomHTTPHeaderValue", # required
         | 
| 6339 | 
            +
                #                 },
         | 
| 6340 | 
            +
                #               ],
         | 
| 6341 | 
            +
                #             },
         | 
| 5850 6342 | 
             
                #           },
         | 
| 5851 6343 | 
             
                #           allow: {
         | 
| 6344 | 
            +
                #             custom_request_handling: {
         | 
| 6345 | 
            +
                #               insert_headers: [ # required
         | 
| 6346 | 
            +
                #                 {
         | 
| 6347 | 
            +
                #                   name: "CustomHTTPHeaderName", # required
         | 
| 6348 | 
            +
                #                   value: "CustomHTTPHeaderValue", # required
         | 
| 6349 | 
            +
                #                 },
         | 
| 6350 | 
            +
                #               ],
         | 
| 6351 | 
            +
                #             },
         | 
| 5852 6352 | 
             
                #           },
         | 
| 5853 6353 | 
             
                #           count: {
         | 
| 6354 | 
            +
                #             custom_request_handling: {
         | 
| 6355 | 
            +
                #               insert_headers: [ # required
         | 
| 6356 | 
            +
                #                 {
         | 
| 6357 | 
            +
                #                   name: "CustomHTTPHeaderName", # required
         | 
| 6358 | 
            +
                #                   value: "CustomHTTPHeaderValue", # required
         | 
| 6359 | 
            +
                #                 },
         | 
| 6360 | 
            +
                #               ],
         | 
| 6361 | 
            +
                #             },
         | 
| 5854 6362 | 
             
                #           },
         | 
| 5855 6363 | 
             
                #         },
         | 
| 5856 6364 | 
             
                #         override_action: {
         | 
| 5857 6365 | 
             
                #           count: {
         | 
| 6366 | 
            +
                #             custom_request_handling: {
         | 
| 6367 | 
            +
                #               insert_headers: [ # required
         | 
| 6368 | 
            +
                #                 {
         | 
| 6369 | 
            +
                #                   name: "CustomHTTPHeaderName", # required
         | 
| 6370 | 
            +
                #                   value: "CustomHTTPHeaderValue", # required
         | 
| 6371 | 
            +
                #                 },
         | 
| 6372 | 
            +
                #               ],
         | 
| 6373 | 
            +
                #             },
         | 
| 5858 6374 | 
             
                #           },
         | 
| 5859 6375 | 
             
                #           none: {
         | 
| 5860 6376 | 
             
                #           },
         | 
| @@ -5949,10 +6465,36 @@ module Aws::WAFV2 | |
| 5949 6465 | 
             
                #
         | 
| 5950 6466 | 
             
                #       {
         | 
| 5951 6467 | 
             
                #         block: {
         | 
| 6468 | 
            +
                #           custom_response: {
         | 
| 6469 | 
            +
                #             response_code: 1, # required
         | 
| 6470 | 
            +
                #             custom_response_body_key: "EntityName",
         | 
| 6471 | 
            +
                #             response_headers: [
         | 
| 6472 | 
            +
                #               {
         | 
| 6473 | 
            +
                #                 name: "CustomHTTPHeaderName", # required
         | 
| 6474 | 
            +
                #                 value: "CustomHTTPHeaderValue", # required
         | 
| 6475 | 
            +
                #               },
         | 
| 6476 | 
            +
                #             ],
         | 
| 6477 | 
            +
                #           },
         | 
| 5952 6478 | 
             
                #         },
         | 
| 5953 6479 | 
             
                #         allow: {
         | 
| 6480 | 
            +
                #           custom_request_handling: {
         | 
| 6481 | 
            +
                #             insert_headers: [ # required
         | 
| 6482 | 
            +
                #               {
         | 
| 6483 | 
            +
                #                 name: "CustomHTTPHeaderName", # required
         | 
| 6484 | 
            +
                #                 value: "CustomHTTPHeaderValue", # required
         | 
| 6485 | 
            +
                #               },
         | 
| 6486 | 
            +
                #             ],
         | 
| 6487 | 
            +
                #           },
         | 
| 5954 6488 | 
             
                #         },
         | 
| 5955 6489 | 
             
                #         count: {
         | 
| 6490 | 
            +
                #           custom_request_handling: {
         | 
| 6491 | 
            +
                #             insert_headers: [ # required
         | 
| 6492 | 
            +
                #               {
         | 
| 6493 | 
            +
                #                 name: "CustomHTTPHeaderName", # required
         | 
| 6494 | 
            +
                #                 value: "CustomHTTPHeaderValue", # required
         | 
| 6495 | 
            +
                #               },
         | 
| 6496 | 
            +
                #             ],
         | 
| 6497 | 
            +
                #           },
         | 
| 5956 6498 | 
             
                #         },
         | 
| 5957 6499 | 
             
                #       }
         | 
| 5958 6500 | 
             
                #
         | 
| @@ -6033,6 +6575,27 @@ module Aws::WAFV2 | |
| 6033 6575 | 
             
                #   collection.
         | 
| 6034 6576 | 
             
                #   @return [Types::VisibilityConfig]
         | 
| 6035 6577 | 
             
                #
         | 
| 6578 | 
            +
                # @!attribute [rw] custom_response_bodies
         | 
| 6579 | 
            +
                #   A map of custom response keys and content bodies. When you create a
         | 
| 6580 | 
            +
                #   rule with a block action, you can send a custom response to the web
         | 
| 6581 | 
            +
                #   request. You define these for the rule group, and then use them in
         | 
| 6582 | 
            +
                #   the rules that you define in the rule group.
         | 
| 6583 | 
            +
                #
         | 
| 6584 | 
            +
                #   For information about customizing web requests and responses, see
         | 
| 6585 | 
            +
                #   [Customizing web requests and responses in AWS WAF][1] in the [AWS
         | 
| 6586 | 
            +
                #   WAF Developer Guide][2].
         | 
| 6587 | 
            +
                #
         | 
| 6588 | 
            +
                #   For information about the limits on count and size for custom
         | 
| 6589 | 
            +
                #   request and response settings, see [AWS WAF quotas][3] in the [AWS
         | 
| 6590 | 
            +
                #   WAF Developer Guide][2].
         | 
| 6591 | 
            +
                #
         | 
| 6592 | 
            +
                #
         | 
| 6593 | 
            +
                #
         | 
| 6594 | 
            +
                #   [1]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-custom-request-response.html
         | 
| 6595 | 
            +
                #   [2]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html
         | 
| 6596 | 
            +
                #   [3]: https://docs.aws.amazon.com/waf/latest/developerguide/limits.html
         | 
| 6597 | 
            +
                #   @return [Hash<String,Types::CustomResponseBody>]
         | 
| 6598 | 
            +
                #
         | 
| 6036 6599 | 
             
                # @see http://docs.aws.amazon.com/goto/WebAPI/wafv2-2019-07-29/RuleGroup AWS API Documentation
         | 
| 6037 6600 | 
             
                #
         | 
| 6038 6601 | 
             
                class RuleGroup < Struct.new(
         | 
| @@ -6042,7 +6605,8 @@ module Aws::WAFV2 | |
| 6042 6605 | 
             
                  :arn,
         | 
| 6043 6606 | 
             
                  :description,
         | 
| 6044 6607 | 
             
                  :rules,
         | 
| 6045 | 
            -
                  :visibility_config | 
| 6608 | 
            +
                  :visibility_config,
         | 
| 6609 | 
            +
                  :custom_response_bodies)
         | 
| 6046 6610 | 
             
                  SENSITIVE = []
         | 
| 6047 6611 | 
             
                  include Aws::Structure
         | 
| 6048 6612 | 
             
                end
         | 
| @@ -6194,6 +6758,16 @@ module Aws::WAFV2 | |
| 6194 6758 | 
             
                #   a rule group, this field is absent.
         | 
| 6195 6759 | 
             
                #   @return [String]
         | 
| 6196 6760 | 
             
                #
         | 
| 6761 | 
            +
                # @!attribute [rw] request_headers_inserted
         | 
| 6762 | 
            +
                #   Custom request headers inserted by AWS WAF into the request,
         | 
| 6763 | 
            +
                #   according to the custom request configuration for the matching rule
         | 
| 6764 | 
            +
                #   action.
         | 
| 6765 | 
            +
                #   @return [Array<Types::HTTPHeader>]
         | 
| 6766 | 
            +
                #
         | 
| 6767 | 
            +
                # @!attribute [rw] response_code_sent
         | 
| 6768 | 
            +
                #   The response code that was sent for the request.
         | 
| 6769 | 
            +
                #   @return [Integer]
         | 
| 6770 | 
            +
                #
         | 
| 6197 6771 | 
             
                # @see http://docs.aws.amazon.com/goto/WebAPI/wafv2-2019-07-29/SampledHTTPRequest AWS API Documentation
         | 
| 6198 6772 | 
             
                #
         | 
| 6199 6773 | 
             
                class SampledHTTPRequest < Struct.new(
         | 
| @@ -6201,7 +6775,9 @@ module Aws::WAFV2 | |
| 6201 6775 | 
             
                  :weight,
         | 
| 6202 6776 | 
             
                  :timestamp,
         | 
| 6203 6777 | 
             
                  :action,
         | 
| 6204 | 
            -
                  :rule_name_within_rule_group | 
| 6778 | 
            +
                  :rule_name_within_rule_group,
         | 
| 6779 | 
            +
                  :request_headers_inserted,
         | 
| 6780 | 
            +
                  :response_code_sent)
         | 
| 6205 6781 | 
             
                  SENSITIVE = []
         | 
| 6206 6782 | 
             
                  include Aws::Structure
         | 
| 6207 6783 | 
             
                end
         | 
| @@ -8537,14 +9113,48 @@ module Aws::WAFV2 | |
| 8537 9113 | 
             
                #             },
         | 
| 8538 9114 | 
             
                #             action: {
         | 
| 8539 9115 | 
             
                #               block: {
         | 
| 9116 | 
            +
                #                 custom_response: {
         | 
| 9117 | 
            +
                #                   response_code: 1, # required
         | 
| 9118 | 
            +
                #                   custom_response_body_key: "EntityName",
         | 
| 9119 | 
            +
                #                   response_headers: [
         | 
| 9120 | 
            +
                #                     {
         | 
| 9121 | 
            +
                #                       name: "CustomHTTPHeaderName", # required
         | 
| 9122 | 
            +
                #                       value: "CustomHTTPHeaderValue", # required
         | 
| 9123 | 
            +
                #                     },
         | 
| 9124 | 
            +
                #                   ],
         | 
| 9125 | 
            +
                #                 },
         | 
| 8540 9126 | 
             
                #               },
         | 
| 8541 9127 | 
             
                #               allow: {
         | 
| 9128 | 
            +
                #                 custom_request_handling: {
         | 
| 9129 | 
            +
                #                   insert_headers: [ # required
         | 
| 9130 | 
            +
                #                     {
         | 
| 9131 | 
            +
                #                       name: "CustomHTTPHeaderName", # required
         | 
| 9132 | 
            +
                #                       value: "CustomHTTPHeaderValue", # required
         | 
| 9133 | 
            +
                #                     },
         | 
| 9134 | 
            +
                #                   ],
         | 
| 9135 | 
            +
                #                 },
         | 
| 8542 9136 | 
             
                #               },
         | 
| 8543 9137 | 
             
                #               count: {
         | 
| 9138 | 
            +
                #                 custom_request_handling: {
         | 
| 9139 | 
            +
                #                   insert_headers: [ # required
         | 
| 9140 | 
            +
                #                     {
         | 
| 9141 | 
            +
                #                       name: "CustomHTTPHeaderName", # required
         | 
| 9142 | 
            +
                #                       value: "CustomHTTPHeaderValue", # required
         | 
| 9143 | 
            +
                #                     },
         | 
| 9144 | 
            +
                #                   ],
         | 
| 9145 | 
            +
                #                 },
         | 
| 8544 9146 | 
             
                #               },
         | 
| 8545 9147 | 
             
                #             },
         | 
| 8546 9148 | 
             
                #             override_action: {
         | 
| 8547 9149 | 
             
                #               count: {
         | 
| 9150 | 
            +
                #                 custom_request_handling: {
         | 
| 9151 | 
            +
                #                   insert_headers: [ # required
         | 
| 9152 | 
            +
                #                     {
         | 
| 9153 | 
            +
                #                       name: "CustomHTTPHeaderName", # required
         | 
| 9154 | 
            +
                #                       value: "CustomHTTPHeaderValue", # required
         | 
| 9155 | 
            +
                #                     },
         | 
| 9156 | 
            +
                #                   ],
         | 
| 9157 | 
            +
                #                 },
         | 
| 8548 9158 | 
             
                #               },
         | 
| 8549 9159 | 
             
                #               none: {
         | 
| 8550 9160 | 
             
                #               },
         | 
| @@ -8562,6 +9172,12 @@ module Aws::WAFV2 | |
| 8562 9172 | 
             
                #           metric_name: "MetricName", # required
         | 
| 8563 9173 | 
             
                #         },
         | 
| 8564 9174 | 
             
                #         lock_token: "LockToken", # required
         | 
| 9175 | 
            +
                #         custom_response_bodies: {
         | 
| 9176 | 
            +
                #           "EntityName" => {
         | 
| 9177 | 
            +
                #             content_type: "TEXT_PLAIN", # required, accepts TEXT_PLAIN, TEXT_HTML, APPLICATION_JSON
         | 
| 9178 | 
            +
                #             content: "ResponseContent", # required
         | 
| 9179 | 
            +
                #           },
         | 
| 9180 | 
            +
                #         },
         | 
| 8565 9181 | 
             
                #       }
         | 
| 8566 9182 | 
             
                #
         | 
| 8567 9183 | 
             
                # @!attribute [rw] name
         | 
| @@ -8618,6 +9234,27 @@ module Aws::WAFV2 | |
| 8618 9234 | 
             
                #   operation.
         | 
| 8619 9235 | 
             
                #   @return [String]
         | 
| 8620 9236 | 
             
                #
         | 
| 9237 | 
            +
                # @!attribute [rw] custom_response_bodies
         | 
| 9238 | 
            +
                #   A map of custom response keys and content bodies. When you create a
         | 
| 9239 | 
            +
                #   rule with a block action, you can send a custom response to the web
         | 
| 9240 | 
            +
                #   request. You define these for the rule group, and then use them in
         | 
| 9241 | 
            +
                #   the rules that you define in the rule group.
         | 
| 9242 | 
            +
                #
         | 
| 9243 | 
            +
                #   For information about customizing web requests and responses, see
         | 
| 9244 | 
            +
                #   [Customizing web requests and responses in AWS WAF][1] in the [AWS
         | 
| 9245 | 
            +
                #   WAF Developer Guide][2].
         | 
| 9246 | 
            +
                #
         | 
| 9247 | 
            +
                #   For information about the limits on count and size for custom
         | 
| 9248 | 
            +
                #   request and response settings, see [AWS WAF quotas][3] in the [AWS
         | 
| 9249 | 
            +
                #   WAF Developer Guide][2].
         | 
| 9250 | 
            +
                #
         | 
| 9251 | 
            +
                #
         | 
| 9252 | 
            +
                #
         | 
| 9253 | 
            +
                #   [1]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-custom-request-response.html
         | 
| 9254 | 
            +
                #   [2]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html
         | 
| 9255 | 
            +
                #   [3]: https://docs.aws.amazon.com/waf/latest/developerguide/limits.html
         | 
| 9256 | 
            +
                #   @return [Hash<String,Types::CustomResponseBody>]
         | 
| 9257 | 
            +
                #
         | 
| 8621 9258 | 
             
                # @see http://docs.aws.amazon.com/goto/WebAPI/wafv2-2019-07-29/UpdateRuleGroupRequest AWS API Documentation
         | 
| 8622 9259 | 
             
                #
         | 
| 8623 9260 | 
             
                class UpdateRuleGroupRequest < Struct.new(
         | 
| @@ -8627,7 +9264,8 @@ module Aws::WAFV2 | |
| 8627 9264 | 
             
                  :description,
         | 
| 8628 9265 | 
             
                  :rules,
         | 
| 8629 9266 | 
             
                  :visibility_config,
         | 
| 8630 | 
            -
                  :lock_token | 
| 9267 | 
            +
                  :lock_token,
         | 
| 9268 | 
            +
                  :custom_response_bodies)
         | 
| 8631 9269 | 
             
                  SENSITIVE = []
         | 
| 8632 9270 | 
             
                  include Aws::Structure
         | 
| 8633 9271 | 
             
                end
         | 
| @@ -8655,8 +9293,26 @@ module Aws::WAFV2 | |
| 8655 9293 | 
             
                #         id: "EntityId", # required
         | 
| 8656 9294 | 
             
                #         default_action: { # required
         | 
| 8657 9295 | 
             
                #           block: {
         | 
| 9296 | 
            +
                #             custom_response: {
         | 
| 9297 | 
            +
                #               response_code: 1, # required
         | 
| 9298 | 
            +
                #               custom_response_body_key: "EntityName",
         | 
| 9299 | 
            +
                #               response_headers: [
         | 
| 9300 | 
            +
                #                 {
         | 
| 9301 | 
            +
                #                   name: "CustomHTTPHeaderName", # required
         | 
| 9302 | 
            +
                #                   value: "CustomHTTPHeaderValue", # required
         | 
| 9303 | 
            +
                #                 },
         | 
| 9304 | 
            +
                #               ],
         | 
| 9305 | 
            +
                #             },
         | 
| 8658 9306 | 
             
                #           },
         | 
| 8659 9307 | 
             
                #           allow: {
         | 
| 9308 | 
            +
                #             custom_request_handling: {
         | 
| 9309 | 
            +
                #               insert_headers: [ # required
         | 
| 9310 | 
            +
                #                 {
         | 
| 9311 | 
            +
                #                   name: "CustomHTTPHeaderName", # required
         | 
| 9312 | 
            +
                #                   value: "CustomHTTPHeaderValue", # required
         | 
| 9313 | 
            +
                #                 },
         | 
| 9314 | 
            +
                #               ],
         | 
| 9315 | 
            +
                #             },
         | 
| 8660 9316 | 
             
                #           },
         | 
| 8661 9317 | 
             
                #         },
         | 
| 8662 9318 | 
             
                #         description: "EntityDescription",
         | 
| @@ -8910,14 +9566,48 @@ module Aws::WAFV2 | |
| 8910 9566 | 
             
                #             },
         | 
| 8911 9567 | 
             
                #             action: {
         | 
| 8912 9568 | 
             
                #               block: {
         | 
| 9569 | 
            +
                #                 custom_response: {
         | 
| 9570 | 
            +
                #                   response_code: 1, # required
         | 
| 9571 | 
            +
                #                   custom_response_body_key: "EntityName",
         | 
| 9572 | 
            +
                #                   response_headers: [
         | 
| 9573 | 
            +
                #                     {
         | 
| 9574 | 
            +
                #                       name: "CustomHTTPHeaderName", # required
         | 
| 9575 | 
            +
                #                       value: "CustomHTTPHeaderValue", # required
         | 
| 9576 | 
            +
                #                     },
         | 
| 9577 | 
            +
                #                   ],
         | 
| 9578 | 
            +
                #                 },
         | 
| 8913 9579 | 
             
                #               },
         | 
| 8914 9580 | 
             
                #               allow: {
         | 
| 9581 | 
            +
                #                 custom_request_handling: {
         | 
| 9582 | 
            +
                #                   insert_headers: [ # required
         | 
| 9583 | 
            +
                #                     {
         | 
| 9584 | 
            +
                #                       name: "CustomHTTPHeaderName", # required
         | 
| 9585 | 
            +
                #                       value: "CustomHTTPHeaderValue", # required
         | 
| 9586 | 
            +
                #                     },
         | 
| 9587 | 
            +
                #                   ],
         | 
| 9588 | 
            +
                #                 },
         | 
| 8915 9589 | 
             
                #               },
         | 
| 8916 9590 | 
             
                #               count: {
         | 
| 9591 | 
            +
                #                 custom_request_handling: {
         | 
| 9592 | 
            +
                #                   insert_headers: [ # required
         | 
| 9593 | 
            +
                #                     {
         | 
| 9594 | 
            +
                #                       name: "CustomHTTPHeaderName", # required
         | 
| 9595 | 
            +
                #                       value: "CustomHTTPHeaderValue", # required
         | 
| 9596 | 
            +
                #                     },
         | 
| 9597 | 
            +
                #                   ],
         | 
| 9598 | 
            +
                #                 },
         | 
| 8917 9599 | 
             
                #               },
         | 
| 8918 9600 | 
             
                #             },
         | 
| 8919 9601 | 
             
                #             override_action: {
         | 
| 8920 9602 | 
             
                #               count: {
         | 
| 9603 | 
            +
                #                 custom_request_handling: {
         | 
| 9604 | 
            +
                #                   insert_headers: [ # required
         | 
| 9605 | 
            +
                #                     {
         | 
| 9606 | 
            +
                #                       name: "CustomHTTPHeaderName", # required
         | 
| 9607 | 
            +
                #                       value: "CustomHTTPHeaderValue", # required
         | 
| 9608 | 
            +
                #                     },
         | 
| 9609 | 
            +
                #                   ],
         | 
| 9610 | 
            +
                #                 },
         | 
| 8921 9611 | 
             
                #               },
         | 
| 8922 9612 | 
             
                #               none: {
         | 
| 8923 9613 | 
             
                #               },
         | 
| @@ -8935,6 +9625,12 @@ module Aws::WAFV2 | |
| 8935 9625 | 
             
                #           metric_name: "MetricName", # required
         | 
| 8936 9626 | 
             
                #         },
         | 
| 8937 9627 | 
             
                #         lock_token: "LockToken", # required
         | 
| 9628 | 
            +
                #         custom_response_bodies: {
         | 
| 9629 | 
            +
                #           "EntityName" => {
         | 
| 9630 | 
            +
                #             content_type: "TEXT_PLAIN", # required, accepts TEXT_PLAIN, TEXT_HTML, APPLICATION_JSON
         | 
| 9631 | 
            +
                #             content: "ResponseContent", # required
         | 
| 9632 | 
            +
                #           },
         | 
| 9633 | 
            +
                #         },
         | 
| 8938 9634 | 
             
                #       }
         | 
| 8939 9635 | 
             
                #
         | 
| 8940 9636 | 
             
                # @!attribute [rw] name
         | 
| @@ -8996,6 +9692,27 @@ module Aws::WAFV2 | |
| 8996 9692 | 
             
                #   operation.
         | 
| 8997 9693 | 
             
                #   @return [String]
         | 
| 8998 9694 | 
             
                #
         | 
| 9695 | 
            +
                # @!attribute [rw] custom_response_bodies
         | 
| 9696 | 
            +
                #   A map of custom response keys and content bodies. When you create a
         | 
| 9697 | 
            +
                #   rule with a block action, you can send a custom response to the web
         | 
| 9698 | 
            +
                #   request. You define these for the web ACL, and then use them in the
         | 
| 9699 | 
            +
                #   rules and default actions that you define in the web ACL.
         | 
| 9700 | 
            +
                #
         | 
| 9701 | 
            +
                #   For information about customizing web requests and responses, see
         | 
| 9702 | 
            +
                #   [Customizing web requests and responses in AWS WAF][1] in the [AWS
         | 
| 9703 | 
            +
                #   WAF Developer Guide][2].
         | 
| 9704 | 
            +
                #
         | 
| 9705 | 
            +
                #   For information about the limits on count and size for custom
         | 
| 9706 | 
            +
                #   request and response settings, see [AWS WAF quotas][3] in the [AWS
         | 
| 9707 | 
            +
                #   WAF Developer Guide][2].
         | 
| 9708 | 
            +
                #
         | 
| 9709 | 
            +
                #
         | 
| 9710 | 
            +
                #
         | 
| 9711 | 
            +
                #   [1]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-custom-request-response.html
         | 
| 9712 | 
            +
                #   [2]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html
         | 
| 9713 | 
            +
                #   [3]: https://docs.aws.amazon.com/waf/latest/developerguide/limits.html
         | 
| 9714 | 
            +
                #   @return [Hash<String,Types::CustomResponseBody>]
         | 
| 9715 | 
            +
                #
         | 
| 8999 9716 | 
             
                # @see http://docs.aws.amazon.com/goto/WebAPI/wafv2-2019-07-29/UpdateWebACLRequest AWS API Documentation
         | 
| 9000 9717 | 
             
                #
         | 
| 9001 9718 | 
             
                class UpdateWebACLRequest < Struct.new(
         | 
| @@ -9006,7 +9723,8 @@ module Aws::WAFV2 | |
| 9006 9723 | 
             
                  :description,
         | 
| 9007 9724 | 
             
                  :rules,
         | 
| 9008 9725 | 
             
                  :visibility_config,
         | 
| 9009 | 
            -
                  :lock_token | 
| 9726 | 
            +
                  :lock_token,
         | 
| 9727 | 
            +
                  :custom_response_bodies)
         | 
| 9010 9728 | 
             
                  SENSITIVE = []
         | 
| 9011 9729 | 
             
                  include Aws::Structure
         | 
| 9012 9730 | 
             
                end
         | 
| @@ -9442,6 +10160,27 @@ module Aws::WAFV2 | |
| 9442 10160 | 
             
                #   any Firewall Manager rule groups in the web ACL.
         | 
| 9443 10161 | 
             
                #   @return [Boolean]
         | 
| 9444 10162 | 
             
                #
         | 
| 10163 | 
            +
                # @!attribute [rw] custom_response_bodies
         | 
| 10164 | 
            +
                #   A map of custom response keys and content bodies. When you create a
         | 
| 10165 | 
            +
                #   rule with a block action, you can send a custom response to the web
         | 
| 10166 | 
            +
                #   request. You define these for the web ACL, and then use them in the
         | 
| 10167 | 
            +
                #   rules and default actions that you define in the web ACL.
         | 
| 10168 | 
            +
                #
         | 
| 10169 | 
            +
                #   For information about customizing web requests and responses, see
         | 
| 10170 | 
            +
                #   [Customizing web requests and responses in AWS WAF][1] in the [AWS
         | 
| 10171 | 
            +
                #   WAF Developer Guide][2].
         | 
| 10172 | 
            +
                #
         | 
| 10173 | 
            +
                #   For information about the limits on count and size for custom
         | 
| 10174 | 
            +
                #   request and response settings, see [AWS WAF quotas][3] in the [AWS
         | 
| 10175 | 
            +
                #   WAF Developer Guide][2].
         | 
| 10176 | 
            +
                #
         | 
| 10177 | 
            +
                #
         | 
| 10178 | 
            +
                #
         | 
| 10179 | 
            +
                #   [1]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-custom-request-response.html
         | 
| 10180 | 
            +
                #   [2]: https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html
         | 
| 10181 | 
            +
                #   [3]: https://docs.aws.amazon.com/waf/latest/developerguide/limits.html
         | 
| 10182 | 
            +
                #   @return [Hash<String,Types::CustomResponseBody>]
         | 
| 10183 | 
            +
                #
         | 
| 9445 10184 | 
             
                # @see http://docs.aws.amazon.com/goto/WebAPI/wafv2-2019-07-29/WebACL AWS API Documentation
         | 
| 9446 10185 | 
             
                #
         | 
| 9447 10186 | 
             
                class WebACL < Struct.new(
         | 
| @@ -9455,7 +10194,8 @@ module Aws::WAFV2 | |
| 9455 10194 | 
             
                  :capacity,
         | 
| 9456 10195 | 
             
                  :pre_process_firewall_manager_rule_groups,
         | 
| 9457 10196 | 
             
                  :post_process_firewall_manager_rule_groups,
         | 
| 9458 | 
            -
                  :managed_by_firewall_manager | 
| 10197 | 
            +
                  :managed_by_firewall_manager,
         | 
| 10198 | 
            +
                  :custom_response_bodies)
         | 
| 9459 10199 | 
             
                  SENSITIVE = []
         | 
| 9460 10200 | 
             
                  include Aws::Structure
         | 
| 9461 10201 | 
             
                end
         |