Documentation

Overview

    Package wafv2 provides the API client, operations, and parameter types for AWS WAFV2.

    This is the latest version of the AWS WAF API, released in November, 2019. The names of the entities that you use to access this API, like endpoints and namespaces, all have the versioning information added, like "V2" or "v2", to distinguish from the prior version. We recommend migrating your resources to this version, because it has a number of significant improvements. If you used AWS WAF prior to this release, you can't use this AWS WAFV2 API to access any AWS WAF resources that you created before. You can access your old rules, web ACLs, and other AWS WAF resources only through the AWS WAF Classic APIs. The AWS WAF Classic APIs have retained the prior names, endpoints, and namespaces. For information, including how to migrate your AWS WAF resources to this version, see the AWS WAF Developer Guide (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html). AWS WAF is a web application firewall that lets you monitor the HTTP and HTTPS requests that are forwarded to Amazon CloudFront, an Amazon API Gateway REST API, an Application Load Balancer, or an AWS AppSync GraphQL API. AWS WAF also lets you control access to your content. Based on conditions that you specify, such as the IP addresses that requests originate from or the values of query strings, the API Gateway REST API, CloudFront distribution, the Application Load Balancer, or the AWS AppSync GraphQL API responds to requests either with the requested content or with an HTTP 403 status code (Forbidden). You also can configure CloudFront to return a custom error page when a request is blocked. This API guide is for developers who need detailed information about AWS WAF API actions, data types, and errors. For detailed information about AWS WAF features and an overview of how to use AWS WAF, see the AWS WAF Developer Guide (https://docs.aws.amazon.com/waf/latest/developerguide/). You can make calls using the endpoints listed in AWS Service Endpoints for AWS WAF (https://docs.aws.amazon.com/general/latest/gr/rande.html#waf_region).

    * For regional applications, you can use any of the endpoints in the list. A regional application can be an Application Load Balancer (ALB), an API Gateway REST API, or an AppSync GraphQL API.

    * For AWS CloudFront applications, you must use the API endpoint listed for US East (N. Virginia): us-east-1.

    Alternatively, you can use one of the AWS SDKs to access an API that's tailored to the programming language or platform that you're using. For more information, see AWS SDKs (http://aws.amazon.com/tools/#SDKs). We currently provide two versions of the AWS WAF API: this API and the prior versions, the classic AWS WAF APIs. This new API provides the same functionality as the older versions, with the following major improvements:

    * You use one API for both global and regional applications. Where you need to distinguish the scope, you specify a Scope parameter and set it to CLOUDFRONT or REGIONAL.

    * You can define a Web ACL or rule group with a single call, and update it with a single call. You define all rule specifications in JSON format, and pass them to your rule group or Web ACL calls.

    * The limits AWS WAF places on the use of rules more closely reflects the cost of running each type of rule. Rule groups include capacity settings, so you know the maximum cost of a rule group when you use it.

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2019-07-29"
    View Source
    const ServiceID = "WAFV2"

    Variables

    This section is empty.

    Functions

    func NewDefaultEndpointResolver

    func NewDefaultEndpointResolver() *internalendpoints.Resolver

      NewDefaultEndpointResolver constructs a new service endpoint resolver

      func WithAPIOptions

      func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options)

        WithAPIOptions returns a functional option for setting the Client's APIOptions option.

        func WithEndpointResolver

        func WithEndpointResolver(v EndpointResolver) func(*Options)

          WithEndpointResolver returns a functional option for setting the Client's EndpointResolver option.

          Types

          type AssociateWebACLInput

          type AssociateWebACLInput struct {
          
          	// The Amazon Resource Name (ARN) of the resource to associate with the web ACL.
          	// The ARN must be in one of the following formats:
          	//
          	// * For an Application Load
          	// Balancer:
          	// arn:aws:elasticloadbalancing:region:account-id:loadbalancer/app/load-balancer-name/load-balancer-id
          	//
          	// *
          	// For an API Gateway REST API:
          	// arn:aws:apigateway:region::/restapis/api-id/stages/stage-name
          	//
          	// * For an AppSync
          	// GraphQL API: arn:aws:appsync:region:account-id:apis/GraphQLApiId
          	//
          	// This member is required.
          	ResourceArn *string
          
          	// The Amazon Resource Name (ARN) of the Web ACL that you want to associate with
          	// the resource.
          	//
          	// This member is required.
          	WebACLArn *string
          }

          type AssociateWebACLOutput

          type AssociateWebACLOutput struct {
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type CheckCapacityInput

          type CheckCapacityInput struct {
          
          	// An array of Rule that you're configuring to use in a rule group or web ACL.
          	//
          	// This member is required.
          	Rules []types.Rule
          
          	// Specifies whether this is for an AWS CloudFront distribution or for a regional
          	// application. A regional application can be an Application Load Balancer (ALB),
          	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
          	// must also specify the Region US East (N. Virginia) as follows:
          	//
          	// * CLI - Specify
          	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
          	// --region=us-east-1.
          	//
          	// * API and SDKs - For all calls, use the Region endpoint
          	// us-east-1.
          	//
          	// This member is required.
          	Scope types.Scope
          }

          type CheckCapacityOutput

          type CheckCapacityOutput struct {
          
          	// The capacity required by the rules and scope.
          	Capacity int64
          
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type Client

          type Client struct {
          	// contains filtered or unexported fields
          }

            Client provides the API client to make operations call for AWS WAFV2.

            func New

            func New(options Options, optFns ...func(*Options)) *Client

              New returns an initialized Client based on the functional options. Provide additional functional options to further configure the behavior of the client, such as changing the client's endpoint or adding custom middleware behavior.

              func NewFromConfig

              func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client

                NewFromConfig returns a new client from the provided config.

                func (*Client) AssociateWebACL

                func (c *Client) AssociateWebACL(ctx context.Context, params *AssociateWebACLInput, optFns ...func(*Options)) (*AssociateWebACLOutput, error)

                  Associates a Web ACL with a regional application resource, to protect the resource. A regional application can be an Application Load Balancer (ALB), an API Gateway REST API, or an AppSync GraphQL API. For AWS CloudFront, don't use this call. Instead, use your CloudFront distribution configuration. To associate a Web ACL, in the CloudFront call UpdateDistribution, set the web ACL ID to the Amazon Resource Name (ARN) of the Web ACL. For information, see UpdateDistribution (https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_UpdateDistribution.html).

                  func (*Client) CheckCapacity

                  func (c *Client) CheckCapacity(ctx context.Context, params *CheckCapacityInput, optFns ...func(*Options)) (*CheckCapacityOutput, error)

                    Returns the web ACL capacity unit (WCU) requirements for a specified scope and set of rules. You can use this to check the capacity requirements for the rules you want to use in a RuleGroup or WebACL. AWS WAF uses WCUs to calculate and control the operating resources that are used to run your rules, rule groups, and web ACLs. AWS WAF calculates capacity differently for each rule type, to reflect the relative cost of each rule. Simple rules that cost little to run use fewer WCUs than more complex rules that use more processing power. Rule group capacity is fixed at creation, which helps users plan their web ACL WCU usage when they use a rule group. The WCU limit for web ACLs is 1,500.

                    func (*Client) CreateIPSet

                    func (c *Client) CreateIPSet(ctx context.Context, params *CreateIPSetInput, optFns ...func(*Options)) (*CreateIPSetOutput, error)

                      Creates an IPSet, which you use to identify web requests that originate from specific IP addresses or ranges of IP addresses. For example, if you're receiving a lot of requests from a ranges of IP addresses, you can configure AWS WAF to block them using an IPSet that lists those IP addresses.

                      func (*Client) CreateRegexPatternSet

                      func (c *Client) CreateRegexPatternSet(ctx context.Context, params *CreateRegexPatternSetInput, optFns ...func(*Options)) (*CreateRegexPatternSetOutput, error)

                        Creates a RegexPatternSet, which you reference in a RegexPatternSetReferenceStatement, to have AWS WAF inspect a web request component for the specified patterns.

                        func (*Client) CreateRuleGroup

                        func (c *Client) CreateRuleGroup(ctx context.Context, params *CreateRuleGroupInput, optFns ...func(*Options)) (*CreateRuleGroupOutput, error)

                          Creates a RuleGroup per the specifications provided. A rule group defines a collection of rules to inspect and control web requests that you can use in a WebACL. When you create a rule group, you define an immutable capacity limit. If you update a rule group, you must stay within the capacity. This allows others to reuse the rule group with confidence in its capacity requirements.

                          func (*Client) CreateWebACL

                          func (c *Client) CreateWebACL(ctx context.Context, params *CreateWebACLInput, optFns ...func(*Options)) (*CreateWebACLOutput, error)

                            Creates a WebACL per the specifications provided. A Web ACL defines a collection of rules to use to inspect and control web requests. Each rule has an action defined (allow, block, or count) for requests that match the statement of the rule. In the Web ACL, you assign a default action to take (allow, block) for any request that does not match any of the rules. The rules in a Web ACL can be a combination of the types Rule, RuleGroup, and managed rule group. You can associate a Web ACL with one or more AWS resources to protect. The resources can be Amazon CloudFront, an Amazon API Gateway REST API, an Application Load Balancer, or an AWS AppSync GraphQL API.

                            func (*Client) DeleteFirewallManagerRuleGroups

                            func (c *Client) DeleteFirewallManagerRuleGroups(ctx context.Context, params *DeleteFirewallManagerRuleGroupsInput, optFns ...func(*Options)) (*DeleteFirewallManagerRuleGroupsOutput, error)

                              Deletes all rule groups that are managed by AWS Firewall Manager for the specified web ACL. You can only use this if ManagedByFirewallManager is false in the specified WebACL.

                              func (*Client) DeleteIPSet

                              func (c *Client) DeleteIPSet(ctx context.Context, params *DeleteIPSetInput, optFns ...func(*Options)) (*DeleteIPSetOutput, error)

                                Deletes the specified IPSet.

                                func (*Client) DeleteLoggingConfiguration

                                func (c *Client) DeleteLoggingConfiguration(ctx context.Context, params *DeleteLoggingConfigurationInput, optFns ...func(*Options)) (*DeleteLoggingConfigurationOutput, error)

                                  Deletes the LoggingConfiguration from the specified web ACL.

                                  func (*Client) DeletePermissionPolicy

                                  func (c *Client) DeletePermissionPolicy(ctx context.Context, params *DeletePermissionPolicyInput, optFns ...func(*Options)) (*DeletePermissionPolicyOutput, error)

                                    Permanently deletes an IAM policy from the specified rule group. You must be the owner of the rule group to perform this operation.

                                    func (*Client) DeleteRegexPatternSet

                                    func (c *Client) DeleteRegexPatternSet(ctx context.Context, params *DeleteRegexPatternSetInput, optFns ...func(*Options)) (*DeleteRegexPatternSetOutput, error)

                                      Deletes the specified RegexPatternSet.

                                      func (*Client) DeleteRuleGroup

                                      func (c *Client) DeleteRuleGroup(ctx context.Context, params *DeleteRuleGroupInput, optFns ...func(*Options)) (*DeleteRuleGroupOutput, error)

                                        Deletes the specified RuleGroup.

                                        func (*Client) DeleteWebACL

                                        func (c *Client) DeleteWebACL(ctx context.Context, params *DeleteWebACLInput, optFns ...func(*Options)) (*DeleteWebACLOutput, error)

                                          Deletes the specified WebACL. You can only use this if ManagedByFirewallManager is false in the specified WebACL.

                                          func (*Client) DescribeManagedRuleGroup

                                          func (c *Client) DescribeManagedRuleGroup(ctx context.Context, params *DescribeManagedRuleGroupInput, optFns ...func(*Options)) (*DescribeManagedRuleGroupOutput, error)

                                            Provides high-level information for a managed rule group, including descriptions of the rules.

                                            func (*Client) DisassociateWebACL

                                            func (c *Client) DisassociateWebACL(ctx context.Context, params *DisassociateWebACLInput, optFns ...func(*Options)) (*DisassociateWebACLOutput, error)

                                              Disassociates a Web ACL from a regional application resource. A regional application can be an Application Load Balancer (ALB), an API Gateway REST API, or an AppSync GraphQL API. For AWS CloudFront, don't use this call. Instead, use your CloudFront distribution configuration. To disassociate a Web ACL, provide an empty web ACL ID in the CloudFront call UpdateDistribution. For information, see UpdateDistribution (https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_UpdateDistribution.html).

                                              func (*Client) GetIPSet

                                              func (c *Client) GetIPSet(ctx context.Context, params *GetIPSetInput, optFns ...func(*Options)) (*GetIPSetOutput, error)

                                                Retrieves the specified IPSet.

                                                func (*Client) GetLoggingConfiguration

                                                func (c *Client) GetLoggingConfiguration(ctx context.Context, params *GetLoggingConfigurationInput, optFns ...func(*Options)) (*GetLoggingConfigurationOutput, error)

                                                  Returns the LoggingConfiguration for the specified web ACL.

                                                  func (*Client) GetPermissionPolicy

                                                  func (c *Client) GetPermissionPolicy(ctx context.Context, params *GetPermissionPolicyInput, optFns ...func(*Options)) (*GetPermissionPolicyOutput, error)

                                                    Returns the IAM policy that is attached to the specified rule group. You must be the owner of the rule group to perform this operation.

                                                    func (*Client) GetRateBasedStatementManagedKeys

                                                    func (c *Client) GetRateBasedStatementManagedKeys(ctx context.Context, params *GetRateBasedStatementManagedKeysInput, optFns ...func(*Options)) (*GetRateBasedStatementManagedKeysOutput, error)

                                                      Retrieves the keys that are currently blocked by a rate-based rule. The maximum number of managed keys that can be blocked for a single rate-based rule is 10,000. If more than 10,000 addresses exceed the rate limit, those with the highest rates are blocked.

                                                      func (*Client) GetRegexPatternSet

                                                      func (c *Client) GetRegexPatternSet(ctx context.Context, params *GetRegexPatternSetInput, optFns ...func(*Options)) (*GetRegexPatternSetOutput, error)

                                                        Retrieves the specified RegexPatternSet.

                                                        func (*Client) GetRuleGroup

                                                        func (c *Client) GetRuleGroup(ctx context.Context, params *GetRuleGroupInput, optFns ...func(*Options)) (*GetRuleGroupOutput, error)

                                                          Retrieves the specified RuleGroup.

                                                          func (*Client) GetSampledRequests

                                                          func (c *Client) GetSampledRequests(ctx context.Context, params *GetSampledRequestsInput, optFns ...func(*Options)) (*GetSampledRequestsOutput, error)

                                                            Gets detailed information about a specified number of requests--a sample--that AWS WAF randomly selects from among the first 5,000 requests that your AWS resource received during a time range that you choose. You can specify a sample size of up to 500 requests, and you can specify any time range in the previous three hours. GetSampledRequests returns a time range, which is usually the time range that you specified. However, if your resource (such as a CloudFront distribution) received 5,000 requests before the specified time range elapsed, GetSampledRequests returns an updated time range. This new time range indicates the actual period during which AWS WAF selected the requests in the sample.

                                                            func (*Client) GetWebACL

                                                            func (c *Client) GetWebACL(ctx context.Context, params *GetWebACLInput, optFns ...func(*Options)) (*GetWebACLOutput, error)

                                                              Retrieves the specified WebACL.

                                                              func (*Client) GetWebACLForResource

                                                              func (c *Client) GetWebACLForResource(ctx context.Context, params *GetWebACLForResourceInput, optFns ...func(*Options)) (*GetWebACLForResourceOutput, error)

                                                                Retrieves the WebACL for the specified resource.

                                                                func (*Client) ListAvailableManagedRuleGroups

                                                                func (c *Client) ListAvailableManagedRuleGroups(ctx context.Context, params *ListAvailableManagedRuleGroupsInput, optFns ...func(*Options)) (*ListAvailableManagedRuleGroupsOutput, error)

                                                                  Retrieves an array of managed rule groups that are available for you to use. This list includes all AWS Managed Rules rule groups and the AWS Marketplace managed rule groups that you're subscribed to.

                                                                  func (*Client) ListIPSets

                                                                  func (c *Client) ListIPSets(ctx context.Context, params *ListIPSetsInput, optFns ...func(*Options)) (*ListIPSetsOutput, error)

                                                                    Retrieves an array of IPSetSummary objects for the IP sets that you manage.

                                                                    func (*Client) ListLoggingConfigurations

                                                                    func (c *Client) ListLoggingConfigurations(ctx context.Context, params *ListLoggingConfigurationsInput, optFns ...func(*Options)) (*ListLoggingConfigurationsOutput, error)

                                                                      Retrieves an array of your LoggingConfiguration objects.

                                                                      func (*Client) ListRegexPatternSets

                                                                      func (c *Client) ListRegexPatternSets(ctx context.Context, params *ListRegexPatternSetsInput, optFns ...func(*Options)) (*ListRegexPatternSetsOutput, error)

                                                                        Retrieves an array of RegexPatternSetSummary objects for the regex pattern sets that you manage.

                                                                        func (*Client) ListResourcesForWebACL

                                                                        func (c *Client) ListResourcesForWebACL(ctx context.Context, params *ListResourcesForWebACLInput, optFns ...func(*Options)) (*ListResourcesForWebACLOutput, error)

                                                                          Retrieves an array of the Amazon Resource Names (ARNs) for the regional resources that are associated with the specified web ACL. If you want the list of AWS CloudFront resources, use the AWS CloudFront call ListDistributionsByWebACLId.

                                                                          func (*Client) ListRuleGroups

                                                                          func (c *Client) ListRuleGroups(ctx context.Context, params *ListRuleGroupsInput, optFns ...func(*Options)) (*ListRuleGroupsOutput, error)

                                                                            Retrieves an array of RuleGroupSummary objects for the rule groups that you manage.

                                                                            func (*Client) ListTagsForResource

                                                                            func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error)

                                                                              Retrieves the TagInfoForResource for the specified resource. Tags are key:value pairs that you can use to categorize and manage your resources, for purposes like billing. For example, you might set the tag key to "customer" and the value to the customer name or ID. You can specify one or more tags to add to each AWS resource, up to 50 tags for a resource. You can tag the AWS resources that you manage through AWS WAF: web ACLs, rule groups, IP sets, and regex pattern sets. You can't manage or view tags through the AWS WAF console.

                                                                              func (*Client) ListWebACLs

                                                                              func (c *Client) ListWebACLs(ctx context.Context, params *ListWebACLsInput, optFns ...func(*Options)) (*ListWebACLsOutput, error)

                                                                                Retrieves an array of WebACLSummary objects for the web ACLs that you manage.

                                                                                func (*Client) PutLoggingConfiguration

                                                                                func (c *Client) PutLoggingConfiguration(ctx context.Context, params *PutLoggingConfigurationInput, optFns ...func(*Options)) (*PutLoggingConfigurationOutput, error)

                                                                                  Enables the specified LoggingConfiguration, to start logging from a web ACL, according to the configuration provided. You can access information about all traffic that AWS WAF inspects using the following steps:

                                                                                  * Create an Amazon Kinesis Data Firehose. Create the data firehose with a PUT source and in the Region that you are operating. If you are capturing logs for Amazon CloudFront, always create the firehose in US East (N. Virginia). Give the data firehose a name that starts with the prefix aws-waf-logs-. For example, aws-waf-logs-us-east-2-analytics. Do not create the data firehose using a Kinesis stream as your source.

                                                                                  * Associate that firehose to your web ACL using a PutLoggingConfiguration request.

                                                                                  When you successfully enable logging using a PutLoggingConfiguration request, AWS WAF will create a service linked role with the necessary permissions to write logs to the Amazon Kinesis Data Firehose. For more information, see Logging Web ACL Traffic Information (https://docs.aws.amazon.com/waf/latest/developerguide/logging.html) in the AWS WAF Developer Guide.

                                                                                  func (*Client) PutPermissionPolicy

                                                                                  func (c *Client) PutPermissionPolicy(ctx context.Context, params *PutPermissionPolicyInput, optFns ...func(*Options)) (*PutPermissionPolicyOutput, error)

                                                                                    Attaches an IAM policy to the specified resource. Use this to share a rule group across accounts. You must be the owner of the rule group to perform this operation. This action is subject to the following restrictions:

                                                                                    * You can attach only one policy with each PutPermissionPolicy request.

                                                                                    * The ARN in the request must be a valid WAF RuleGroup ARN and the rule group must exist in the same region.

                                                                                    * The user making the request must be the owner of the rule group.

                                                                                    func (*Client) TagResource

                                                                                    func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error)

                                                                                      Associates tags with the specified AWS resource. Tags are key:value pairs that you can use to categorize and manage your resources, for purposes like billing. For example, you might set the tag key to "customer" and the value to the customer name or ID. You can specify one or more tags to add to each AWS resource, up to 50 tags for a resource. You can tag the AWS resources that you manage through AWS WAF: web ACLs, rule groups, IP sets, and regex pattern sets. You can't manage or view tags through the AWS WAF console.

                                                                                      func (*Client) UntagResource

                                                                                      func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error)

                                                                                        Disassociates tags from an AWS resource. Tags are key:value pairs that you can associate with AWS resources. For example, the tag key might be "customer" and the tag value might be "companyA." You can specify one or more tags to add to each container. You can add up to 50 tags to each AWS resource.

                                                                                        func (*Client) UpdateIPSet

                                                                                        func (c *Client) UpdateIPSet(ctx context.Context, params *UpdateIPSetInput, optFns ...func(*Options)) (*UpdateIPSetOutput, error)

                                                                                          Updates the specified IPSet. This operation completely replaces any IP address specifications that you already have in the IP set with the ones that you provide to this call. If you want to add to or modify the addresses that are already in the IP set, retrieve those by calling GetIPSet, update them, and provide the complete updated array of IP addresses to this call.

                                                                                          func (*Client) UpdateRegexPatternSet

                                                                                          func (c *Client) UpdateRegexPatternSet(ctx context.Context, params *UpdateRegexPatternSetInput, optFns ...func(*Options)) (*UpdateRegexPatternSetOutput, error)

                                                                                            Updates the specified RegexPatternSet.

                                                                                            func (*Client) UpdateRuleGroup

                                                                                            func (c *Client) UpdateRuleGroup(ctx context.Context, params *UpdateRuleGroupInput, optFns ...func(*Options)) (*UpdateRuleGroupOutput, error)

                                                                                              Updates the specified RuleGroup. A rule group defines a collection of rules to inspect and control web requests that you can use in a WebACL. When you create a rule group, you define an immutable capacity limit. If you update a rule group, you must stay within the capacity. This allows others to reuse the rule group with confidence in its capacity requirements.

                                                                                              func (*Client) UpdateWebACL

                                                                                              func (c *Client) UpdateWebACL(ctx context.Context, params *UpdateWebACLInput, optFns ...func(*Options)) (*UpdateWebACLOutput, error)

                                                                                                Updates the specified WebACL. A Web ACL defines a collection of rules to use to inspect and control web requests. Each rule has an action defined (allow, block, or count) for requests that match the statement of the rule. In the Web ACL, you assign a default action to take (allow, block) for any request that does not match any of the rules. The rules in a Web ACL can be a combination of the types Rule, RuleGroup, and managed rule group. You can associate a Web ACL with one or more AWS resources to protect. The resources can be Amazon CloudFront, an Amazon API Gateway REST API, an Application Load Balancer, or an AWS AppSync GraphQL API.

                                                                                                type CreateIPSetInput

                                                                                                type CreateIPSetInput struct {
                                                                                                
                                                                                                	// Contains an array of strings that specify one or more IP addresses or blocks of
                                                                                                	// IP addresses in Classless Inter-Domain Routing (CIDR) notation. AWS WAF supports
                                                                                                	// all IPv4 and IPv6 CIDR ranges except for /0. Examples:
                                                                                                	//
                                                                                                	// * To configure AWS WAF
                                                                                                	// to allow, block, or count requests that originated from the IP address
                                                                                                	// 192.0.2.44, specify 192.0.2.44/32.
                                                                                                	//
                                                                                                	// * To configure AWS WAF to allow, block, or
                                                                                                	// count requests that originated from IP addresses from 192.0.2.0 to 192.0.2.255,
                                                                                                	// specify 192.0.2.0/24.
                                                                                                	//
                                                                                                	// * To configure AWS WAF to allow, block, or count requests
                                                                                                	// that originated from the IP address 1111:0000:0000:0000:0000:0000:0000:0111,
                                                                                                	// specify 1111:0000:0000:0000:0000:0000:0000:0111/128.
                                                                                                	//
                                                                                                	// * To configure AWS WAF to
                                                                                                	// allow, block, or count requests that originated from IP addresses
                                                                                                	// 1111:0000:0000:0000:0000:0000:0000:0000 to
                                                                                                	// 1111:0000:0000:0000:ffff:ffff:ffff:ffff, specify
                                                                                                	// 1111:0000:0000:0000:0000:0000:0000:0000/64.
                                                                                                	//
                                                                                                	// For more information about CIDR
                                                                                                	// notation, see the Wikipedia entry Classless Inter-Domain Routing
                                                                                                	// (https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing).
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Addresses []string
                                                                                                
                                                                                                	// Specify IPV4 or IPV6.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	IPAddressVersion types.IPAddressVersion
                                                                                                
                                                                                                	// The name of the IP set. You cannot change the name of an IPSet after you create
                                                                                                	// it.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Name *string
                                                                                                
                                                                                                	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                	//
                                                                                                	// * CLI - Specify
                                                                                                	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                	// --region=us-east-1.
                                                                                                	//
                                                                                                	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                	// us-east-1.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Scope types.Scope
                                                                                                
                                                                                                	// A description of the IP set that helps with identification.
                                                                                                	Description *string
                                                                                                
                                                                                                	// An array of key:value pairs to associate with the resource.
                                                                                                	Tags []types.Tag
                                                                                                }

                                                                                                type CreateIPSetOutput

                                                                                                type CreateIPSetOutput struct {
                                                                                                
                                                                                                	// High-level information about an IPSet, returned by operations like create and
                                                                                                	// list. This provides information like the ID, that you can use to retrieve and
                                                                                                	// manage an IPSet, and the ARN, that you provide to the IPSetReferenceStatement to
                                                                                                	// use the address set in a Rule.
                                                                                                	Summary *types.IPSetSummary
                                                                                                
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type CreateRegexPatternSetInput

                                                                                                type CreateRegexPatternSetInput struct {
                                                                                                
                                                                                                	// The name of the set. You cannot change the name after you create the set.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Name *string
                                                                                                
                                                                                                	// Array of regular expression strings.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	RegularExpressionList []types.Regex
                                                                                                
                                                                                                	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                	//
                                                                                                	// * CLI - Specify
                                                                                                	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                	// --region=us-east-1.
                                                                                                	//
                                                                                                	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                	// us-east-1.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Scope types.Scope
                                                                                                
                                                                                                	// A description of the set that helps with identification.
                                                                                                	Description *string
                                                                                                
                                                                                                	// An array of key:value pairs to associate with the resource.
                                                                                                	Tags []types.Tag
                                                                                                }

                                                                                                type CreateRegexPatternSetOutput

                                                                                                type CreateRegexPatternSetOutput struct {
                                                                                                
                                                                                                	// High-level information about a RegexPatternSet, returned by operations like
                                                                                                	// create and list. This provides information like the ID, that you can use to
                                                                                                	// retrieve and manage a RegexPatternSet, and the ARN, that you provide to the
                                                                                                	// RegexPatternSetReferenceStatement to use the pattern set in a Rule.
                                                                                                	Summary *types.RegexPatternSetSummary
                                                                                                
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type CreateRuleGroupInput

                                                                                                type CreateRuleGroupInput struct {
                                                                                                
                                                                                                	// The web ACL capacity units (WCUs) required for this rule group. When you create
                                                                                                	// your own rule group, you define this, and you cannot change it after creation.
                                                                                                	// When you add or modify the rules in a rule group, AWS WAF enforces this limit.
                                                                                                	// You can check the capacity for a set of rules using CheckCapacity. AWS WAF uses
                                                                                                	// WCUs to calculate and control the operating resources that are used to run your
                                                                                                	// rules, rule groups, and web ACLs. AWS WAF calculates capacity differently for
                                                                                                	// each rule type, to reflect the relative cost of each rule. Simple rules that
                                                                                                	// cost little to run use fewer WCUs than more complex rules that use more
                                                                                                	// processing power. Rule group capacity is fixed at creation, which helps users
                                                                                                	// plan their web ACL WCU usage when they use a rule group. The WCU limit for web
                                                                                                	// ACLs is 1,500.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Capacity int64
                                                                                                
                                                                                                	// The name of the rule group. You cannot change the name of a rule group after you
                                                                                                	// create it.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Name *string
                                                                                                
                                                                                                	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                	//
                                                                                                	// * CLI - Specify
                                                                                                	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                	// --region=us-east-1.
                                                                                                	//
                                                                                                	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                	// us-east-1.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Scope types.Scope
                                                                                                
                                                                                                	// Defines and enables Amazon CloudWatch metrics and web request sample collection.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	VisibilityConfig *types.VisibilityConfig
                                                                                                
                                                                                                	// A map of custom response keys and content bodies. When you create a rule with a
                                                                                                	// block action, you can send a custom response to the web request. You define
                                                                                                	// these for the rule group, and then use them in the rules that you define in the
                                                                                                	// rule group. For information about customizing web requests and responses, see
                                                                                                	// Customizing web requests and responses in AWS WAF
                                                                                                	// (https://docs.aws.amazon.com/waf/latest/developerguide/waf-custom-request-response.html)
                                                                                                	// in the AWS WAF Developer Guide
                                                                                                	// (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html). For
                                                                                                	// information about the limits on count and size for custom request and response
                                                                                                	// settings, see AWS WAF quotas
                                                                                                	// (https://docs.aws.amazon.com/waf/latest/developerguide/limits.html) in the AWS
                                                                                                	// WAF Developer Guide
                                                                                                	// (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
                                                                                                	CustomResponseBodies map[string]types.CustomResponseBody
                                                                                                
                                                                                                	// A description of the rule group that helps with identification.
                                                                                                	Description *string
                                                                                                
                                                                                                	// The Rule statements used to identify the web requests that you want to allow,
                                                                                                	// block, or count. Each rule includes one top-level statement that AWS WAF uses to
                                                                                                	// identify matching web requests, and parameters that govern how AWS WAF handles
                                                                                                	// them.
                                                                                                	Rules []types.Rule
                                                                                                
                                                                                                	// An array of key:value pairs to associate with the resource.
                                                                                                	Tags []types.Tag
                                                                                                }

                                                                                                type CreateRuleGroupOutput

                                                                                                type CreateRuleGroupOutput struct {
                                                                                                
                                                                                                	// High-level information about a RuleGroup, returned by operations like create and
                                                                                                	// list. This provides information like the ID, that you can use to retrieve and
                                                                                                	// manage a RuleGroup, and the ARN, that you provide to the
                                                                                                	// RuleGroupReferenceStatement to use the rule group in a Rule.
                                                                                                	Summary *types.RuleGroupSummary
                                                                                                
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type CreateWebACLInput

                                                                                                type CreateWebACLInput struct {
                                                                                                
                                                                                                	// The action to perform if none of the Rules contained in the WebACL match.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	DefaultAction *types.DefaultAction
                                                                                                
                                                                                                	// The name of the Web ACL. You cannot change the name of a Web ACL after you
                                                                                                	// create it.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Name *string
                                                                                                
                                                                                                	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                	//
                                                                                                	// * CLI - Specify
                                                                                                	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                	// --region=us-east-1.
                                                                                                	//
                                                                                                	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                	// us-east-1.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Scope types.Scope
                                                                                                
                                                                                                	// Defines and enables Amazon CloudWatch metrics and web request sample collection.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	VisibilityConfig *types.VisibilityConfig
                                                                                                
                                                                                                	// A map of custom response keys and content bodies. When you create a rule with a
                                                                                                	// block action, you can send a custom response to the web request. You define
                                                                                                	// these for the web ACL, and then use them in the rules and default actions that
                                                                                                	// you define in the web ACL. For information about customizing web requests and
                                                                                                	// responses, see Customizing web requests and responses in AWS WAF
                                                                                                	// (https://docs.aws.amazon.com/waf/latest/developerguide/waf-custom-request-response.html)
                                                                                                	// in the AWS WAF Developer Guide
                                                                                                	// (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html). For
                                                                                                	// information about the limits on count and size for custom request and response
                                                                                                	// settings, see AWS WAF quotas
                                                                                                	// (https://docs.aws.amazon.com/waf/latest/developerguide/limits.html) in the AWS
                                                                                                	// WAF Developer Guide
                                                                                                	// (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
                                                                                                	CustomResponseBodies map[string]types.CustomResponseBody
                                                                                                
                                                                                                	// A description of the Web ACL that helps with identification.
                                                                                                	Description *string
                                                                                                
                                                                                                	// The Rule statements used to identify the web requests that you want to allow,
                                                                                                	// block, or count. Each rule includes one top-level statement that AWS WAF uses to
                                                                                                	// identify matching web requests, and parameters that govern how AWS WAF handles
                                                                                                	// them.
                                                                                                	Rules []types.Rule
                                                                                                
                                                                                                	// An array of key:value pairs to associate with the resource.
                                                                                                	Tags []types.Tag
                                                                                                }

                                                                                                type CreateWebACLOutput

                                                                                                type CreateWebACLOutput struct {
                                                                                                
                                                                                                	// High-level information about a WebACL, returned by operations like create and
                                                                                                	// list. This provides information like the ID, that you can use to retrieve and
                                                                                                	// manage a WebACL, and the ARN, that you provide to operations like
                                                                                                	// AssociateWebACL.
                                                                                                	Summary *types.WebACLSummary
                                                                                                
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type DeleteFirewallManagerRuleGroupsInput

                                                                                                type DeleteFirewallManagerRuleGroupsInput struct {
                                                                                                
                                                                                                	// The Amazon Resource Name (ARN) of the web ACL.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	WebACLArn *string
                                                                                                
                                                                                                	// A token used for optimistic locking. AWS WAF returns a token to your get and
                                                                                                	// list requests, to mark the state of the entity at the time of the request. To
                                                                                                	// make changes to the entity associated with the token, you provide the token to
                                                                                                	// operations like update and delete. AWS WAF uses the token to ensure that no
                                                                                                	// changes have been made to the entity since you last retrieved it. If a change
                                                                                                	// has been made, the update fails with a WAFOptimisticLockException. If this
                                                                                                	// happens, perform another get, and use the new token returned by that operation.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	WebACLLockToken *string
                                                                                                }

                                                                                                type DeleteFirewallManagerRuleGroupsOutput

                                                                                                type DeleteFirewallManagerRuleGroupsOutput struct {
                                                                                                
                                                                                                	// A token used for optimistic locking. AWS WAF returns a token to your get and
                                                                                                	// list requests, to mark the state of the entity at the time of the request. To
                                                                                                	// make changes to the entity associated with the token, you provide the token to
                                                                                                	// operations like update and delete. AWS WAF uses the token to ensure that no
                                                                                                	// changes have been made to the entity since you last retrieved it. If a change
                                                                                                	// has been made, the update fails with a WAFOptimisticLockException. If this
                                                                                                	// happens, perform another get, and use the new token returned by that operation.
                                                                                                	NextWebACLLockToken *string
                                                                                                
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type DeleteIPSetInput

                                                                                                type DeleteIPSetInput struct {
                                                                                                
                                                                                                	// A unique identifier for the set. This ID is returned in the responses to create
                                                                                                	// and list commands. You provide it to operations like update and delete.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Id *string
                                                                                                
                                                                                                	// A token used for optimistic locking. AWS WAF returns a token to your get and
                                                                                                	// list requests, to mark the state of the entity at the time of the request. To
                                                                                                	// make changes to the entity associated with the token, you provide the token to
                                                                                                	// operations like update and delete. AWS WAF uses the token to ensure that no
                                                                                                	// changes have been made to the entity since you last retrieved it. If a change
                                                                                                	// has been made, the update fails with a WAFOptimisticLockException. If this
                                                                                                	// happens, perform another get, and use the new token returned by that operation.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	LockToken *string
                                                                                                
                                                                                                	// The name of the IP set. You cannot change the name of an IPSet after you create
                                                                                                	// it.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Name *string
                                                                                                
                                                                                                	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                	//
                                                                                                	// * CLI - Specify
                                                                                                	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                	// --region=us-east-1.
                                                                                                	//
                                                                                                	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                	// us-east-1.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Scope types.Scope
                                                                                                }

                                                                                                type DeleteIPSetOutput

                                                                                                type DeleteIPSetOutput struct {
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type DeleteLoggingConfigurationInput

                                                                                                type DeleteLoggingConfigurationInput struct {
                                                                                                
                                                                                                	// The Amazon Resource Name (ARN) of the web ACL from which you want to delete the
                                                                                                	// LoggingConfiguration.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	ResourceArn *string
                                                                                                }

                                                                                                type DeleteLoggingConfigurationOutput

                                                                                                type DeleteLoggingConfigurationOutput struct {
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type DeletePermissionPolicyInput

                                                                                                type DeletePermissionPolicyInput struct {
                                                                                                
                                                                                                	// The Amazon Resource Name (ARN) of the rule group from which you want to delete
                                                                                                	// the policy. You must be the owner of the rule group to perform this operation.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	ResourceArn *string
                                                                                                }

                                                                                                type DeletePermissionPolicyOutput

                                                                                                type DeletePermissionPolicyOutput struct {
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type DeleteRegexPatternSetInput

                                                                                                type DeleteRegexPatternSetInput struct {
                                                                                                
                                                                                                	// A unique identifier for the set. This ID is returned in the responses to create
                                                                                                	// and list commands. You provide it to operations like update and delete.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Id *string
                                                                                                
                                                                                                	// A token used for optimistic locking. AWS WAF returns a token to your get and
                                                                                                	// list requests, to mark the state of the entity at the time of the request. To
                                                                                                	// make changes to the entity associated with the token, you provide the token to
                                                                                                	// operations like update and delete. AWS WAF uses the token to ensure that no
                                                                                                	// changes have been made to the entity since you last retrieved it. If a change
                                                                                                	// has been made, the update fails with a WAFOptimisticLockException. If this
                                                                                                	// happens, perform another get, and use the new token returned by that operation.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	LockToken *string
                                                                                                
                                                                                                	// The name of the set. You cannot change the name after you create the set.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Name *string
                                                                                                
                                                                                                	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                	//
                                                                                                	// * CLI - Specify
                                                                                                	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                	// --region=us-east-1.
                                                                                                	//
                                                                                                	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                	// us-east-1.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Scope types.Scope
                                                                                                }

                                                                                                type DeleteRegexPatternSetOutput

                                                                                                type DeleteRegexPatternSetOutput struct {
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type DeleteRuleGroupInput

                                                                                                type DeleteRuleGroupInput struct {
                                                                                                
                                                                                                	// A unique identifier for the rule group. This ID is returned in the responses to
                                                                                                	// create and list commands. You provide it to operations like update and delete.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Id *string
                                                                                                
                                                                                                	// A token used for optimistic locking. AWS WAF returns a token to your get and
                                                                                                	// list requests, to mark the state of the entity at the time of the request. To
                                                                                                	// make changes to the entity associated with the token, you provide the token to
                                                                                                	// operations like update and delete. AWS WAF uses the token to ensure that no
                                                                                                	// changes have been made to the entity since you last retrieved it. If a change
                                                                                                	// has been made, the update fails with a WAFOptimisticLockException. If this
                                                                                                	// happens, perform another get, and use the new token returned by that operation.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	LockToken *string
                                                                                                
                                                                                                	// The name of the rule group. You cannot change the name of a rule group after you
                                                                                                	// create it.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Name *string
                                                                                                
                                                                                                	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                	//
                                                                                                	// * CLI - Specify
                                                                                                	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                	// --region=us-east-1.
                                                                                                	//
                                                                                                	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                	// us-east-1.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Scope types.Scope
                                                                                                }

                                                                                                type DeleteRuleGroupOutput

                                                                                                type DeleteRuleGroupOutput struct {
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type DeleteWebACLInput

                                                                                                type DeleteWebACLInput struct {
                                                                                                
                                                                                                	// The unique identifier for the Web ACL. This ID is returned in the responses to
                                                                                                	// create and list commands. You provide it to operations like update and delete.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Id *string
                                                                                                
                                                                                                	// A token used for optimistic locking. AWS WAF returns a token to your get and
                                                                                                	// list requests, to mark the state of the entity at the time of the request. To
                                                                                                	// make changes to the entity associated with the token, you provide the token to
                                                                                                	// operations like update and delete. AWS WAF uses the token to ensure that no
                                                                                                	// changes have been made to the entity since you last retrieved it. If a change
                                                                                                	// has been made, the update fails with a WAFOptimisticLockException. If this
                                                                                                	// happens, perform another get, and use the new token returned by that operation.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	LockToken *string
                                                                                                
                                                                                                	// The name of the Web ACL. You cannot change the name of a Web ACL after you
                                                                                                	// create it.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Name *string
                                                                                                
                                                                                                	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                	//
                                                                                                	// * CLI - Specify
                                                                                                	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                	// --region=us-east-1.
                                                                                                	//
                                                                                                	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                	// us-east-1.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Scope types.Scope
                                                                                                }

                                                                                                type DeleteWebACLOutput

                                                                                                type DeleteWebACLOutput struct {
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type DescribeManagedRuleGroupInput

                                                                                                type DescribeManagedRuleGroupInput struct {
                                                                                                
                                                                                                	// The name of the managed rule group. You use this, along with the vendor name, to
                                                                                                	// identify the rule group.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Name *string
                                                                                                
                                                                                                	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                	//
                                                                                                	// * CLI - Specify
                                                                                                	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                	// --region=us-east-1.
                                                                                                	//
                                                                                                	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                	// us-east-1.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Scope types.Scope
                                                                                                
                                                                                                	// The name of the managed rule group vendor. You use this, along with the rule
                                                                                                	// group name, to identify the rule group.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	VendorName *string
                                                                                                }

                                                                                                type DescribeManagedRuleGroupOutput

                                                                                                type DescribeManagedRuleGroupOutput struct {
                                                                                                
                                                                                                	// The labels that one or more rules in this rule group add to matching web ACLs.
                                                                                                	// These labels are defined in the RuleLabels for a Rule.
                                                                                                	AvailableLabels []types.LabelSummary
                                                                                                
                                                                                                	// The web ACL capacity units (WCUs) required for this rule group. AWS WAF uses web
                                                                                                	// ACL capacity units (WCU) to calculate and control the operating resources that
                                                                                                	// are used to run your rules, rule groups, and web ACLs. AWS WAF calculates
                                                                                                	// capacity differently for each rule type, to reflect each rule's relative cost.
                                                                                                	// Rule group capacity is fixed at creation, so users can plan their web ACL WCU
                                                                                                	// usage when they use a rule group. The WCU limit for web ACLs is 1,500.
                                                                                                	Capacity int64
                                                                                                
                                                                                                	// The labels that one or more rules in this rule group match against in label
                                                                                                	// match statements. These labels are defined in a LabelMatchStatement
                                                                                                	// specification, in the Statement definition of a rule.
                                                                                                	ConsumedLabels []types.LabelSummary
                                                                                                
                                                                                                	// The label namespace prefix for this rule group. All labels added by rules in
                                                                                                	// this rule group have this prefix.
                                                                                                	//
                                                                                                	// * The syntax for the label namespace prefix
                                                                                                	// for a managed rule group is the following: awswaf:managed:::
                                                                                                	//
                                                                                                	// * When a rule with
                                                                                                	// a label matches a web request, AWS WAF adds the fully qualified label to the
                                                                                                	// request. A fully qualified label is made up of the label namespace from the rule
                                                                                                	// group or web ACL where the rule is defined and the label from the rule,
                                                                                                	// separated by a colon: :
                                                                                                	LabelNamespace *string
                                                                                                
                                                                                                	//
                                                                                                	Rules []types.RuleSummary
                                                                                                
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type DisassociateWebACLInput

                                                                                                type DisassociateWebACLInput struct {
                                                                                                
                                                                                                	// The Amazon Resource Name (ARN) of the resource to disassociate from the web ACL.
                                                                                                	// The ARN must be in one of the following formats:
                                                                                                	//
                                                                                                	// * For an Application Load
                                                                                                	// Balancer:
                                                                                                	// arn:aws:elasticloadbalancing:region:account-id:loadbalancer/app/load-balancer-name/load-balancer-id
                                                                                                	//
                                                                                                	// *
                                                                                                	// For an API Gateway REST API:
                                                                                                	// arn:aws:apigateway:region::/restapis/api-id/stages/stage-name
                                                                                                	//
                                                                                                	// * For an AppSync
                                                                                                	// GraphQL API: arn:aws:appsync:region:account-id:apis/GraphQLApiId
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	ResourceArn *string
                                                                                                }

                                                                                                type DisassociateWebACLOutput

                                                                                                type DisassociateWebACLOutput struct {
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type EndpointResolver

                                                                                                type EndpointResolver interface {
                                                                                                	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
                                                                                                }

                                                                                                  EndpointResolver interface for resolving service endpoints.

                                                                                                  func EndpointResolverFromURL

                                                                                                  func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver

                                                                                                    EndpointResolverFromURL returns an EndpointResolver configured using the provided endpoint url. By default, the resolved endpoint resolver uses the client region as signing region, and the endpoint source is set to EndpointSourceCustom.You can provide functional options to configure endpoint values for the resolved endpoint.

                                                                                                    type EndpointResolverFunc

                                                                                                    type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)

                                                                                                      EndpointResolverFunc is a helper utility that wraps a function so it satisfies the EndpointResolver interface. This is useful when you want to add additional endpoint resolving logic, or stub out specific endpoints with custom values.

                                                                                                      func (EndpointResolverFunc) ResolveEndpoint

                                                                                                      func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error)

                                                                                                      type EndpointResolverOptions

                                                                                                      type EndpointResolverOptions = internalendpoints.Options

                                                                                                        EndpointResolverOptions is the service endpoint resolver options

                                                                                                        type GetIPSetInput

                                                                                                        type GetIPSetInput struct {
                                                                                                        
                                                                                                        	// A unique identifier for the set. This ID is returned in the responses to create
                                                                                                        	// and list commands. You provide it to operations like update and delete.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Id *string
                                                                                                        
                                                                                                        	// The name of the IP set. You cannot change the name of an IPSet after you create
                                                                                                        	// it.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Name *string
                                                                                                        
                                                                                                        	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                        	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                        	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                        	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                        	//
                                                                                                        	// * CLI - Specify
                                                                                                        	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                        	// --region=us-east-1.
                                                                                                        	//
                                                                                                        	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                        	// us-east-1.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Scope types.Scope
                                                                                                        }

                                                                                                        type GetIPSetOutput

                                                                                                        type GetIPSetOutput struct {
                                                                                                        
                                                                                                        	//
                                                                                                        	IPSet *types.IPSet
                                                                                                        
                                                                                                        	// A token used for optimistic locking. AWS WAF returns a token to your get and
                                                                                                        	// list requests, to mark the state of the entity at the time of the request. To
                                                                                                        	// make changes to the entity associated with the token, you provide the token to
                                                                                                        	// operations like update and delete. AWS WAF uses the token to ensure that no
                                                                                                        	// changes have been made to the entity since you last retrieved it. If a change
                                                                                                        	// has been made, the update fails with a WAFOptimisticLockException. If this
                                                                                                        	// happens, perform another get, and use the new token returned by that operation.
                                                                                                        	LockToken *string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type GetLoggingConfigurationInput

                                                                                                        type GetLoggingConfigurationInput struct {
                                                                                                        
                                                                                                        	// The Amazon Resource Name (ARN) of the web ACL for which you want to get the
                                                                                                        	// LoggingConfiguration.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	ResourceArn *string
                                                                                                        }

                                                                                                        type GetLoggingConfigurationOutput

                                                                                                        type GetLoggingConfigurationOutput struct {
                                                                                                        
                                                                                                        	// The LoggingConfiguration for the specified web ACL.
                                                                                                        	LoggingConfiguration *types.LoggingConfiguration
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type GetPermissionPolicyInput

                                                                                                        type GetPermissionPolicyInput struct {
                                                                                                        
                                                                                                        	// The Amazon Resource Name (ARN) of the rule group for which you want to get the
                                                                                                        	// policy.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	ResourceArn *string
                                                                                                        }

                                                                                                        type GetPermissionPolicyOutput

                                                                                                        type GetPermissionPolicyOutput struct {
                                                                                                        
                                                                                                        	// The IAM policy that is attached to the specified rule group.
                                                                                                        	Policy *string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type GetRateBasedStatementManagedKeysInput

                                                                                                        type GetRateBasedStatementManagedKeysInput struct {
                                                                                                        
                                                                                                        	// The name of the rate-based rule to get the keys for.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	RuleName *string
                                                                                                        
                                                                                                        	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                        	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                        	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                        	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                        	//
                                                                                                        	// * CLI - Specify
                                                                                                        	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                        	// --region=us-east-1.
                                                                                                        	//
                                                                                                        	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                        	// us-east-1.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Scope types.Scope
                                                                                                        
                                                                                                        	// The unique identifier for the Web ACL. This ID is returned in the responses to
                                                                                                        	// create and list commands. You provide it to operations like update and delete.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	WebACLId *string
                                                                                                        
                                                                                                        	// The name of the Web ACL. You cannot change the name of a Web ACL after you
                                                                                                        	// create it.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	WebACLName *string
                                                                                                        }

                                                                                                        type GetRateBasedStatementManagedKeysOutput

                                                                                                        type GetRateBasedStatementManagedKeysOutput struct {
                                                                                                        
                                                                                                        	// The keys that are of Internet Protocol version 4 (IPv4).
                                                                                                        	ManagedKeysIPV4 *types.RateBasedStatementManagedKeysIPSet
                                                                                                        
                                                                                                        	// The keys that are of Internet Protocol version 6 (IPv6).
                                                                                                        	ManagedKeysIPV6 *types.RateBasedStatementManagedKeysIPSet
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type GetRegexPatternSetInput

                                                                                                        type GetRegexPatternSetInput struct {
                                                                                                        
                                                                                                        	// A unique identifier for the set. This ID is returned in the responses to create
                                                                                                        	// and list commands. You provide it to operations like update and delete.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Id *string
                                                                                                        
                                                                                                        	// The name of the set. You cannot change the name after you create the set.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Name *string
                                                                                                        
                                                                                                        	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                        	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                        	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                        	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                        	//
                                                                                                        	// * CLI - Specify
                                                                                                        	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                        	// --region=us-east-1.
                                                                                                        	//
                                                                                                        	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                        	// us-east-1.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Scope types.Scope
                                                                                                        }

                                                                                                        type GetRegexPatternSetOutput

                                                                                                        type GetRegexPatternSetOutput struct {
                                                                                                        
                                                                                                        	// A token used for optimistic locking. AWS WAF returns a token to your get and
                                                                                                        	// list requests, to mark the state of the entity at the time of the request. To
                                                                                                        	// make changes to the entity associated with the token, you provide the token to
                                                                                                        	// operations like update and delete. AWS WAF uses the token to ensure that no
                                                                                                        	// changes have been made to the entity since you last retrieved it. If a change
                                                                                                        	// has been made, the update fails with a WAFOptimisticLockException. If this
                                                                                                        	// happens, perform another get, and use the new token returned by that operation.
                                                                                                        	LockToken *string
                                                                                                        
                                                                                                        	//
                                                                                                        	RegexPatternSet *types.RegexPatternSet
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type GetRuleGroupInput

                                                                                                        type GetRuleGroupInput struct {
                                                                                                        
                                                                                                        	// A unique identifier for the rule group. This ID is returned in the responses to
                                                                                                        	// create and list commands. You provide it to operations like update and delete.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Id *string
                                                                                                        
                                                                                                        	// The name of the rule group. You cannot change the name of a rule group after you
                                                                                                        	// create it.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Name *string
                                                                                                        
                                                                                                        	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                        	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                        	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                        	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                        	//
                                                                                                        	// * CLI - Specify
                                                                                                        	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                        	// --region=us-east-1.
                                                                                                        	//
                                                                                                        	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                        	// us-east-1.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Scope types.Scope
                                                                                                        }

                                                                                                        type GetRuleGroupOutput

                                                                                                        type GetRuleGroupOutput struct {
                                                                                                        
                                                                                                        	// A token used for optimistic locking. AWS WAF returns a token to your get and
                                                                                                        	// list requests, to mark the state of the entity at the time of the request. To
                                                                                                        	// make changes to the entity associated with the token, you provide the token to
                                                                                                        	// operations like update and delete. AWS WAF uses the token to ensure that no
                                                                                                        	// changes have been made to the entity since you last retrieved it. If a change
                                                                                                        	// has been made, the update fails with a WAFOptimisticLockException. If this
                                                                                                        	// happens, perform another get, and use the new token returned by that operation.
                                                                                                        	LockToken *string
                                                                                                        
                                                                                                        	//
                                                                                                        	RuleGroup *types.RuleGroup
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type GetSampledRequestsInput

                                                                                                        type GetSampledRequestsInput struct {
                                                                                                        
                                                                                                        	// The number of requests that you want AWS WAF to return from among the first
                                                                                                        	// 5,000 requests that your AWS resource received during the time range. If your
                                                                                                        	// resource received fewer requests than the value of MaxItems, GetSampledRequests
                                                                                                        	// returns information about all of them.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	MaxItems int64
                                                                                                        
                                                                                                        	// The metric name assigned to the Rule or RuleGroup for which you want a sample of
                                                                                                        	// requests.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	RuleMetricName *string
                                                                                                        
                                                                                                        	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                        	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                        	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                        	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                        	//
                                                                                                        	// * CLI - Specify
                                                                                                        	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                        	// --region=us-east-1.
                                                                                                        	//
                                                                                                        	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                        	// us-east-1.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Scope types.Scope
                                                                                                        
                                                                                                        	// The start date and time and the end date and time of the range for which you
                                                                                                        	// want GetSampledRequests to return a sample of requests. You must specify the
                                                                                                        	// times in Coordinated Universal Time (UTC) format. UTC format includes the
                                                                                                        	// special designator, Z. For example, "2016-09-27T14:50Z". You can specify any
                                                                                                        	// time range in the previous three hours. If you specify a start time that's
                                                                                                        	// earlier than three hours ago, AWS WAF sets it to three hours ago.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	TimeWindow *types.TimeWindow
                                                                                                        
                                                                                                        	// The Amazon resource name (ARN) of the WebACL for which you want a sample of
                                                                                                        	// requests.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	WebAclArn *string
                                                                                                        }

                                                                                                        type GetSampledRequestsOutput

                                                                                                        type GetSampledRequestsOutput struct {
                                                                                                        
                                                                                                        	// The total number of requests from which GetSampledRequests got a sample of
                                                                                                        	// MaxItems requests. If PopulationSize is less than MaxItems, the sample includes
                                                                                                        	// every request that your AWS resource received during the specified time range.
                                                                                                        	PopulationSize int64
                                                                                                        
                                                                                                        	// A complex type that contains detailed information about each of the requests in
                                                                                                        	// the sample.
                                                                                                        	SampledRequests []types.SampledHTTPRequest
                                                                                                        
                                                                                                        	// Usually, TimeWindow is the time range that you specified in the
                                                                                                        	// GetSampledRequests request. However, if your AWS resource received more than
                                                                                                        	// 5,000 requests during the time range that you specified in the request,
                                                                                                        	// GetSampledRequests returns the time range for the first 5,000 requests. Times
                                                                                                        	// are in Coordinated Universal Time (UTC) format.
                                                                                                        	TimeWindow *types.TimeWindow
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type GetWebACLForResourceInput

                                                                                                        type GetWebACLForResourceInput struct {
                                                                                                        
                                                                                                        	// The ARN (Amazon Resource Name) of the resource.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	ResourceArn *string
                                                                                                        }

                                                                                                        type GetWebACLForResourceOutput

                                                                                                        type GetWebACLForResourceOutput struct {
                                                                                                        
                                                                                                        	// The Web ACL that is associated with the resource. If there is no associated
                                                                                                        	// resource, AWS WAF returns a null Web ACL.
                                                                                                        	WebACL *types.WebACL
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type GetWebACLInput

                                                                                                        type GetWebACLInput struct {
                                                                                                        
                                                                                                        	// The unique identifier for the Web ACL. This ID is returned in the responses to
                                                                                                        	// create and list commands. You provide it to operations like update and delete.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Id *string
                                                                                                        
                                                                                                        	// The name of the Web ACL. You cannot change the name of a Web ACL after you
                                                                                                        	// create it.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Name *string
                                                                                                        
                                                                                                        	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                        	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                        	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                        	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                        	//
                                                                                                        	// * CLI - Specify
                                                                                                        	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                        	// --region=us-east-1.
                                                                                                        	//
                                                                                                        	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                        	// us-east-1.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Scope types.Scope
                                                                                                        }

                                                                                                        type GetWebACLOutput

                                                                                                        type GetWebACLOutput struct {
                                                                                                        
                                                                                                        	// A token used for optimistic locking. AWS WAF returns a token to your get and
                                                                                                        	// list requests, to mark the state of the entity at the time of the request. To
                                                                                                        	// make changes to the entity associated with the token, you provide the token to
                                                                                                        	// operations like update and delete. AWS WAF uses the token to ensure that no
                                                                                                        	// changes have been made to the entity since you last retrieved it. If a change
                                                                                                        	// has been made, the update fails with a WAFOptimisticLockException. If this
                                                                                                        	// happens, perform another get, and use the new token returned by that operation.
                                                                                                        	LockToken *string
                                                                                                        
                                                                                                        	// The Web ACL specification. You can modify the settings in this Web ACL and use
                                                                                                        	// it to update this Web ACL or create a new one.
                                                                                                        	WebACL *types.WebACL
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type HTTPClient

                                                                                                        type HTTPClient interface {
                                                                                                        	Do(*http.Request) (*http.Response, error)
                                                                                                        }

                                                                                                        type HTTPSignerV4

                                                                                                        type HTTPSignerV4 interface {
                                                                                                        	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
                                                                                                        }

                                                                                                        type ListAvailableManagedRuleGroupsInput

                                                                                                        type ListAvailableManagedRuleGroupsInput struct {
                                                                                                        
                                                                                                        	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                        	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                        	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                        	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                        	//
                                                                                                        	// * CLI - Specify
                                                                                                        	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                        	// --region=us-east-1.
                                                                                                        	//
                                                                                                        	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                        	// us-east-1.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Scope types.Scope
                                                                                                        
                                                                                                        	// The maximum number of objects that you want AWS WAF to return for this request.
                                                                                                        	// If more objects are available, in the response, AWS WAF provides a NextMarker
                                                                                                        	// value that you can use in a subsequent call to get the next batch of objects.
                                                                                                        	Limit *int32
                                                                                                        
                                                                                                        	// When you request a list of objects with a Limit setting, if the number of
                                                                                                        	// objects that are still available for retrieval exceeds the limit, AWS WAF
                                                                                                        	// returns a NextMarker value in the response. To retrieve the next batch of
                                                                                                        	// objects, provide the marker from the prior call in your next request.
                                                                                                        	NextMarker *string
                                                                                                        }

                                                                                                        type ListAvailableManagedRuleGroupsOutput

                                                                                                        type ListAvailableManagedRuleGroupsOutput struct {
                                                                                                        
                                                                                                        	//
                                                                                                        	ManagedRuleGroups []types.ManagedRuleGroupSummary
                                                                                                        
                                                                                                        	// When you request a list of objects with a Limit setting, if the number of
                                                                                                        	// objects that are still available for retrieval exceeds the limit, AWS WAF
                                                                                                        	// returns a NextMarker value in the response. To retrieve the next batch of
                                                                                                        	// objects, provide the marker from the prior call in your next request.
                                                                                                        	NextMarker *string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListIPSetsInput

                                                                                                        type ListIPSetsInput struct {
                                                                                                        
                                                                                                        	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                        	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                        	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                        	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                        	//
                                                                                                        	// * CLI - Specify
                                                                                                        	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                        	// --region=us-east-1.
                                                                                                        	//
                                                                                                        	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                        	// us-east-1.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Scope types.Scope
                                                                                                        
                                                                                                        	// The maximum number of objects that you want AWS WAF to return for this request.
                                                                                                        	// If more objects are available, in the response, AWS WAF provides a NextMarker
                                                                                                        	// value that you can use in a subsequent call to get the next batch of objects.
                                                                                                        	Limit *int32
                                                                                                        
                                                                                                        	// When you request a list of objects with a Limit setting, if the number of
                                                                                                        	// objects that are still available for retrieval exceeds the limit, AWS WAF
                                                                                                        	// returns a NextMarker value in the response. To retrieve the next batch of
                                                                                                        	// objects, provide the marker from the prior call in your next request.
                                                                                                        	NextMarker *string
                                                                                                        }

                                                                                                        type ListIPSetsOutput

                                                                                                        type ListIPSetsOutput struct {
                                                                                                        
                                                                                                        	// Array of IPSets. This may not be the full list of IPSets that you have defined.
                                                                                                        	// See the Limit specification for this request.
                                                                                                        	IPSets []types.IPSetSummary
                                                                                                        
                                                                                                        	// When you request a list of objects with a Limit setting, if the number of
                                                                                                        	// objects that are still available for retrieval exceeds the limit, AWS WAF
                                                                                                        	// returns a NextMarker value in the response. To retrieve the next batch of
                                                                                                        	// objects, provide the marker from the prior call in your next request.
                                                                                                        	NextMarker *string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListLoggingConfigurationsInput

                                                                                                        type ListLoggingConfigurationsInput struct {
                                                                                                        
                                                                                                        	// The maximum number of objects that you want AWS WAF to return for this request.
                                                                                                        	// If more objects are available, in the response, AWS WAF provides a NextMarker
                                                                                                        	// value that you can use in a subsequent call to get the next batch of objects.
                                                                                                        	Limit *int32
                                                                                                        
                                                                                                        	// When you request a list of objects with a Limit setting, if the number of
                                                                                                        	// objects that are still available for retrieval exceeds the limit, AWS WAF
                                                                                                        	// returns a NextMarker value in the response. To retrieve the next batch of
                                                                                                        	// objects, provide the marker from the prior call in your next request.
                                                                                                        	NextMarker *string
                                                                                                        
                                                                                                        	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                        	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                        	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                        	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                        	//
                                                                                                        	// * CLI - Specify
                                                                                                        	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                        	// --region=us-east-1.
                                                                                                        	//
                                                                                                        	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                        	// us-east-1.
                                                                                                        	Scope types.Scope
                                                                                                        }

                                                                                                        type ListLoggingConfigurationsOutput

                                                                                                        type ListLoggingConfigurationsOutput struct {
                                                                                                        
                                                                                                        	//
                                                                                                        	LoggingConfigurations []types.LoggingConfiguration
                                                                                                        
                                                                                                        	// When you request a list of objects with a Limit setting, if the number of
                                                                                                        	// objects that are still available for retrieval exceeds the limit, AWS WAF
                                                                                                        	// returns a NextMarker value in the response. To retrieve the next batch of
                                                                                                        	// objects, provide the marker from the prior call in your next request.
                                                                                                        	NextMarker *string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListRegexPatternSetsInput

                                                                                                        type ListRegexPatternSetsInput struct {
                                                                                                        
                                                                                                        	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                        	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                        	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                        	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                        	//
                                                                                                        	// * CLI - Specify
                                                                                                        	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                        	// --region=us-east-1.
                                                                                                        	//
                                                                                                        	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                        	// us-east-1.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Scope types.Scope
                                                                                                        
                                                                                                        	// The maximum number of objects that you want AWS WAF to return for this request.
                                                                                                        	// If more objects are available, in the response, AWS WAF provides a NextMarker
                                                                                                        	// value that you can use in a subsequent call to get the next batch of objects.
                                                                                                        	Limit *int32
                                                                                                        
                                                                                                        	// When you request a list of objects with a Limit setting, if the number of
                                                                                                        	// objects that are still available for retrieval exceeds the limit, AWS WAF
                                                                                                        	// returns a NextMarker value in the response. To retrieve the next batch of
                                                                                                        	// objects, provide the marker from the prior call in your next request.
                                                                                                        	NextMarker *string
                                                                                                        }

                                                                                                        type ListRegexPatternSetsOutput

                                                                                                        type ListRegexPatternSetsOutput struct {
                                                                                                        
                                                                                                        	// When you request a list of objects with a Limit setting, if the number of
                                                                                                        	// objects that are still available for retrieval exceeds the limit, AWS WAF
                                                                                                        	// returns a NextMarker value in the response. To retrieve the next batch of
                                                                                                        	// objects, provide the marker from the prior call in your next request.
                                                                                                        	NextMarker *string
                                                                                                        
                                                                                                        	//
                                                                                                        	RegexPatternSets []types.RegexPatternSetSummary
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListResourcesForWebACLInput

                                                                                                        type ListResourcesForWebACLInput struct {
                                                                                                        
                                                                                                        	// The Amazon Resource Name (ARN) of the Web ACL.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	WebACLArn *string
                                                                                                        
                                                                                                        	// Used for web ACLs that are scoped for regional applications. A regional
                                                                                                        	// application can be an Application Load Balancer (ALB), an API Gateway REST API,
                                                                                                        	// or an AppSync GraphQL API.
                                                                                                        	ResourceType types.ResourceType
                                                                                                        }

                                                                                                        type ListResourcesForWebACLOutput

                                                                                                        type ListResourcesForWebACLOutput struct {
                                                                                                        
                                                                                                        	// The array of Amazon Resource Names (ARNs) of the associated resources.
                                                                                                        	ResourceArns []string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListRuleGroupsInput

                                                                                                        type ListRuleGroupsInput struct {
                                                                                                        
                                                                                                        	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                        	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                        	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                        	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                        	//
                                                                                                        	// * CLI - Specify
                                                                                                        	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                        	// --region=us-east-1.
                                                                                                        	//
                                                                                                        	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                        	// us-east-1.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Scope types.Scope
                                                                                                        
                                                                                                        	// The maximum number of objects that you want AWS WAF to return for this request.
                                                                                                        	// If more objects are available, in the response, AWS WAF provides a NextMarker
                                                                                                        	// value that you can use in a subsequent call to get the next batch of objects.
                                                                                                        	Limit *int32
                                                                                                        
                                                                                                        	// When you request a list of objects with a Limit setting, if the number of
                                                                                                        	// objects that are still available for retrieval exceeds the limit, AWS WAF
                                                                                                        	// returns a NextMarker value in the response. To retrieve the next batch of
                                                                                                        	// objects, provide the marker from the prior call in your next request.
                                                                                                        	NextMarker *string
                                                                                                        }

                                                                                                        type ListRuleGroupsOutput

                                                                                                        type ListRuleGroupsOutput struct {
                                                                                                        
                                                                                                        	// When you request a list of objects with a Limit setting, if the number of
                                                                                                        	// objects that are still available for retrieval exceeds the limit, AWS WAF
                                                                                                        	// returns a NextMarker value in the response. To retrieve the next batch of
                                                                                                        	// objects, provide the marker from the prior call in your next request.
                                                                                                        	NextMarker *string
                                                                                                        
                                                                                                        	//
                                                                                                        	RuleGroups []types.RuleGroupSummary
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListTagsForResourceInput

                                                                                                        type ListTagsForResourceInput struct {
                                                                                                        
                                                                                                        	// The Amazon Resource Name (ARN) of the resource.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	ResourceARN *string
                                                                                                        
                                                                                                        	// The maximum number of objects that you want AWS WAF to return for this request.
                                                                                                        	// If more objects are available, in the response, AWS WAF provides a NextMarker
                                                                                                        	// value that you can use in a subsequent call to get the next batch of objects.
                                                                                                        	Limit *int32
                                                                                                        
                                                                                                        	// When you request a list of objects with a Limit setting, if the number of
                                                                                                        	// objects that are still available for retrieval exceeds the limit, AWS WAF
                                                                                                        	// returns a NextMarker value in the response. To retrieve the next batch of
                                                                                                        	// objects, provide the marker from the prior call in your next request.
                                                                                                        	NextMarker *string
                                                                                                        }

                                                                                                        type ListTagsForResourceOutput

                                                                                                        type ListTagsForResourceOutput struct {
                                                                                                        
                                                                                                        	// When you request a list of objects with a Limit setting, if the number of
                                                                                                        	// objects that are still available for retrieval exceeds the limit, AWS WAF
                                                                                                        	// returns a NextMarker value in the response. To retrieve the next batch of
                                                                                                        	// objects, provide the marker from the prior call in your next request.
                                                                                                        	NextMarker *string
                                                                                                        
                                                                                                        	// The collection of tagging definitions for the resource.
                                                                                                        	TagInfoForResource *types.TagInfoForResource
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListWebACLsInput

                                                                                                        type ListWebACLsInput struct {
                                                                                                        
                                                                                                        	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                        	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                        	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                        	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                        	//
                                                                                                        	// * CLI - Specify
                                                                                                        	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                        	// --region=us-east-1.
                                                                                                        	//
                                                                                                        	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                        	// us-east-1.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Scope types.Scope
                                                                                                        
                                                                                                        	// The maximum number of objects that you want AWS WAF to return for this request.
                                                                                                        	// If more objects are available, in the response, AWS WAF provides a NextMarker
                                                                                                        	// value that you can use in a subsequent call to get the next batch of objects.
                                                                                                        	Limit *int32
                                                                                                        
                                                                                                        	// When you request a list of objects with a Limit setting, if the number of
                                                                                                        	// objects that are still available for retrieval exceeds the limit, AWS WAF
                                                                                                        	// returns a NextMarker value in the response. To retrieve the next batch of
                                                                                                        	// objects, provide the marker from the prior call in your next request.
                                                                                                        	NextMarker *string
                                                                                                        }

                                                                                                        type ListWebACLsOutput

                                                                                                        type ListWebACLsOutput struct {
                                                                                                        
                                                                                                        	// When you request a list of objects with a Limit setting, if the number of
                                                                                                        	// objects that are still available for retrieval exceeds the limit, AWS WAF
                                                                                                        	// returns a NextMarker value in the response. To retrieve the next batch of
                                                                                                        	// objects, provide the marker from the prior call in your next request.
                                                                                                        	NextMarker *string
                                                                                                        
                                                                                                        	//
                                                                                                        	WebACLs []types.WebACLSummary
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type Options

                                                                                                        type Options struct {
                                                                                                        	// Set of options to modify how an operation is invoked. These apply to all
                                                                                                        	// operations invoked for this client. Use functional options on operation call to
                                                                                                        	// modify this list for per operation behavior.
                                                                                                        	APIOptions []func(*middleware.Stack) error
                                                                                                        
                                                                                                        	// Configures the events that will be sent to the configured logger.
                                                                                                        	ClientLogMode aws.ClientLogMode
                                                                                                        
                                                                                                        	// The credentials object to use when signing requests.
                                                                                                        	Credentials aws.CredentialsProvider
                                                                                                        
                                                                                                        	// The endpoint options to be used when attempting to resolve an endpoint.
                                                                                                        	EndpointOptions EndpointResolverOptions
                                                                                                        
                                                                                                        	// The service endpoint resolver.
                                                                                                        	EndpointResolver EndpointResolver
                                                                                                        
                                                                                                        	// Signature Version 4 (SigV4) Signer
                                                                                                        	HTTPSignerV4 HTTPSignerV4
                                                                                                        
                                                                                                        	// The logger writer interface to write logging messages to.
                                                                                                        	Logger logging.Logger
                                                                                                        
                                                                                                        	// The region to send requests to. (Required)
                                                                                                        	Region string
                                                                                                        
                                                                                                        	// Retryer guides how HTTP requests should be retried in case of recoverable
                                                                                                        	// failures. When nil the API client will use a default retryer.
                                                                                                        	Retryer aws.Retryer
                                                                                                        
                                                                                                        	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
                                                                                                        	// implementation if nil.
                                                                                                        	HTTPClient HTTPClient
                                                                                                        }

                                                                                                        func (Options) Copy

                                                                                                        func (o Options) Copy() Options

                                                                                                          Copy creates a clone where the APIOptions list is deep copied.

                                                                                                          type PutLoggingConfigurationInput

                                                                                                          type PutLoggingConfigurationInput struct {
                                                                                                          
                                                                                                          	//
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	LoggingConfiguration *types.LoggingConfiguration
                                                                                                          }

                                                                                                          type PutLoggingConfigurationOutput

                                                                                                          type PutLoggingConfigurationOutput struct {
                                                                                                          
                                                                                                          	//
                                                                                                          	LoggingConfiguration *types.LoggingConfiguration
                                                                                                          
                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                          }

                                                                                                          type PutPermissionPolicyInput

                                                                                                          type PutPermissionPolicyInput struct {
                                                                                                          
                                                                                                          	// The policy to attach to the specified rule group. The policy specifications must
                                                                                                          	// conform to the following:
                                                                                                          	//
                                                                                                          	// * The policy must be composed using IAM Policy
                                                                                                          	// version 2012-10-17 or version 2015-01-01.
                                                                                                          	//
                                                                                                          	// * The policy must include
                                                                                                          	// specifications for Effect, Action, and Principal.
                                                                                                          	//
                                                                                                          	// * Effect must specify
                                                                                                          	// Allow.
                                                                                                          	//
                                                                                                          	// * Action must specify wafv2:CreateWebACL, wafv2:UpdateWebACL, and
                                                                                                          	// wafv2:PutFirewallManagerRuleGroups. AWS WAF rejects any extra actions or
                                                                                                          	// wildcard actions in the policy.
                                                                                                          	//
                                                                                                          	// * The policy must not include a Resource
                                                                                                          	// parameter.
                                                                                                          	//
                                                                                                          	// For more information, see IAM Policies
                                                                                                          	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html).
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	Policy *string
                                                                                                          
                                                                                                          	// The Amazon Resource Name (ARN) of the RuleGroup to which you want to attach the
                                                                                                          	// policy.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	ResourceArn *string
                                                                                                          }

                                                                                                          type PutPermissionPolicyOutput

                                                                                                          type PutPermissionPolicyOutput struct {
                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                          }

                                                                                                          type ResolveEndpoint

                                                                                                          type ResolveEndpoint struct {
                                                                                                          	Resolver EndpointResolver
                                                                                                          	Options  EndpointResolverOptions
                                                                                                          }

                                                                                                          func (*ResolveEndpoint) HandleSerialize

                                                                                                          func (*ResolveEndpoint) ID

                                                                                                          func (*ResolveEndpoint) ID() string

                                                                                                          type TagResourceInput

                                                                                                          type TagResourceInput struct {
                                                                                                          
                                                                                                          	// The Amazon Resource Name (ARN) of the resource.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	ResourceARN *string
                                                                                                          
                                                                                                          	// An array of key:value pairs to associate with the resource.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	Tags []types.Tag
                                                                                                          }

                                                                                                          type TagResourceOutput

                                                                                                          type TagResourceOutput struct {
                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                          }

                                                                                                          type UntagResourceInput

                                                                                                          type UntagResourceInput struct {
                                                                                                          
                                                                                                          	// The Amazon Resource Name (ARN) of the resource.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	ResourceARN *string
                                                                                                          
                                                                                                          	// An array of keys identifying the tags to disassociate from the resource.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	TagKeys []string
                                                                                                          }

                                                                                                          type UntagResourceOutput

                                                                                                          type UntagResourceOutput struct {
                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                          }

                                                                                                          type UpdateIPSetInput

                                                                                                          type UpdateIPSetInput struct {
                                                                                                          
                                                                                                          	// Contains an array of strings that specify one or more IP addresses or blocks of
                                                                                                          	// IP addresses in Classless Inter-Domain Routing (CIDR) notation. AWS WAF supports
                                                                                                          	// all IPv4 and IPv6 CIDR ranges except for /0. Examples:
                                                                                                          	//
                                                                                                          	// * To configure AWS WAF
                                                                                                          	// to allow, block, or count requests that originated from the IP address
                                                                                                          	// 192.0.2.44, specify 192.0.2.44/32.
                                                                                                          	//
                                                                                                          	// * To configure AWS WAF to allow, block, or
                                                                                                          	// count requests that originated from IP addresses from 192.0.2.0 to 192.0.2.255,
                                                                                                          	// specify 192.0.2.0/24.
                                                                                                          	//
                                                                                                          	// * To configure AWS WAF to allow, block, or count requests
                                                                                                          	// that originated from the IP address 1111:0000:0000:0000:0000:0000:0000:0111,
                                                                                                          	// specify 1111:0000:0000:0000:0000:0000:0000:0111/128.
                                                                                                          	//
                                                                                                          	// * To configure AWS WAF to
                                                                                                          	// allow, block, or count requests that originated from IP addresses
                                                                                                          	// 1111:0000:0000:0000:0000:0000:0000:0000 to
                                                                                                          	// 1111:0000:0000:0000:ffff:ffff:ffff:ffff, specify
                                                                                                          	// 1111:0000:0000:0000:0000:0000:0000:0000/64.
                                                                                                          	//
                                                                                                          	// For more information about CIDR
                                                                                                          	// notation, see the Wikipedia entry Classless Inter-Domain Routing
                                                                                                          	// (https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing).
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	Addresses []string
                                                                                                          
                                                                                                          	// A unique identifier for the set. This ID is returned in the responses to create
                                                                                                          	// and list commands. You provide it to operations like update and delete.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	Id *string
                                                                                                          
                                                                                                          	// A token used for optimistic locking. AWS WAF returns a token to your get and
                                                                                                          	// list requests, to mark the state of the entity at the time of the request. To
                                                                                                          	// make changes to the entity associated with the token, you provide the token to
                                                                                                          	// operations like update and delete. AWS WAF uses the token to ensure that no
                                                                                                          	// changes have been made to the entity since you last retrieved it. If a change
                                                                                                          	// has been made, the update fails with a WAFOptimisticLockException. If this
                                                                                                          	// happens, perform another get, and use the new token returned by that operation.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	LockToken *string
                                                                                                          
                                                                                                          	// The name of the IP set. You cannot change the name of an IPSet after you create
                                                                                                          	// it.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	Name *string
                                                                                                          
                                                                                                          	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                          	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                          	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                          	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                          	//
                                                                                                          	// * CLI - Specify
                                                                                                          	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                          	// --region=us-east-1.
                                                                                                          	//
                                                                                                          	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                          	// us-east-1.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	Scope types.Scope
                                                                                                          
                                                                                                          	// A description of the IP set that helps with identification.
                                                                                                          	Description *string
                                                                                                          }

                                                                                                          type UpdateIPSetOutput

                                                                                                          type UpdateIPSetOutput struct {
                                                                                                          
                                                                                                          	// A token used for optimistic locking. AWS WAF returns this token to your update
                                                                                                          	// requests. You use NextLockToken in the same manner as you use LockToken.
                                                                                                          	NextLockToken *string
                                                                                                          
                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                          }

                                                                                                          type UpdateRegexPatternSetInput

                                                                                                          type UpdateRegexPatternSetInput struct {
                                                                                                          
                                                                                                          	// A unique identifier for the set. This ID is returned in the responses to create
                                                                                                          	// and list commands. You provide it to operations like update and delete.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	Id *string
                                                                                                          
                                                                                                          	// A token used for optimistic locking. AWS WAF returns a token to your get and
                                                                                                          	// list requests, to mark the state of the entity at the time of the request. To
                                                                                                          	// make changes to the entity associated with the token, you provide the token to
                                                                                                          	// operations like update and delete. AWS WAF uses the token to ensure that no
                                                                                                          	// changes have been made to the entity since you last retrieved it. If a change
                                                                                                          	// has been made, the update fails with a WAFOptimisticLockException. If this
                                                                                                          	// happens, perform another get, and use the new token returned by that operation.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	LockToken *string
                                                                                                          
                                                                                                          	// The name of the set. You cannot change the name after you create the set.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	Name *string
                                                                                                          
                                                                                                          	//
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	RegularExpressionList []types.Regex
                                                                                                          
                                                                                                          	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                          	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                          	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                          	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                          	//
                                                                                                          	// * CLI - Specify
                                                                                                          	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                          	// --region=us-east-1.
                                                                                                          	//
                                                                                                          	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                          	// us-east-1.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	Scope types.Scope
                                                                                                          
                                                                                                          	// A description of the set that helps with identification.
                                                                                                          	Description *string
                                                                                                          }

                                                                                                          type UpdateRegexPatternSetOutput

                                                                                                          type UpdateRegexPatternSetOutput struct {
                                                                                                          
                                                                                                          	// A token used for optimistic locking. AWS WAF returns this token to your update
                                                                                                          	// requests. You use NextLockToken in the same manner as you use LockToken.
                                                                                                          	NextLockToken *string
                                                                                                          
                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                          }

                                                                                                          type UpdateRuleGroupInput

                                                                                                          type UpdateRuleGroupInput struct {
                                                                                                          
                                                                                                          	// A unique identifier for the rule group. This ID is returned in the responses to
                                                                                                          	// create and list commands. You provide it to operations like update and delete.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	Id *string
                                                                                                          
                                                                                                          	// A token used for optimistic locking. AWS WAF returns a token to your get and
                                                                                                          	// list requests, to mark the state of the entity at the time of the request. To
                                                                                                          	// make changes to the entity associated with the token, you provide the token to
                                                                                                          	// operations like update and delete. AWS WAF uses the token to ensure that no
                                                                                                          	// changes have been made to the entity since you last retrieved it. If a change
                                                                                                          	// has been made, the update fails with a WAFOptimisticLockException. If this
                                                                                                          	// happens, perform another get, and use the new token returned by that operation.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	LockToken *string
                                                                                                          
                                                                                                          	// The name of the rule group. You cannot change the name of a rule group after you
                                                                                                          	// create it.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	Name *string
                                                                                                          
                                                                                                          	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                          	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                          	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                          	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                          	//
                                                                                                          	// * CLI - Specify
                                                                                                          	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                          	// --region=us-east-1.
                                                                                                          	//
                                                                                                          	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                          	// us-east-1.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	Scope types.Scope
                                                                                                          
                                                                                                          	// Defines and enables Amazon CloudWatch metrics and web request sample collection.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	VisibilityConfig *types.VisibilityConfig
                                                                                                          
                                                                                                          	// A map of custom response keys and content bodies. When you create a rule with a
                                                                                                          	// block action, you can send a custom response to the web request. You define
                                                                                                          	// these for the rule group, and then use them in the rules that you define in the
                                                                                                          	// rule group. For information about customizing web requests and responses, see
                                                                                                          	// Customizing web requests and responses in AWS WAF
                                                                                                          	// (https://docs.aws.amazon.com/waf/latest/developerguide/waf-custom-request-response.html)
                                                                                                          	// in the AWS WAF Developer Guide
                                                                                                          	// (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html). For
                                                                                                          	// information about the limits on count and size for custom request and response
                                                                                                          	// settings, see AWS WAF quotas
                                                                                                          	// (https://docs.aws.amazon.com/waf/latest/developerguide/limits.html) in the AWS
                                                                                                          	// WAF Developer Guide
                                                                                                          	// (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
                                                                                                          	CustomResponseBodies map[string]types.CustomResponseBody
                                                                                                          
                                                                                                          	// A description of the rule group that helps with identification.
                                                                                                          	Description *string
                                                                                                          
                                                                                                          	// The Rule statements used to identify the web requests that you want to allow,
                                                                                                          	// block, or count. Each rule includes one top-level statement that AWS WAF uses to
                                                                                                          	// identify matching web requests, and parameters that govern how AWS WAF handles
                                                                                                          	// them.
                                                                                                          	Rules []types.Rule
                                                                                                          }

                                                                                                          type UpdateRuleGroupOutput

                                                                                                          type UpdateRuleGroupOutput struct {
                                                                                                          
                                                                                                          	// A token used for optimistic locking. AWS WAF returns this token to your update
                                                                                                          	// requests. You use NextLockToken in the same manner as you use LockToken.
                                                                                                          	NextLockToken *string
                                                                                                          
                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                          }

                                                                                                          type UpdateWebACLInput

                                                                                                          type UpdateWebACLInput struct {
                                                                                                          
                                                                                                          	// The action to perform if none of the Rules contained in the WebACL match.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	DefaultAction *types.DefaultAction
                                                                                                          
                                                                                                          	// The unique identifier for the Web ACL. This ID is returned in the responses to
                                                                                                          	// create and list commands. You provide it to operations like update and delete.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	Id *string
                                                                                                          
                                                                                                          	// A token used for optimistic locking. AWS WAF returns a token to your get and
                                                                                                          	// list requests, to mark the state of the entity at the time of the request. To
                                                                                                          	// make changes to the entity associated with the token, you provide the token to
                                                                                                          	// operations like update and delete. AWS WAF uses the token to ensure that no
                                                                                                          	// changes have been made to the entity since you last retrieved it. If a change
                                                                                                          	// has been made, the update fails with a WAFOptimisticLockException. If this
                                                                                                          	// happens, perform another get, and use the new token returned by that operation.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	LockToken *string
                                                                                                          
                                                                                                          	// The name of the Web ACL. You cannot change the name of a Web ACL after you
                                                                                                          	// create it.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	Name *string
                                                                                                          
                                                                                                          	// Specifies whether this is for an AWS CloudFront distribution or for a regional
                                                                                                          	// application. A regional application can be an Application Load Balancer (ALB),
                                                                                                          	// an API Gateway REST API, or an AppSync GraphQL API. To work with CloudFront, you
                                                                                                          	// must also specify the Region US East (N. Virginia) as follows:
                                                                                                          	//
                                                                                                          	// * CLI - Specify
                                                                                                          	// the Region when you use the CloudFront scope: --scope=CLOUDFRONT
                                                                                                          	// --region=us-east-1.
                                                                                                          	//
                                                                                                          	// * API and SDKs - For all calls, use the Region endpoint
                                                                                                          	// us-east-1.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	Scope types.Scope
                                                                                                          
                                                                                                          	// Defines and enables Amazon CloudWatch metrics and web request sample collection.
                                                                                                          	//
                                                                                                          	// This member is required.
                                                                                                          	VisibilityConfig *types.VisibilityConfig
                                                                                                          
                                                                                                          	// A map of custom response keys and content bodies. When you create a rule with a
                                                                                                          	// block action, you can send a custom response to the web request. You define
                                                                                                          	// these for the web ACL, and then use them in the rules and default actions that
                                                                                                          	// you define in the web ACL. For information about customizing web requests and
                                                                                                          	// responses, see Customizing web requests and responses in AWS WAF
                                                                                                          	// (https://docs.aws.amazon.com/waf/latest/developerguide/waf-custom-request-response.html)
                                                                                                          	// in the AWS WAF Developer Guide
                                                                                                          	// (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html). For
                                                                                                          	// information about the limits on count and size for custom request and response
                                                                                                          	// settings, see AWS WAF quotas
                                                                                                          	// (https://docs.aws.amazon.com/waf/latest/developerguide/limits.html) in the AWS
                                                                                                          	// WAF Developer Guide
                                                                                                          	// (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
                                                                                                          	CustomResponseBodies map[string]types.CustomResponseBody
                                                                                                          
                                                                                                          	// A description of the Web ACL that helps with identification.
                                                                                                          	Description *string
                                                                                                          
                                                                                                          	// The Rule statements used to identify the web requests that you want to allow,
                                                                                                          	// block, or count. Each rule includes one top-level statement that AWS WAF uses to
                                                                                                          	// identify matching web requests, and parameters that govern how AWS WAF handles
                                                                                                          	// them.
                                                                                                          	Rules []types.Rule
                                                                                                          }

                                                                                                          type UpdateWebACLOutput

                                                                                                          type UpdateWebACLOutput struct {
                                                                                                          
                                                                                                          	// A token used for optimistic locking. AWS WAF returns this token to your update
                                                                                                          	// requests. You use NextLockToken in the same manner as you use LockToken.
                                                                                                          	NextLockToken *string
                                                                                                          
                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                          }

                                                                                                          Directories

                                                                                                          Path Synopsis
                                                                                                          internal