api.go

// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.

package waf

import (
	"fmt"
	"time"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/internal/awsutil"
)

const opCreateByteMatchSet = "CreateByteMatchSet"

// CreateByteMatchSetRequest is a API request type for the CreateByteMatchSet API operation.
type CreateByteMatchSetRequest struct {
	*aws.Request
	Input *CreateByteMatchSetInput
}

// Send marshals and sends the CreateByteMatchSet API request.
func (r CreateByteMatchSetRequest) Send() (*CreateByteMatchSetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreateByteMatchSetOutput), nil
}

// CreateByteMatchSetRequest returns a request value for making API operation for
// AWS WAF.
//
// Creates a ByteMatchSet. You then use UpdateByteMatchSet to identify the part
// of a web request that you want AWS WAF to inspect, such as the values of
// the User-Agent header or the query string. For example, you can create a
// ByteMatchSet that matches any requests with User-Agent headers that contain
// the string BadBot. You can then configure AWS WAF to reject those requests.
//
// To create and configure a ByteMatchSet, perform the following steps:
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of a CreateByteMatchSet request.
//
// Submit a CreateByteMatchSet request.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of an UpdateByteMatchSet request.
//
// Submit an UpdateByteMatchSet request to specify the part of the request that
// you want AWS WAF to inspect (for example, the header or the URI) and the
// value that you want AWS WAF to watch for.
//
// For more information about how to use the AWS WAF API to allow or block HTTP
// requests, see the AWS WAF Developer Guide (http://docs.aws.amazon.com/waf/latest/developerguide/).
//
//    // Example sending a request using the CreateByteMatchSetRequest method.
//    req := client.CreateByteMatchSetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateByteMatchSet
func (c *WAF) CreateByteMatchSetRequest(input *CreateByteMatchSetInput) CreateByteMatchSetRequest {
	op := &aws.Operation{
		Name:       opCreateByteMatchSet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateByteMatchSetInput{}
	}

	output := &CreateByteMatchSetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreateByteMatchSetRequest{Request: req, Input: input}
}

const opCreateIPSet = "CreateIPSet"

// CreateIPSetRequest is a API request type for the CreateIPSet API operation.
type CreateIPSetRequest struct {
	*aws.Request
	Input *CreateIPSetInput
}

// Send marshals and sends the CreateIPSet API request.
func (r CreateIPSetRequest) Send() (*CreateIPSetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreateIPSetOutput), nil
}

// CreateIPSetRequest returns a request value for making API operation for
// AWS WAF.
//
// Creates an IPSet, which you use to specify which web requests you want to
// allow or block based on the IP addresses that the requests originate from.
// For example, if you're receiving a lot of requests from one or more individual
// IP addresses or one or more ranges of IP addresses and you want to block
// the requests, you can create an IPSet that contains those IP addresses and
// then configure AWS WAF to block the requests.
//
// To create and configure an IPSet, perform the following steps:
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of a CreateIPSet request.
//
// Submit a CreateIPSet request.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of an UpdateIPSet request.
//
// Submit an UpdateIPSet request to specify the IP addresses that you want AWS
// WAF to watch for.
//
// For more information about how to use the AWS WAF API to allow or block HTTP
// requests, see the AWS WAF Developer Guide (http://docs.aws.amazon.com/waf/latest/developerguide/).
//
//    // Example sending a request using the CreateIPSetRequest method.
//    req := client.CreateIPSetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateIPSet
func (c *WAF) CreateIPSetRequest(input *CreateIPSetInput) CreateIPSetRequest {
	op := &aws.Operation{
		Name:       opCreateIPSet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateIPSetInput{}
	}

	output := &CreateIPSetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreateIPSetRequest{Request: req, Input: input}
}

const opCreateRateBasedRule = "CreateRateBasedRule"

// CreateRateBasedRuleRequest is a API request type for the CreateRateBasedRule API operation.
type CreateRateBasedRuleRequest struct {
	*aws.Request
	Input *CreateRateBasedRuleInput
}

// Send marshals and sends the CreateRateBasedRule API request.
func (r CreateRateBasedRuleRequest) Send() (*CreateRateBasedRuleOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreateRateBasedRuleOutput), nil
}

// CreateRateBasedRuleRequest returns a request value for making API operation for
// AWS WAF.
//
// Creates a RateBasedRule. The RateBasedRule contains a RateLimit, which specifies
// the maximum number of requests that AWS WAF allows from a specified IP address
// in a five-minute period. The RateBasedRule also contains the IPSet objects,
// ByteMatchSet objects, and other predicates that identify the requests that
// you want to count or block if these requests exceed the RateLimit.
//
// If you add more than one predicate to a RateBasedRule, a request not only
// must exceed the RateLimit, but it also must match all the specifications
// to be counted or blocked. For example, suppose you add the following to a
// RateBasedRule:
//
//    * An IPSet that matches the IP address 192.0.2.44/32
//
//    * A ByteMatchSet that matches BadBot in the User-Agent header
//
// Further, you specify a RateLimit of 15,000.
//
// You then add the RateBasedRule to a WebACL and specify that you want to block
// requests that meet the conditions in the rule. For a request to be blocked,
// it must come from the IP address 192.0.2.44 and the User-Agent header in
// the request must contain the value BadBot. Further, requests that match these
// two conditions must be received at a rate of more than 15,000 requests every
// five minutes. If both conditions are met and the rate is exceeded, AWS WAF
// blocks the requests. If the rate drops below 15,000 for a five-minute period,
// AWS WAF no longer blocks the requests.
//
// As a second example, suppose you want to limit requests to a particular page
// on your site. To do this, you could add the following to a RateBasedRule:
//
//    * A ByteMatchSet with FieldToMatch of URI
//
//    * A PositionalConstraint of STARTS_WITH
//
//    * A TargetString of login
//
// Further, you specify a RateLimit of 15,000.
//
// By adding this RateBasedRule to a WebACL, you could limit requests to your
// login page without affecting the rest of your site.
//
// To create and configure a RateBasedRule, perform the following steps:
//
// Create and update the predicates that you want to include in the rule. For
// more information, see CreateByteMatchSet, CreateIPSet, and CreateSqlInjectionMatchSet.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of a CreateRule request.
//
// Submit a CreateRateBasedRule request.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of an UpdateRule request.
//
// Submit an UpdateRateBasedRule request to specify the predicates that you
// want to include in the rule.
//
// Create and update a WebACL that contains the RateBasedRule. For more information,
// see CreateWebACL.
//
// For more information about how to use the AWS WAF API to allow or block HTTP
// requests, see the AWS WAF Developer Guide (http://docs.aws.amazon.com/waf/latest/developerguide/).
//
//    // Example sending a request using the CreateRateBasedRuleRequest method.
//    req := client.CreateRateBasedRuleRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateRateBasedRule
func (c *WAF) CreateRateBasedRuleRequest(input *CreateRateBasedRuleInput) CreateRateBasedRuleRequest {
	op := &aws.Operation{
		Name:       opCreateRateBasedRule,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateRateBasedRuleInput{}
	}

	output := &CreateRateBasedRuleOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreateRateBasedRuleRequest{Request: req, Input: input}
}

const opCreateRule = "CreateRule"

// CreateRuleRequest is a API request type for the CreateRule API operation.
type CreateRuleRequest struct {
	*aws.Request
	Input *CreateRuleInput
}

// Send marshals and sends the CreateRule API request.
func (r CreateRuleRequest) Send() (*CreateRuleOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreateRuleOutput), nil
}

// CreateRuleRequest returns a request value for making API operation for
// AWS WAF.
//
// Creates a Rule, which contains the IPSet objects, ByteMatchSet objects, and
// other predicates that identify the requests that you want to block. If you
// add more than one predicate to a Rule, a request must match all of the specifications
// to be allowed or blocked. For example, suppose you add the following to a
// Rule:
//
//    * An IPSet that matches the IP address 192.0.2.44/32
//
//    * A ByteMatchSet that matches BadBot in the User-Agent header
//
// You then add the Rule to a WebACL and specify that you want to blocks requests
// that satisfy the Rule. For a request to be blocked, it must come from the
// IP address 192.0.2.44 and the User-Agent header in the request must contain
// the value BadBot.
//
// To create and configure a Rule, perform the following steps:
//
// Create and update the predicates that you want to include in the Rule. For
// more information, see CreateByteMatchSet, CreateIPSet, and CreateSqlInjectionMatchSet.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of a CreateRule request.
//
// Submit a CreateRule request.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of an UpdateRule request.
//
// Submit an UpdateRule request to specify the predicates that you want to include
// in the Rule.
//
// Create and update a WebACL that contains the Rule. For more information,
// see CreateWebACL.
//
// For more information about how to use the AWS WAF API to allow or block HTTP
// requests, see the AWS WAF Developer Guide (http://docs.aws.amazon.com/waf/latest/developerguide/).
//
//    // Example sending a request using the CreateRuleRequest method.
//    req := client.CreateRuleRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateRule
func (c *WAF) CreateRuleRequest(input *CreateRuleInput) CreateRuleRequest {
	op := &aws.Operation{
		Name:       opCreateRule,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateRuleInput{}
	}

	output := &CreateRuleOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreateRuleRequest{Request: req, Input: input}
}

const opCreateSizeConstraintSet = "CreateSizeConstraintSet"

// CreateSizeConstraintSetRequest is a API request type for the CreateSizeConstraintSet API operation.
type CreateSizeConstraintSetRequest struct {
	*aws.Request
	Input *CreateSizeConstraintSetInput
}

// Send marshals and sends the CreateSizeConstraintSet API request.
func (r CreateSizeConstraintSetRequest) Send() (*CreateSizeConstraintSetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreateSizeConstraintSetOutput), nil
}

// CreateSizeConstraintSetRequest returns a request value for making API operation for
// AWS WAF.
//
// Creates a SizeConstraintSet. You then use UpdateSizeConstraintSet to identify
// the part of a web request that you want AWS WAF to check for length, such
// as the length of the User-Agent header or the length of the query string.
// For example, you can create a SizeConstraintSet that matches any requests
// that have a query string that is longer than 100 bytes. You can then configure
// AWS WAF to reject those requests.
//
// To create and configure a SizeConstraintSet, perform the following steps:
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of a CreateSizeConstraintSet request.
//
// Submit a CreateSizeConstraintSet request.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of an UpdateSizeConstraintSet request.
//
// Submit an UpdateSizeConstraintSet request to specify the part of the request
// that you want AWS WAF to inspect (for example, the header or the URI) and
// the value that you want AWS WAF to watch for.
//
// For more information about how to use the AWS WAF API to allow or block HTTP
// requests, see the AWS WAF Developer Guide (http://docs.aws.amazon.com/waf/latest/developerguide/).
//
//    // Example sending a request using the CreateSizeConstraintSetRequest method.
//    req := client.CreateSizeConstraintSetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateSizeConstraintSet
func (c *WAF) CreateSizeConstraintSetRequest(input *CreateSizeConstraintSetInput) CreateSizeConstraintSetRequest {
	op := &aws.Operation{
		Name:       opCreateSizeConstraintSet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateSizeConstraintSetInput{}
	}

	output := &CreateSizeConstraintSetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreateSizeConstraintSetRequest{Request: req, Input: input}
}

const opCreateSqlInjectionMatchSet = "CreateSqlInjectionMatchSet"

// CreateSqlInjectionMatchSetRequest is a API request type for the CreateSqlInjectionMatchSet API operation.
type CreateSqlInjectionMatchSetRequest struct {
	*aws.Request
	Input *CreateSqlInjectionMatchSetInput
}

// Send marshals and sends the CreateSqlInjectionMatchSet API request.
func (r CreateSqlInjectionMatchSetRequest) Send() (*CreateSqlInjectionMatchSetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreateSqlInjectionMatchSetOutput), nil
}

// CreateSqlInjectionMatchSetRequest returns a request value for making API operation for
// AWS WAF.
//
// Creates a SqlInjectionMatchSet, which you use to allow, block, or count requests
// that contain snippets of SQL code in a specified part of web requests. AWS
// WAF searches for character sequences that are likely to be malicious strings.
//
// To create and configure a SqlInjectionMatchSet, perform the following steps:
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of a CreateSqlInjectionMatchSet request.
//
// Submit a CreateSqlInjectionMatchSet request.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of an UpdateSqlInjectionMatchSet request.
//
// Submit an UpdateSqlInjectionMatchSet request to specify the parts of web
// requests in which you want to allow, block, or count malicious SQL code.
//
// For more information about how to use the AWS WAF API to allow or block HTTP
// requests, see the AWS WAF Developer Guide (http://docs.aws.amazon.com/waf/latest/developerguide/).
//
//    // Example sending a request using the CreateSqlInjectionMatchSetRequest method.
//    req := client.CreateSqlInjectionMatchSetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateSqlInjectionMatchSet
func (c *WAF) CreateSqlInjectionMatchSetRequest(input *CreateSqlInjectionMatchSetInput) CreateSqlInjectionMatchSetRequest {
	op := &aws.Operation{
		Name:       opCreateSqlInjectionMatchSet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateSqlInjectionMatchSetInput{}
	}

	output := &CreateSqlInjectionMatchSetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreateSqlInjectionMatchSetRequest{Request: req, Input: input}
}

const opCreateWebACL = "CreateWebACL"

// CreateWebACLRequest is a API request type for the CreateWebACL API operation.
type CreateWebACLRequest struct {
	*aws.Request
	Input *CreateWebACLInput
}

// Send marshals and sends the CreateWebACL API request.
func (r CreateWebACLRequest) Send() (*CreateWebACLOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreateWebACLOutput), nil
}

// CreateWebACLRequest returns a request value for making API operation for
// AWS WAF.
//
// Creates a WebACL, which contains the Rules that identify the CloudFront web
// requests that you want to allow, block, or count. AWS WAF evaluates Rules
// in order based on the value of Priority for each Rule.
//
// You also specify a default action, either ALLOW or BLOCK. If a web request
// doesn't match any of the Rules in a WebACL, AWS WAF responds to the request
// with the default action.
//
// To create and configure a WebACL, perform the following steps:
//
// Create and update the ByteMatchSet objects and other predicates that you
// want to include in Rules. For more information, see CreateByteMatchSet, UpdateByteMatchSet,
// CreateIPSet, UpdateIPSet, CreateSqlInjectionMatchSet, and UpdateSqlInjectionMatchSet.
//
// Create and update the Rules that you want to include in the WebACL. For more
// information, see CreateRule and UpdateRule.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of a CreateWebACL request.
//
// Submit a CreateWebACL request.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of an UpdateWebACL request.
//
// Submit an UpdateWebACL request to specify the Rules that you want to include
// in the WebACL, to specify the default action, and to associate the WebACL
// with a CloudFront distribution.
//
// For more information about how to use the AWS WAF API, see the AWS WAF Developer
// Guide (http://docs.aws.amazon.com/waf/latest/developerguide/).
//
//    // Example sending a request using the CreateWebACLRequest method.
//    req := client.CreateWebACLRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateWebACL
func (c *WAF) CreateWebACLRequest(input *CreateWebACLInput) CreateWebACLRequest {
	op := &aws.Operation{
		Name:       opCreateWebACL,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateWebACLInput{}
	}

	output := &CreateWebACLOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreateWebACLRequest{Request: req, Input: input}
}

const opCreateXssMatchSet = "CreateXssMatchSet"

// CreateXssMatchSetRequest is a API request type for the CreateXssMatchSet API operation.
type CreateXssMatchSetRequest struct {
	*aws.Request
	Input *CreateXssMatchSetInput
}

// Send marshals and sends the CreateXssMatchSet API request.
func (r CreateXssMatchSetRequest) Send() (*CreateXssMatchSetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*CreateXssMatchSetOutput), nil
}

// CreateXssMatchSetRequest returns a request value for making API operation for
// AWS WAF.
//
// Creates an XssMatchSet, which you use to allow, block, or count requests
// that contain cross-site scripting attacks in the specified part of web requests.
// AWS WAF searches for character sequences that are likely to be malicious
// strings.
//
// To create and configure an XssMatchSet, perform the following steps:
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of a CreateXssMatchSet request.
//
// Submit a CreateXssMatchSet request.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of an UpdateXssMatchSet request.
//
// Submit an UpdateXssMatchSet request to specify the parts of web requests
// in which you want to allow, block, or count cross-site scripting attacks.
//
// For more information about how to use the AWS WAF API to allow or block HTTP
// requests, see the AWS WAF Developer Guide (http://docs.aws.amazon.com/waf/latest/developerguide/).
//
//    // Example sending a request using the CreateXssMatchSetRequest method.
//    req := client.CreateXssMatchSetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateXssMatchSet
func (c *WAF) CreateXssMatchSetRequest(input *CreateXssMatchSetInput) CreateXssMatchSetRequest {
	op := &aws.Operation{
		Name:       opCreateXssMatchSet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &CreateXssMatchSetInput{}
	}

	output := &CreateXssMatchSetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return CreateXssMatchSetRequest{Request: req, Input: input}
}

const opDeleteByteMatchSet = "DeleteByteMatchSet"

// DeleteByteMatchSetRequest is a API request type for the DeleteByteMatchSet API operation.
type DeleteByteMatchSetRequest struct {
	*aws.Request
	Input *DeleteByteMatchSetInput
}

// Send marshals and sends the DeleteByteMatchSet API request.
func (r DeleteByteMatchSetRequest) Send() (*DeleteByteMatchSetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteByteMatchSetOutput), nil
}

// DeleteByteMatchSetRequest returns a request value for making API operation for
// AWS WAF.
//
// Permanently deletes a ByteMatchSet. You can't delete a ByteMatchSet if it's
// still used in any Rules or if it still includes any ByteMatchTuple objects
// (any filters).
//
// If you just want to remove a ByteMatchSet from a Rule, use UpdateRule.
//
// To permanently delete a ByteMatchSet, perform the following steps:
//
// Update the ByteMatchSet to remove filters, if any. For more information,
// see UpdateByteMatchSet.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of a DeleteByteMatchSet request.
//
// Submit a DeleteByteMatchSet request.
//
//    // Example sending a request using the DeleteByteMatchSetRequest method.
//    req := client.DeleteByteMatchSetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteByteMatchSet
func (c *WAF) DeleteByteMatchSetRequest(input *DeleteByteMatchSetInput) DeleteByteMatchSetRequest {
	op := &aws.Operation{
		Name:       opDeleteByteMatchSet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteByteMatchSetInput{}
	}

	output := &DeleteByteMatchSetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteByteMatchSetRequest{Request: req, Input: input}
}

const opDeleteIPSet = "DeleteIPSet"

// DeleteIPSetRequest is a API request type for the DeleteIPSet API operation.
type DeleteIPSetRequest struct {
	*aws.Request
	Input *DeleteIPSetInput
}

// Send marshals and sends the DeleteIPSet API request.
func (r DeleteIPSetRequest) Send() (*DeleteIPSetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteIPSetOutput), nil
}

// DeleteIPSetRequest returns a request value for making API operation for
// AWS WAF.
//
// Permanently deletes an IPSet. You can't delete an IPSet if it's still used
// in any Rules or if it still includes any IP addresses.
//
// If you just want to remove an IPSet from a Rule, use UpdateRule.
//
// To permanently delete an IPSet from AWS WAF, perform the following steps:
//
// Update the IPSet to remove IP address ranges, if any. For more information,
// see UpdateIPSet.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of a DeleteIPSet request.
//
// Submit a DeleteIPSet request.
//
//    // Example sending a request using the DeleteIPSetRequest method.
//    req := client.DeleteIPSetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteIPSet
func (c *WAF) DeleteIPSetRequest(input *DeleteIPSetInput) DeleteIPSetRequest {
	op := &aws.Operation{
		Name:       opDeleteIPSet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteIPSetInput{}
	}

	output := &DeleteIPSetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteIPSetRequest{Request: req, Input: input}
}

const opDeleteRateBasedRule = "DeleteRateBasedRule"

// DeleteRateBasedRuleRequest is a API request type for the DeleteRateBasedRule API operation.
type DeleteRateBasedRuleRequest struct {
	*aws.Request
	Input *DeleteRateBasedRuleInput
}

// Send marshals and sends the DeleteRateBasedRule API request.
func (r DeleteRateBasedRuleRequest) Send() (*DeleteRateBasedRuleOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteRateBasedRuleOutput), nil
}

// DeleteRateBasedRuleRequest returns a request value for making API operation for
// AWS WAF.
//
// Permanently deletes a RateBasedRule. You can't delete a rule if it's still
// used in any WebACL objects or if it still includes any predicates, such as
// ByteMatchSet objects.
//
// If you just want to remove a rule from a WebACL, use UpdateWebACL.
//
// To permanently delete a RateBasedRule from AWS WAF, perform the following
// steps:
//
// Update the RateBasedRule to remove predicates, if any. For more information,
// see UpdateRateBasedRule.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of a DeleteRateBasedRule request.
//
// Submit a DeleteRateBasedRule request.
//
//    // Example sending a request using the DeleteRateBasedRuleRequest method.
//    req := client.DeleteRateBasedRuleRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteRateBasedRule
func (c *WAF) DeleteRateBasedRuleRequest(input *DeleteRateBasedRuleInput) DeleteRateBasedRuleRequest {
	op := &aws.Operation{
		Name:       opDeleteRateBasedRule,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteRateBasedRuleInput{}
	}

	output := &DeleteRateBasedRuleOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteRateBasedRuleRequest{Request: req, Input: input}
}

const opDeleteRule = "DeleteRule"

// DeleteRuleRequest is a API request type for the DeleteRule API operation.
type DeleteRuleRequest struct {
	*aws.Request
	Input *DeleteRuleInput
}

// Send marshals and sends the DeleteRule API request.
func (r DeleteRuleRequest) Send() (*DeleteRuleOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteRuleOutput), nil
}

// DeleteRuleRequest returns a request value for making API operation for
// AWS WAF.
//
// Permanently deletes a Rule. You can't delete a Rule if it's still used in
// any WebACL objects or if it still includes any predicates, such as ByteMatchSet
// objects.
//
// If you just want to remove a Rule from a WebACL, use UpdateWebACL.
//
// To permanently delete a Rule from AWS WAF, perform the following steps:
//
// Update the Rule to remove predicates, if any. For more information, see UpdateRule.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of a DeleteRule request.
//
// Submit a DeleteRule request.
//
//    // Example sending a request using the DeleteRuleRequest method.
//    req := client.DeleteRuleRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteRule
func (c *WAF) DeleteRuleRequest(input *DeleteRuleInput) DeleteRuleRequest {
	op := &aws.Operation{
		Name:       opDeleteRule,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteRuleInput{}
	}

	output := &DeleteRuleOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteRuleRequest{Request: req, Input: input}
}

const opDeleteSizeConstraintSet = "DeleteSizeConstraintSet"

// DeleteSizeConstraintSetRequest is a API request type for the DeleteSizeConstraintSet API operation.
type DeleteSizeConstraintSetRequest struct {
	*aws.Request
	Input *DeleteSizeConstraintSetInput
}

// Send marshals and sends the DeleteSizeConstraintSet API request.
func (r DeleteSizeConstraintSetRequest) Send() (*DeleteSizeConstraintSetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteSizeConstraintSetOutput), nil
}

// DeleteSizeConstraintSetRequest returns a request value for making API operation for
// AWS WAF.
//
// Permanently deletes a SizeConstraintSet. You can't delete a SizeConstraintSet
// if it's still used in any Rules or if it still includes any SizeConstraint
// objects (any filters).
//
// If you just want to remove a SizeConstraintSet from a Rule, use UpdateRule.
//
// To permanently delete a SizeConstraintSet, perform the following steps:
//
// Update the SizeConstraintSet to remove filters, if any. For more information,
// see UpdateSizeConstraintSet.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of a DeleteSizeConstraintSet request.
//
// Submit a DeleteSizeConstraintSet request.
//
//    // Example sending a request using the DeleteSizeConstraintSetRequest method.
//    req := client.DeleteSizeConstraintSetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteSizeConstraintSet
func (c *WAF) DeleteSizeConstraintSetRequest(input *DeleteSizeConstraintSetInput) DeleteSizeConstraintSetRequest {
	op := &aws.Operation{
		Name:       opDeleteSizeConstraintSet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteSizeConstraintSetInput{}
	}

	output := &DeleteSizeConstraintSetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteSizeConstraintSetRequest{Request: req, Input: input}
}

const opDeleteSqlInjectionMatchSet = "DeleteSqlInjectionMatchSet"

// DeleteSqlInjectionMatchSetRequest is a API request type for the DeleteSqlInjectionMatchSet API operation.
type DeleteSqlInjectionMatchSetRequest struct {
	*aws.Request
	Input *DeleteSqlInjectionMatchSetInput
}

// Send marshals and sends the DeleteSqlInjectionMatchSet API request.
func (r DeleteSqlInjectionMatchSetRequest) Send() (*DeleteSqlInjectionMatchSetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteSqlInjectionMatchSetOutput), nil
}

// DeleteSqlInjectionMatchSetRequest returns a request value for making API operation for
// AWS WAF.
//
// Permanently deletes a SqlInjectionMatchSet. You can't delete a SqlInjectionMatchSet
// if it's still used in any Rules or if it still contains any SqlInjectionMatchTuple
// objects.
//
// If you just want to remove a SqlInjectionMatchSet from a Rule, use UpdateRule.
//
// To permanently delete a SqlInjectionMatchSet from AWS WAF, perform the following
// steps:
//
// Update the SqlInjectionMatchSet to remove filters, if any. For more information,
// see UpdateSqlInjectionMatchSet.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of a DeleteSqlInjectionMatchSet request.
//
// Submit a DeleteSqlInjectionMatchSet request.
//
//    // Example sending a request using the DeleteSqlInjectionMatchSetRequest method.
//    req := client.DeleteSqlInjectionMatchSetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteSqlInjectionMatchSet
func (c *WAF) DeleteSqlInjectionMatchSetRequest(input *DeleteSqlInjectionMatchSetInput) DeleteSqlInjectionMatchSetRequest {
	op := &aws.Operation{
		Name:       opDeleteSqlInjectionMatchSet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteSqlInjectionMatchSetInput{}
	}

	output := &DeleteSqlInjectionMatchSetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteSqlInjectionMatchSetRequest{Request: req, Input: input}
}

const opDeleteWebACL = "DeleteWebACL"

// DeleteWebACLRequest is a API request type for the DeleteWebACL API operation.
type DeleteWebACLRequest struct {
	*aws.Request
	Input *DeleteWebACLInput
}

// Send marshals and sends the DeleteWebACL API request.
func (r DeleteWebACLRequest) Send() (*DeleteWebACLOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteWebACLOutput), nil
}

// DeleteWebACLRequest returns a request value for making API operation for
// AWS WAF.
//
// Permanently deletes a WebACL. You can't delete a WebACL if it still contains
// any Rules.
//
// To delete a WebACL, perform the following steps:
//
// Update the WebACL to remove Rules, if any. For more information, see UpdateWebACL.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of a DeleteWebACL request.
//
// Submit a DeleteWebACL request.
//
//    // Example sending a request using the DeleteWebACLRequest method.
//    req := client.DeleteWebACLRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteWebACL
func (c *WAF) DeleteWebACLRequest(input *DeleteWebACLInput) DeleteWebACLRequest {
	op := &aws.Operation{
		Name:       opDeleteWebACL,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteWebACLInput{}
	}

	output := &DeleteWebACLOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteWebACLRequest{Request: req, Input: input}
}

const opDeleteXssMatchSet = "DeleteXssMatchSet"

// DeleteXssMatchSetRequest is a API request type for the DeleteXssMatchSet API operation.
type DeleteXssMatchSetRequest struct {
	*aws.Request
	Input *DeleteXssMatchSetInput
}

// Send marshals and sends the DeleteXssMatchSet API request.
func (r DeleteXssMatchSetRequest) Send() (*DeleteXssMatchSetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*DeleteXssMatchSetOutput), nil
}

// DeleteXssMatchSetRequest returns a request value for making API operation for
// AWS WAF.
//
// Permanently deletes an XssMatchSet. You can't delete an XssMatchSet if it's
// still used in any Rules or if it still contains any XssMatchTuple objects.
//
// If you just want to remove an XssMatchSet from a Rule, use UpdateRule.
//
// To permanently delete an XssMatchSet from AWS WAF, perform the following
// steps:
//
// Update the XssMatchSet to remove filters, if any. For more information, see
// UpdateXssMatchSet.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of a DeleteXssMatchSet request.
//
// Submit a DeleteXssMatchSet request.
//
//    // Example sending a request using the DeleteXssMatchSetRequest method.
//    req := client.DeleteXssMatchSetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteXssMatchSet
func (c *WAF) DeleteXssMatchSetRequest(input *DeleteXssMatchSetInput) DeleteXssMatchSetRequest {
	op := &aws.Operation{
		Name:       opDeleteXssMatchSet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteXssMatchSetInput{}
	}

	output := &DeleteXssMatchSetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return DeleteXssMatchSetRequest{Request: req, Input: input}
}

const opGetByteMatchSet = "GetByteMatchSet"

// GetByteMatchSetRequest is a API request type for the GetByteMatchSet API operation.
type GetByteMatchSetRequest struct {
	*aws.Request
	Input *GetByteMatchSetInput
}

// Send marshals and sends the GetByteMatchSet API request.
func (r GetByteMatchSetRequest) Send() (*GetByteMatchSetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*GetByteMatchSetOutput), nil
}

// GetByteMatchSetRequest returns a request value for making API operation for
// AWS WAF.
//
// Returns the ByteMatchSet specified by ByteMatchSetId.
//
//    // Example sending a request using the GetByteMatchSetRequest method.
//    req := client.GetByteMatchSetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetByteMatchSet
func (c *WAF) GetByteMatchSetRequest(input *GetByteMatchSetInput) GetByteMatchSetRequest {
	op := &aws.Operation{
		Name:       opGetByteMatchSet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetByteMatchSetInput{}
	}

	output := &GetByteMatchSetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return GetByteMatchSetRequest{Request: req, Input: input}
}

const opGetChangeToken = "GetChangeToken"

// GetChangeTokenRequest is a API request type for the GetChangeToken API operation.
type GetChangeTokenRequest struct {
	*aws.Request
	Input *GetChangeTokenInput
}

// Send marshals and sends the GetChangeToken API request.
func (r GetChangeTokenRequest) Send() (*GetChangeTokenOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*GetChangeTokenOutput), nil
}

// GetChangeTokenRequest returns a request value for making API operation for
// AWS WAF.
//
// When you want to create, update, or delete AWS WAF objects, get a change
// token and include the change token in the create, update, or delete request.
// Change tokens ensure that your application doesn't submit conflicting requests
// to AWS WAF.
//
// Each create, update, or delete request must use a unique change token. If
// your application submits a GetChangeToken request and then submits a second
// GetChangeToken request before submitting a create, update, or delete request,
// the second GetChangeToken request returns the same value as the first GetChangeToken
// request.
//
// When you use a change token in a create, update, or delete request, the status
// of the change token changes to PENDING, which indicates that AWS WAF is propagating
// the change to all AWS WAF servers. Use GetChangeTokenStatus to determine
// the status of your change token.
//
//    // Example sending a request using the GetChangeTokenRequest method.
//    req := client.GetChangeTokenRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetChangeToken
func (c *WAF) GetChangeTokenRequest(input *GetChangeTokenInput) GetChangeTokenRequest {
	op := &aws.Operation{
		Name:       opGetChangeToken,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetChangeTokenInput{}
	}

	output := &GetChangeTokenOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return GetChangeTokenRequest{Request: req, Input: input}
}

const opGetChangeTokenStatus = "GetChangeTokenStatus"

// GetChangeTokenStatusRequest is a API request type for the GetChangeTokenStatus API operation.
type GetChangeTokenStatusRequest struct {
	*aws.Request
	Input *GetChangeTokenStatusInput
}

// Send marshals and sends the GetChangeTokenStatus API request.
func (r GetChangeTokenStatusRequest) Send() (*GetChangeTokenStatusOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*GetChangeTokenStatusOutput), nil
}

// GetChangeTokenStatusRequest returns a request value for making API operation for
// AWS WAF.
//
// Returns the status of a ChangeToken that you got by calling GetChangeToken.
// ChangeTokenStatus is one of the following values:
//
//    * PROVISIONED: You requested the change token by calling GetChangeToken,
//    but you haven't used it yet in a call to create, update, or delete an
//    AWS WAF object.
//
//    * PENDING: AWS WAF is propagating the create, update, or delete request
//    to all AWS WAF servers.
//
//    * IN_SYNC: Propagation is complete.
//
//    // Example sending a request using the GetChangeTokenStatusRequest method.
//    req := client.GetChangeTokenStatusRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetChangeTokenStatus
func (c *WAF) GetChangeTokenStatusRequest(input *GetChangeTokenStatusInput) GetChangeTokenStatusRequest {
	op := &aws.Operation{
		Name:       opGetChangeTokenStatus,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetChangeTokenStatusInput{}
	}

	output := &GetChangeTokenStatusOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return GetChangeTokenStatusRequest{Request: req, Input: input}
}

const opGetIPSet = "GetIPSet"

// GetIPSetRequest is a API request type for the GetIPSet API operation.
type GetIPSetRequest struct {
	*aws.Request
	Input *GetIPSetInput
}

// Send marshals and sends the GetIPSet API request.
func (r GetIPSetRequest) Send() (*GetIPSetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*GetIPSetOutput), nil
}

// GetIPSetRequest returns a request value for making API operation for
// AWS WAF.
//
// Returns the IPSet that is specified by IPSetId.
//
//    // Example sending a request using the GetIPSetRequest method.
//    req := client.GetIPSetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetIPSet
func (c *WAF) GetIPSetRequest(input *GetIPSetInput) GetIPSetRequest {
	op := &aws.Operation{
		Name:       opGetIPSet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetIPSetInput{}
	}

	output := &GetIPSetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return GetIPSetRequest{Request: req, Input: input}
}

const opGetRateBasedRule = "GetRateBasedRule"

// GetRateBasedRuleRequest is a API request type for the GetRateBasedRule API operation.
type GetRateBasedRuleRequest struct {
	*aws.Request
	Input *GetRateBasedRuleInput
}

// Send marshals and sends the GetRateBasedRule API request.
func (r GetRateBasedRuleRequest) Send() (*GetRateBasedRuleOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*GetRateBasedRuleOutput), nil
}

// GetRateBasedRuleRequest returns a request value for making API operation for
// AWS WAF.
//
// Returns the RateBasedRule that is specified by the RuleId that you included
// in the GetRateBasedRule request.
//
//    // Example sending a request using the GetRateBasedRuleRequest method.
//    req := client.GetRateBasedRuleRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetRateBasedRule
func (c *WAF) GetRateBasedRuleRequest(input *GetRateBasedRuleInput) GetRateBasedRuleRequest {
	op := &aws.Operation{
		Name:       opGetRateBasedRule,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetRateBasedRuleInput{}
	}

	output := &GetRateBasedRuleOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return GetRateBasedRuleRequest{Request: req, Input: input}
}

const opGetRateBasedRuleManagedKeys = "GetRateBasedRuleManagedKeys"

// GetRateBasedRuleManagedKeysRequest is a API request type for the GetRateBasedRuleManagedKeys API operation.
type GetRateBasedRuleManagedKeysRequest struct {
	*aws.Request
	Input *GetRateBasedRuleManagedKeysInput
}

// Send marshals and sends the GetRateBasedRuleManagedKeys API request.
func (r GetRateBasedRuleManagedKeysRequest) Send() (*GetRateBasedRuleManagedKeysOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*GetRateBasedRuleManagedKeysOutput), nil
}

// GetRateBasedRuleManagedKeysRequest returns a request value for making API operation for
// AWS WAF.
//
// Returns an array of IP addresses currently being blocked by the RateBasedRule
// that is specified by the RuleId. The maximum number of managed keys that
// will be blocked is 10,000. If more than 10,000 addresses exceed the rate
// limit, the 10,000 addresses with the highest rates will be blocked.
//
//    // Example sending a request using the GetRateBasedRuleManagedKeysRequest method.
//    req := client.GetRateBasedRuleManagedKeysRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetRateBasedRuleManagedKeys
func (c *WAF) GetRateBasedRuleManagedKeysRequest(input *GetRateBasedRuleManagedKeysInput) GetRateBasedRuleManagedKeysRequest {
	op := &aws.Operation{
		Name:       opGetRateBasedRuleManagedKeys,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetRateBasedRuleManagedKeysInput{}
	}

	output := &GetRateBasedRuleManagedKeysOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return GetRateBasedRuleManagedKeysRequest{Request: req, Input: input}
}

const opGetRule = "GetRule"

// GetRuleRequest is a API request type for the GetRule API operation.
type GetRuleRequest struct {
	*aws.Request
	Input *GetRuleInput
}

// Send marshals and sends the GetRule API request.
func (r GetRuleRequest) Send() (*GetRuleOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*GetRuleOutput), nil
}

// GetRuleRequest returns a request value for making API operation for
// AWS WAF.
//
// Returns the Rule that is specified by the RuleId that you included in the
// GetRule request.
//
//    // Example sending a request using the GetRuleRequest method.
//    req := client.GetRuleRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetRule
func (c *WAF) GetRuleRequest(input *GetRuleInput) GetRuleRequest {
	op := &aws.Operation{
		Name:       opGetRule,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetRuleInput{}
	}

	output := &GetRuleOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return GetRuleRequest{Request: req, Input: input}
}

const opGetSampledRequests = "GetSampledRequests"

// GetSampledRequestsRequest is a API request type for the GetSampledRequests API operation.
type GetSampledRequestsRequest struct {
	*aws.Request
	Input *GetSampledRequestsInput
}

// Send marshals and sends the GetSampledRequests API request.
func (r GetSampledRequestsRequest) Send() (*GetSampledRequestsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*GetSampledRequestsOutput), nil
}

// GetSampledRequestsRequest returns a request value for making API operation for
// AWS WAF.
//
// 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.
//
//    // Example sending a request using the GetSampledRequestsRequest method.
//    req := client.GetSampledRequestsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetSampledRequests
func (c *WAF) GetSampledRequestsRequest(input *GetSampledRequestsInput) GetSampledRequestsRequest {
	op := &aws.Operation{
		Name:       opGetSampledRequests,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetSampledRequestsInput{}
	}

	output := &GetSampledRequestsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return GetSampledRequestsRequest{Request: req, Input: input}
}

const opGetSizeConstraintSet = "GetSizeConstraintSet"

// GetSizeConstraintSetRequest is a API request type for the GetSizeConstraintSet API operation.
type GetSizeConstraintSetRequest struct {
	*aws.Request
	Input *GetSizeConstraintSetInput
}

// Send marshals and sends the GetSizeConstraintSet API request.
func (r GetSizeConstraintSetRequest) Send() (*GetSizeConstraintSetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*GetSizeConstraintSetOutput), nil
}

// GetSizeConstraintSetRequest returns a request value for making API operation for
// AWS WAF.
//
// Returns the SizeConstraintSet specified by SizeConstraintSetId.
//
//    // Example sending a request using the GetSizeConstraintSetRequest method.
//    req := client.GetSizeConstraintSetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetSizeConstraintSet
func (c *WAF) GetSizeConstraintSetRequest(input *GetSizeConstraintSetInput) GetSizeConstraintSetRequest {
	op := &aws.Operation{
		Name:       opGetSizeConstraintSet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetSizeConstraintSetInput{}
	}

	output := &GetSizeConstraintSetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return GetSizeConstraintSetRequest{Request: req, Input: input}
}

const opGetSqlInjectionMatchSet = "GetSqlInjectionMatchSet"

// GetSqlInjectionMatchSetRequest is a API request type for the GetSqlInjectionMatchSet API operation.
type GetSqlInjectionMatchSetRequest struct {
	*aws.Request
	Input *GetSqlInjectionMatchSetInput
}

// Send marshals and sends the GetSqlInjectionMatchSet API request.
func (r GetSqlInjectionMatchSetRequest) Send() (*GetSqlInjectionMatchSetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*GetSqlInjectionMatchSetOutput), nil
}

// GetSqlInjectionMatchSetRequest returns a request value for making API operation for
// AWS WAF.
//
// Returns the SqlInjectionMatchSet that is specified by SqlInjectionMatchSetId.
//
//    // Example sending a request using the GetSqlInjectionMatchSetRequest method.
//    req := client.GetSqlInjectionMatchSetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetSqlInjectionMatchSet
func (c *WAF) GetSqlInjectionMatchSetRequest(input *GetSqlInjectionMatchSetInput) GetSqlInjectionMatchSetRequest {
	op := &aws.Operation{
		Name:       opGetSqlInjectionMatchSet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetSqlInjectionMatchSetInput{}
	}

	output := &GetSqlInjectionMatchSetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return GetSqlInjectionMatchSetRequest{Request: req, Input: input}
}

const opGetWebACL = "GetWebACL"

// GetWebACLRequest is a API request type for the GetWebACL API operation.
type GetWebACLRequest struct {
	*aws.Request
	Input *GetWebACLInput
}

// Send marshals and sends the GetWebACL API request.
func (r GetWebACLRequest) Send() (*GetWebACLOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*GetWebACLOutput), nil
}

// GetWebACLRequest returns a request value for making API operation for
// AWS WAF.
//
// Returns the WebACL that is specified by WebACLId.
//
//    // Example sending a request using the GetWebACLRequest method.
//    req := client.GetWebACLRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetWebACL
func (c *WAF) GetWebACLRequest(input *GetWebACLInput) GetWebACLRequest {
	op := &aws.Operation{
		Name:       opGetWebACL,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetWebACLInput{}
	}

	output := &GetWebACLOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return GetWebACLRequest{Request: req, Input: input}
}

const opGetXssMatchSet = "GetXssMatchSet"

// GetXssMatchSetRequest is a API request type for the GetXssMatchSet API operation.
type GetXssMatchSetRequest struct {
	*aws.Request
	Input *GetXssMatchSetInput
}

// Send marshals and sends the GetXssMatchSet API request.
func (r GetXssMatchSetRequest) Send() (*GetXssMatchSetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*GetXssMatchSetOutput), nil
}

// GetXssMatchSetRequest returns a request value for making API operation for
// AWS WAF.
//
// Returns the XssMatchSet that is specified by XssMatchSetId.
//
//    // Example sending a request using the GetXssMatchSetRequest method.
//    req := client.GetXssMatchSetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetXssMatchSet
func (c *WAF) GetXssMatchSetRequest(input *GetXssMatchSetInput) GetXssMatchSetRequest {
	op := &aws.Operation{
		Name:       opGetXssMatchSet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetXssMatchSetInput{}
	}

	output := &GetXssMatchSetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return GetXssMatchSetRequest{Request: req, Input: input}
}

const opListByteMatchSets = "ListByteMatchSets"

// ListByteMatchSetsRequest is a API request type for the ListByteMatchSets API operation.
type ListByteMatchSetsRequest struct {
	*aws.Request
	Input *ListByteMatchSetsInput
}

// Send marshals and sends the ListByteMatchSets API request.
func (r ListByteMatchSetsRequest) Send() (*ListByteMatchSetsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*ListByteMatchSetsOutput), nil
}

// ListByteMatchSetsRequest returns a request value for making API operation for
// AWS WAF.
//
// Returns an array of ByteMatchSetSummary objects.
//
//    // Example sending a request using the ListByteMatchSetsRequest method.
//    req := client.ListByteMatchSetsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListByteMatchSets
func (c *WAF) ListByteMatchSetsRequest(input *ListByteMatchSetsInput) ListByteMatchSetsRequest {
	op := &aws.Operation{
		Name:       opListByteMatchSets,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListByteMatchSetsInput{}
	}

	output := &ListByteMatchSetsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return ListByteMatchSetsRequest{Request: req, Input: input}
}

const opListIPSets = "ListIPSets"

// ListIPSetsRequest is a API request type for the ListIPSets API operation.
type ListIPSetsRequest struct {
	*aws.Request
	Input *ListIPSetsInput
}

// Send marshals and sends the ListIPSets API request.
func (r ListIPSetsRequest) Send() (*ListIPSetsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*ListIPSetsOutput), nil
}

// ListIPSetsRequest returns a request value for making API operation for
// AWS WAF.
//
// Returns an array of IPSetSummary objects in the response.
//
//    // Example sending a request using the ListIPSetsRequest method.
//    req := client.ListIPSetsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListIPSets
func (c *WAF) ListIPSetsRequest(input *ListIPSetsInput) ListIPSetsRequest {
	op := &aws.Operation{
		Name:       opListIPSets,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListIPSetsInput{}
	}

	output := &ListIPSetsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return ListIPSetsRequest{Request: req, Input: input}
}

const opListRateBasedRules = "ListRateBasedRules"

// ListRateBasedRulesRequest is a API request type for the ListRateBasedRules API operation.
type ListRateBasedRulesRequest struct {
	*aws.Request
	Input *ListRateBasedRulesInput
}

// Send marshals and sends the ListRateBasedRules API request.
func (r ListRateBasedRulesRequest) Send() (*ListRateBasedRulesOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*ListRateBasedRulesOutput), nil
}

// ListRateBasedRulesRequest returns a request value for making API operation for
// AWS WAF.
//
// Returns an array of RuleSummary objects.
//
//    // Example sending a request using the ListRateBasedRulesRequest method.
//    req := client.ListRateBasedRulesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListRateBasedRules
func (c *WAF) ListRateBasedRulesRequest(input *ListRateBasedRulesInput) ListRateBasedRulesRequest {
	op := &aws.Operation{
		Name:       opListRateBasedRules,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListRateBasedRulesInput{}
	}

	output := &ListRateBasedRulesOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return ListRateBasedRulesRequest{Request: req, Input: input}
}

const opListRules = "ListRules"

// ListRulesRequest is a API request type for the ListRules API operation.
type ListRulesRequest struct {
	*aws.Request
	Input *ListRulesInput
}

// Send marshals and sends the ListRules API request.
func (r ListRulesRequest) Send() (*ListRulesOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*ListRulesOutput), nil
}

// ListRulesRequest returns a request value for making API operation for
// AWS WAF.
//
// Returns an array of RuleSummary objects.
//
//    // Example sending a request using the ListRulesRequest method.
//    req := client.ListRulesRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListRules
func (c *WAF) ListRulesRequest(input *ListRulesInput) ListRulesRequest {
	op := &aws.Operation{
		Name:       opListRules,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListRulesInput{}
	}

	output := &ListRulesOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return ListRulesRequest{Request: req, Input: input}
}

const opListSizeConstraintSets = "ListSizeConstraintSets"

// ListSizeConstraintSetsRequest is a API request type for the ListSizeConstraintSets API operation.
type ListSizeConstraintSetsRequest struct {
	*aws.Request
	Input *ListSizeConstraintSetsInput
}

// Send marshals and sends the ListSizeConstraintSets API request.
func (r ListSizeConstraintSetsRequest) Send() (*ListSizeConstraintSetsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*ListSizeConstraintSetsOutput), nil
}

// ListSizeConstraintSetsRequest returns a request value for making API operation for
// AWS WAF.
//
// Returns an array of SizeConstraintSetSummary objects.
//
//    // Example sending a request using the ListSizeConstraintSetsRequest method.
//    req := client.ListSizeConstraintSetsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListSizeConstraintSets
func (c *WAF) ListSizeConstraintSetsRequest(input *ListSizeConstraintSetsInput) ListSizeConstraintSetsRequest {
	op := &aws.Operation{
		Name:       opListSizeConstraintSets,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListSizeConstraintSetsInput{}
	}

	output := &ListSizeConstraintSetsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return ListSizeConstraintSetsRequest{Request: req, Input: input}
}

const opListSqlInjectionMatchSets = "ListSqlInjectionMatchSets"

// ListSqlInjectionMatchSetsRequest is a API request type for the ListSqlInjectionMatchSets API operation.
type ListSqlInjectionMatchSetsRequest struct {
	*aws.Request
	Input *ListSqlInjectionMatchSetsInput
}

// Send marshals and sends the ListSqlInjectionMatchSets API request.
func (r ListSqlInjectionMatchSetsRequest) Send() (*ListSqlInjectionMatchSetsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*ListSqlInjectionMatchSetsOutput), nil
}

// ListSqlInjectionMatchSetsRequest returns a request value for making API operation for
// AWS WAF.
//
// Returns an array of SqlInjectionMatchSet objects.
//
//    // Example sending a request using the ListSqlInjectionMatchSetsRequest method.
//    req := client.ListSqlInjectionMatchSetsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListSqlInjectionMatchSets
func (c *WAF) ListSqlInjectionMatchSetsRequest(input *ListSqlInjectionMatchSetsInput) ListSqlInjectionMatchSetsRequest {
	op := &aws.Operation{
		Name:       opListSqlInjectionMatchSets,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListSqlInjectionMatchSetsInput{}
	}

	output := &ListSqlInjectionMatchSetsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return ListSqlInjectionMatchSetsRequest{Request: req, Input: input}
}

const opListWebACLs = "ListWebACLs"

// ListWebACLsRequest is a API request type for the ListWebACLs API operation.
type ListWebACLsRequest struct {
	*aws.Request
	Input *ListWebACLsInput
}

// Send marshals and sends the ListWebACLs API request.
func (r ListWebACLsRequest) Send() (*ListWebACLsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*ListWebACLsOutput), nil
}

// ListWebACLsRequest returns a request value for making API operation for
// AWS WAF.
//
// Returns an array of WebACLSummary objects in the response.
//
//    // Example sending a request using the ListWebACLsRequest method.
//    req := client.ListWebACLsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListWebACLs
func (c *WAF) ListWebACLsRequest(input *ListWebACLsInput) ListWebACLsRequest {
	op := &aws.Operation{
		Name:       opListWebACLs,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListWebACLsInput{}
	}

	output := &ListWebACLsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return ListWebACLsRequest{Request: req, Input: input}
}

const opListXssMatchSets = "ListXssMatchSets"

// ListXssMatchSetsRequest is a API request type for the ListXssMatchSets API operation.
type ListXssMatchSetsRequest struct {
	*aws.Request
	Input *ListXssMatchSetsInput
}

// Send marshals and sends the ListXssMatchSets API request.
func (r ListXssMatchSetsRequest) Send() (*ListXssMatchSetsOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*ListXssMatchSetsOutput), nil
}

// ListXssMatchSetsRequest returns a request value for making API operation for
// AWS WAF.
//
// Returns an array of XssMatchSet objects.
//
//    // Example sending a request using the ListXssMatchSetsRequest method.
//    req := client.ListXssMatchSetsRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListXssMatchSets
func (c *WAF) ListXssMatchSetsRequest(input *ListXssMatchSetsInput) ListXssMatchSetsRequest {
	op := &aws.Operation{
		Name:       opListXssMatchSets,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListXssMatchSetsInput{}
	}

	output := &ListXssMatchSetsOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return ListXssMatchSetsRequest{Request: req, Input: input}
}

const opUpdateByteMatchSet = "UpdateByteMatchSet"

// UpdateByteMatchSetRequest is a API request type for the UpdateByteMatchSet API operation.
type UpdateByteMatchSetRequest struct {
	*aws.Request
	Input *UpdateByteMatchSetInput
}

// Send marshals and sends the UpdateByteMatchSet API request.
func (r UpdateByteMatchSetRequest) Send() (*UpdateByteMatchSetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UpdateByteMatchSetOutput), nil
}

// UpdateByteMatchSetRequest returns a request value for making API operation for
// AWS WAF.
//
// Inserts or deletes ByteMatchTuple objects (filters) in a ByteMatchSet. For
// each ByteMatchTuple object, you specify the following values:
//
//    * Whether to insert or delete the object from the array. If you want to
//    change a ByteMatchSetUpdate object, you delete the existing object and
//    add a new one.
//
//    * The part of a web request that you want AWS WAF to inspect, such as
//    a query string or the value of the User-Agent header.
//
//    * The bytes (typically a string that corresponds with ASCII characters)
//    that you want AWS WAF to look for. For more information, including how
//    you specify the values for the AWS WAF API and the AWS CLI or SDKs, see
//    TargetString in the ByteMatchTuple data type.
//
//    * Where to look, such as at the beginning or the end of a query string.
//
//    * Whether to perform any conversions on the request, such as converting
//    it to lowercase, before inspecting it for the specified string.
//
// For example, you can add a ByteMatchSetUpdate object that matches web requests
// in which User-Agent headers contain the string BadBot. You can then configure
// AWS WAF to block those requests.
//
// To create and configure a ByteMatchSet, perform the following steps:
//
// Create a ByteMatchSet. For more information, see CreateByteMatchSet.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of an UpdateByteMatchSet request.
//
// Submit an UpdateByteMatchSet request to specify the part of the request that
// you want AWS WAF to inspect (for example, the header or the URI) and the
// value that you want AWS WAF to watch for.
//
// For more information about how to use the AWS WAF API to allow or block HTTP
// requests, see the AWS WAF Developer Guide (http://docs.aws.amazon.com/waf/latest/developerguide/).
//
//    // Example sending a request using the UpdateByteMatchSetRequest method.
//    req := client.UpdateByteMatchSetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateByteMatchSet
func (c *WAF) UpdateByteMatchSetRequest(input *UpdateByteMatchSetInput) UpdateByteMatchSetRequest {
	op := &aws.Operation{
		Name:       opUpdateByteMatchSet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateByteMatchSetInput{}
	}

	output := &UpdateByteMatchSetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return UpdateByteMatchSetRequest{Request: req, Input: input}
}

const opUpdateIPSet = "UpdateIPSet"

// UpdateIPSetRequest is a API request type for the UpdateIPSet API operation.
type UpdateIPSetRequest struct {
	*aws.Request
	Input *UpdateIPSetInput
}

// Send marshals and sends the UpdateIPSet API request.
func (r UpdateIPSetRequest) Send() (*UpdateIPSetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UpdateIPSetOutput), nil
}

// UpdateIPSetRequest returns a request value for making API operation for
// AWS WAF.
//
// Inserts or deletes IPSetDescriptor objects in an IPSet. For each IPSetDescriptor
// object, you specify the following values:
//
//    * Whether to insert or delete the object from the array. If you want to
//    change an IPSetDescriptor object, you delete the existing object and add
//    a new one.
//
//    * The IP address version, IPv4 or IPv6.
//
//    * The IP address in CIDR notation, for example, 192.0.2.0/24 (for the
//    range of IP addresses from 192.0.2.0 to 192.0.2.255) or 192.0.2.44/32
//    (for the individual IP address 192.0.2.44).
//
// AWS WAF supports /8, /16, /24, and /32 IP address ranges for IPv4, and /24,
// /32, /48, /56, /64 and /128 for IPv6. For more information about CIDR notation,
// see the Wikipedia entry Classless Inter-Domain Routing (https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing).
//
// IPv6 addresses can be represented using any of the following formats:
//
//    * 1111:0000:0000:0000:0000:0000:0000:0111/128
//
//    * 1111:0:0:0:0:0:0:0111/128
//
//    * 1111::0111/128
//
//    * 1111::111/128
//
// You use an IPSet to specify which web requests you want to allow or block
// based on the IP addresses that the requests originated from. For example,
// if you're receiving a lot of requests from one or a small number of IP addresses
// and you want to block the requests, you can create an IPSet that specifies
// those IP addresses, and then configure AWS WAF to block the requests.
//
// To create and configure an IPSet, perform the following steps:
//
// Submit a CreateIPSet request.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of an UpdateIPSet request.
//
// Submit an UpdateIPSet request to specify the IP addresses that you want AWS
// WAF to watch for.
//
// When you update an IPSet, you specify the IP addresses that you want to add
// and/or the IP addresses that you want to delete. If you want to change an
// IP address, you delete the existing IP address and add the new one.
//
// For more information about how to use the AWS WAF API to allow or block HTTP
// requests, see the AWS WAF Developer Guide (http://docs.aws.amazon.com/waf/latest/developerguide/).
//
//    // Example sending a request using the UpdateIPSetRequest method.
//    req := client.UpdateIPSetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateIPSet
func (c *WAF) UpdateIPSetRequest(input *UpdateIPSetInput) UpdateIPSetRequest {
	op := &aws.Operation{
		Name:       opUpdateIPSet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateIPSetInput{}
	}

	output := &UpdateIPSetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return UpdateIPSetRequest{Request: req, Input: input}
}

const opUpdateRateBasedRule = "UpdateRateBasedRule"

// UpdateRateBasedRuleRequest is a API request type for the UpdateRateBasedRule API operation.
type UpdateRateBasedRuleRequest struct {
	*aws.Request
	Input *UpdateRateBasedRuleInput
}

// Send marshals and sends the UpdateRateBasedRule API request.
func (r UpdateRateBasedRuleRequest) Send() (*UpdateRateBasedRuleOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UpdateRateBasedRuleOutput), nil
}

// UpdateRateBasedRuleRequest returns a request value for making API operation for
// AWS WAF.
//
// Inserts or deletes Predicate objects in a rule and updates the RateLimit
// in the rule.
//
// Each Predicate object identifies a predicate, such as a ByteMatchSet or an
// IPSet, that specifies the web requests that you want to block or count. The
// RateLimit specifies the number of requests every five minutes that triggers
// the rule.
//
// If you add more than one predicate to a RateBasedRule, a request must match
// all the predicates and exceed the RateLimit to be counted or blocked. For
// example, suppose you add the following to a RateBasedRule:
//
//    * An IPSet that matches the IP address 192.0.2.44/32
//
//    * A ByteMatchSet that matches BadBot in the User-Agent header
//
// Further, you specify a RateLimit of 15,000.
//
// You then add the RateBasedRule to a WebACL and specify that you want to block
// requests that satisfy the rule. For a request to be blocked, it must come
// from the IP address 192.0.2.44 and the User-Agent header in the request must
// contain the value BadBot. Further, requests that match these two conditions
// much be received at a rate of more than 15,000 every five minutes. If the
// rate drops below this limit, AWS WAF no longer blocks the requests.
//
// As a second example, suppose you want to limit requests to a particular page
// on your site. To do this, you could add the following to a RateBasedRule:
//
//    * A ByteMatchSet with FieldToMatch of URI
//
//    * A PositionalConstraint of STARTS_WITH
//
//    * A TargetString of login
//
// Further, you specify a RateLimit of 15,000.
//
// By adding this RateBasedRule to a WebACL, you could limit requests to your
// login page without affecting the rest of your site.
//
//    // Example sending a request using the UpdateRateBasedRuleRequest method.
//    req := client.UpdateRateBasedRuleRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateRateBasedRule
func (c *WAF) UpdateRateBasedRuleRequest(input *UpdateRateBasedRuleInput) UpdateRateBasedRuleRequest {
	op := &aws.Operation{
		Name:       opUpdateRateBasedRule,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateRateBasedRuleInput{}
	}

	output := &UpdateRateBasedRuleOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return UpdateRateBasedRuleRequest{Request: req, Input: input}
}

const opUpdateRule = "UpdateRule"

// UpdateRuleRequest is a API request type for the UpdateRule API operation.
type UpdateRuleRequest struct {
	*aws.Request
	Input *UpdateRuleInput
}

// Send marshals and sends the UpdateRule API request.
func (r UpdateRuleRequest) Send() (*UpdateRuleOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UpdateRuleOutput), nil
}

// UpdateRuleRequest returns a request value for making API operation for
// AWS WAF.
//
// Inserts or deletes Predicate objects in a Rule. Each Predicate object identifies
// a predicate, such as a ByteMatchSet or an IPSet, that specifies the web requests
// that you want to allow, block, or count. If you add more than one predicate
// to a Rule, a request must match all of the specifications to be allowed,
// blocked, or counted. For example, suppose you add the following to a Rule:
//
//    * A ByteMatchSet that matches the value BadBot in the User-Agent header
//
//    * An IPSet that matches the IP address 192.0.2.44
//
// You then add the Rule to a WebACL and specify that you want to block requests
// that satisfy the Rule. For a request to be blocked, the User-Agent header
// in the request must contain the value BadBotand the request must originate
// from the IP address 192.0.2.44.
//
// To create and configure a Rule, perform the following steps:
//
// Create and update the predicates that you want to include in the Rule.
//
// Create the Rule. See CreateRule.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of an UpdateRule request.
//
// Submit an UpdateRule request to add predicates to the Rule.
//
// Create and update a WebACL that contains the Rule. See CreateWebACL.
//
// If you want to replace one ByteMatchSet or IPSet with another, you delete
// the existing one and add the new one.
//
// For more information about how to use the AWS WAF API to allow or block HTTP
// requests, see the AWS WAF Developer Guide (http://docs.aws.amazon.com/waf/latest/developerguide/).
//
//    // Example sending a request using the UpdateRuleRequest method.
//    req := client.UpdateRuleRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateRule
func (c *WAF) UpdateRuleRequest(input *UpdateRuleInput) UpdateRuleRequest {
	op := &aws.Operation{
		Name:       opUpdateRule,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateRuleInput{}
	}

	output := &UpdateRuleOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return UpdateRuleRequest{Request: req, Input: input}
}

const opUpdateSizeConstraintSet = "UpdateSizeConstraintSet"

// UpdateSizeConstraintSetRequest is a API request type for the UpdateSizeConstraintSet API operation.
type UpdateSizeConstraintSetRequest struct {
	*aws.Request
	Input *UpdateSizeConstraintSetInput
}

// Send marshals and sends the UpdateSizeConstraintSet API request.
func (r UpdateSizeConstraintSetRequest) Send() (*UpdateSizeConstraintSetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UpdateSizeConstraintSetOutput), nil
}

// UpdateSizeConstraintSetRequest returns a request value for making API operation for
// AWS WAF.
//
// Inserts or deletes SizeConstraint objects (filters) in a SizeConstraintSet.
// For each SizeConstraint object, you specify the following values:
//
//    * Whether to insert or delete the object from the array. If you want to
//    change a SizeConstraintSetUpdate object, you delete the existing object
//    and add a new one.
//
//    * The part of a web request that you want AWS WAF to evaluate, such as
//    the length of a query string or the length of the User-Agent header.
//
//    * Whether to perform any transformations on the request, such as converting
//    it to lowercase, before checking its length. Note that transformations
//    of the request body are not supported because the AWS resource forwards
//    only the first 8192 bytes of your request to AWS WAF.
//
//    * A ComparisonOperator used for evaluating the selected part of the request
//    against the specified Size, such as equals, greater than, less than, and
//    so on.
//
//    * The length, in bytes, that you want AWS WAF to watch for in selected
//    part of the request. The length is computed after applying the transformation.
//
// For example, you can add a SizeConstraintSetUpdate object that matches web
// requests in which the length of the User-Agent header is greater than 100
// bytes. You can then configure AWS WAF to block those requests.
//
// To create and configure a SizeConstraintSet, perform the following steps:
//
// Create a SizeConstraintSet. For more information, see CreateSizeConstraintSet.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of an UpdateSizeConstraintSet request.
//
// Submit an UpdateSizeConstraintSet request to specify the part of the request
// that you want AWS WAF to inspect (for example, the header or the URI) and
// the value that you want AWS WAF to watch for.
//
// For more information about how to use the AWS WAF API to allow or block HTTP
// requests, see the AWS WAF Developer Guide (http://docs.aws.amazon.com/waf/latest/developerguide/).
//
//    // Example sending a request using the UpdateSizeConstraintSetRequest method.
//    req := client.UpdateSizeConstraintSetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateSizeConstraintSet
func (c *WAF) UpdateSizeConstraintSetRequest(input *UpdateSizeConstraintSetInput) UpdateSizeConstraintSetRequest {
	op := &aws.Operation{
		Name:       opUpdateSizeConstraintSet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateSizeConstraintSetInput{}
	}

	output := &UpdateSizeConstraintSetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return UpdateSizeConstraintSetRequest{Request: req, Input: input}
}

const opUpdateSqlInjectionMatchSet = "UpdateSqlInjectionMatchSet"

// UpdateSqlInjectionMatchSetRequest is a API request type for the UpdateSqlInjectionMatchSet API operation.
type UpdateSqlInjectionMatchSetRequest struct {
	*aws.Request
	Input *UpdateSqlInjectionMatchSetInput
}

// Send marshals and sends the UpdateSqlInjectionMatchSet API request.
func (r UpdateSqlInjectionMatchSetRequest) Send() (*UpdateSqlInjectionMatchSetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UpdateSqlInjectionMatchSetOutput), nil
}

// UpdateSqlInjectionMatchSetRequest returns a request value for making API operation for
// AWS WAF.
//
// Inserts or deletes SqlInjectionMatchTuple objects (filters) in a SqlInjectionMatchSet.
// For each SqlInjectionMatchTuple object, you specify the following values:
//
//    * Action: Whether to insert the object into or delete the object from
//    the array. To change a SqlInjectionMatchTuple, you delete the existing
//    object and add a new one.
//
//    * FieldToMatch: The part of web requests that you want AWS WAF to inspect
//    and, if you want AWS WAF to inspect a header, the name of the header.
//
//    * TextTransformation: Which text transformation, if any, to perform on
//    the web request before inspecting the request for snippets of malicious
//    SQL code.
//
// You use SqlInjectionMatchSet objects to specify which CloudFront requests
// you want to allow, block, or count. For example, if you're receiving requests
// that contain snippets of SQL code in the query string and you want to block
// the requests, you can create a SqlInjectionMatchSet with the applicable settings,
// and then configure AWS WAF to block the requests.
//
// To create and configure a SqlInjectionMatchSet, perform the following steps:
//
// Submit a CreateSqlInjectionMatchSet request.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of an UpdateIPSet request.
//
// Submit an UpdateSqlInjectionMatchSet request to specify the parts of web
// requests that you want AWS WAF to inspect for snippets of SQL code.
//
// For more information about how to use the AWS WAF API to allow or block HTTP
// requests, see the AWS WAF Developer Guide (http://docs.aws.amazon.com/waf/latest/developerguide/).
//
//    // Example sending a request using the UpdateSqlInjectionMatchSetRequest method.
//    req := client.UpdateSqlInjectionMatchSetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateSqlInjectionMatchSet
func (c *WAF) UpdateSqlInjectionMatchSetRequest(input *UpdateSqlInjectionMatchSetInput) UpdateSqlInjectionMatchSetRequest {
	op := &aws.Operation{
		Name:       opUpdateSqlInjectionMatchSet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateSqlInjectionMatchSetInput{}
	}

	output := &UpdateSqlInjectionMatchSetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return UpdateSqlInjectionMatchSetRequest{Request: req, Input: input}
}

const opUpdateWebACL = "UpdateWebACL"

// UpdateWebACLRequest is a API request type for the UpdateWebACL API operation.
type UpdateWebACLRequest struct {
	*aws.Request
	Input *UpdateWebACLInput
}

// Send marshals and sends the UpdateWebACL API request.
func (r UpdateWebACLRequest) Send() (*UpdateWebACLOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UpdateWebACLOutput), nil
}

// UpdateWebACLRequest returns a request value for making API operation for
// AWS WAF.
//
// Inserts or deletes ActivatedRule objects in a WebACL. Each Rule identifies
// web requests that you want to allow, block, or count. When you update a WebACL,
// you specify the following values:
//
//    * A default action for the WebACL, either ALLOW or BLOCK. AWS WAF performs
//    the default action if a request doesn't match the criteria in any of the
//    Rules in a WebACL.
//
//    * The Rules that you want to add and/or delete. If you want to replace
//    one Rule with another, you delete the existing Rule and add the new one.
//
//    * For each Rule, whether you want AWS WAF to allow requests, block requests,
//    or count requests that match the conditions in the Rule.
//
//    * The order in which you want AWS WAF to evaluate the Rules in a WebACL.
//    If you add more than one Rule to a WebACL, AWS WAF evaluates each request
//    against the Rules in order based on the value of Priority. (The Rule that
//    has the lowest value for Priority is evaluated first.) When a web request
//    matches all of the predicates (such as ByteMatchSets and IPSets) in a
//    Rule, AWS WAF immediately takes the corresponding action, allow or block,
//    and doesn't evaluate the request against the remaining Rules in the WebACL,
//    if any.
//
// To create and configure a WebACL, perform the following steps:
//
// Create and update the predicates that you want to include in Rules. For more
// information, see CreateByteMatchSet, UpdateByteMatchSet, CreateIPSet, UpdateIPSet,
// CreateSqlInjectionMatchSet, and UpdateSqlInjectionMatchSet.
//
// Create and update the Rules that you want to include in the WebACL. For more
// information, see CreateRule and UpdateRule.
//
// Create a WebACL. See CreateWebACL.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of an UpdateWebACL request.
//
// Submit an UpdateWebACL request to specify the Rules that you want to include
// in the WebACL, to specify the default action, and to associate the WebACL
// with a CloudFront distribution.
//
// Be aware that if you try to add a RATE_BASED rule to a web ACL without setting
// the rule type when first creating the rule, the UpdateWebACL request will
// fail because the request tries to add a REGULAR rule (the default rule type)
// with the specified ID, which does not exist.
//
// For more information about how to use the AWS WAF API to allow or block HTTP
// requests, see the AWS WAF Developer Guide (http://docs.aws.amazon.com/waf/latest/developerguide/).
//
//    // Example sending a request using the UpdateWebACLRequest method.
//    req := client.UpdateWebACLRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateWebACL
func (c *WAF) UpdateWebACLRequest(input *UpdateWebACLInput) UpdateWebACLRequest {
	op := &aws.Operation{
		Name:       opUpdateWebACL,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateWebACLInput{}
	}

	output := &UpdateWebACLOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return UpdateWebACLRequest{Request: req, Input: input}
}

const opUpdateXssMatchSet = "UpdateXssMatchSet"

// UpdateXssMatchSetRequest is a API request type for the UpdateXssMatchSet API operation.
type UpdateXssMatchSetRequest struct {
	*aws.Request
	Input *UpdateXssMatchSetInput
}

// Send marshals and sends the UpdateXssMatchSet API request.
func (r UpdateXssMatchSetRequest) Send() (*UpdateXssMatchSetOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}

	return r.Request.Data.(*UpdateXssMatchSetOutput), nil
}

// UpdateXssMatchSetRequest returns a request value for making API operation for
// AWS WAF.
//
// Inserts or deletes XssMatchTuple objects (filters) in an XssMatchSet. For
// each XssMatchTuple object, you specify the following values:
//
//    * Action: Whether to insert the object into or delete the object from
//    the array. To change a XssMatchTuple, you delete the existing object and
//    add a new one.
//
//    * FieldToMatch: The part of web requests that you want AWS WAF to inspect
//    and, if you want AWS WAF to inspect a header, the name of the header.
//
//    * TextTransformation: Which text transformation, if any, to perform on
//    the web request before inspecting the request for cross-site scripting
//    attacks.
//
// You use XssMatchSet objects to specify which CloudFront requests you want
// to allow, block, or count. For example, if you're receiving requests that
// contain cross-site scripting attacks in the request body and you want to
// block the requests, you can create an XssMatchSet with the applicable settings,
// and then configure AWS WAF to block the requests.
//
// To create and configure an XssMatchSet, perform the following steps:
//
// Submit a CreateXssMatchSet request.
//
// Use GetChangeToken to get the change token that you provide in the ChangeToken
// parameter of an UpdateIPSet request.
//
// Submit an UpdateXssMatchSet request to specify the parts of web requests
// that you want AWS WAF to inspect for cross-site scripting attacks.
//
// For more information about how to use the AWS WAF API to allow or block HTTP
// requests, see the AWS WAF Developer Guide (http://docs.aws.amazon.com/waf/latest/developerguide/).
//
//    // Example sending a request using the UpdateXssMatchSetRequest method.
//    req := client.UpdateXssMatchSetRequest(params)
//    resp, err := req.Send()
//    if err == nil {
//        fmt.Println(resp)
//    }
//
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateXssMatchSet
func (c *WAF) UpdateXssMatchSetRequest(input *UpdateXssMatchSetInput) UpdateXssMatchSetRequest {
	op := &aws.Operation{
		Name:       opUpdateXssMatchSet,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &UpdateXssMatchSetInput{}
	}

	output := &UpdateXssMatchSetOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}

	return UpdateXssMatchSetRequest{Request: req, Input: input}
}

// The ActivatedRule object in an UpdateWebACL request specifies a Rule that
// you want to insert or delete, the priority of the Rule in the WebACL, and
// the action that you want AWS WAF to take when a web request matches the Rule
// (ALLOW, BLOCK, or COUNT).
//
// To specify whether to insert or delete a Rule, use the Action parameter in
// the WebACLUpdate data type.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ActivatedRule
type ActivatedRule struct {
	_ struct{} `type:"structure"`

	// Specifies the action that CloudFront or AWS WAF takes when a web request
	// matches the conditions in the Rule. Valid values for Action include the following:
	//
	//    * ALLOW: CloudFront responds with the requested object.
	//
	//    * BLOCK: CloudFront responds with an HTTP 403 (Forbidden) status code.
	//
	//    * COUNT: AWS WAF increments a counter of requests that match the conditions
	//    in the rule and then continues to inspect the web request based on the
	//    remaining rules in the web ACL.
	//
	// Action is a required field
	Action *WafAction `type:"structure" required:"true"`

	// Specifies the order in which the Rules in a WebACL are evaluated. Rules with
	// a lower value for Priority are evaluated before Rules with a higher value.
	// The value must be a unique integer. If you add multiple Rules to a WebACL,
	// the values don't need to be consecutive.
	//
	// Priority is a required field
	Priority *int64 `type:"integer" required:"true"`

	// The RuleId for a Rule. You use RuleId to get more information about a Rule
	// (see GetRule), update a Rule (see UpdateRule), insert a Rule into a WebACL
	// or delete a one from a WebACL (see UpdateWebACL), or delete a Rule from AWS
	// WAF (see DeleteRule).
	//
	// RuleId is returned by CreateRule and by ListRules.
	//
	// RuleId is a required field
	RuleId *string `min:"1" type:"string" required:"true"`

	// The rule type, either REGULAR, as defined by Rule, or RATE_BASED, as defined
	// by RateBasedRule. The default is REGULAR. Although this field is optional,
	// be aware that if you try to add a RATE_BASED rule to a web ACL without setting
	// the type, the UpdateWebACL request will fail because the request tries to
	// add a REGULAR rule with the specified ID, which does not exist.
	Type WafRuleType `type:"string" enum:"true"`
}

// String returns the string representation
func (s ActivatedRule) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ActivatedRule) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ActivatedRule) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ActivatedRule"}

	if s.Action == nil {
		invalidParams.Add(aws.NewErrParamRequired("Action"))
	}

	if s.Priority == nil {
		invalidParams.Add(aws.NewErrParamRequired("Priority"))
	}

	if s.RuleId == nil {
		invalidParams.Add(aws.NewErrParamRequired("RuleId"))
	}
	if s.RuleId != nil && len(*s.RuleId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("RuleId", 1))
	}
	if s.Action != nil {
		if err := s.Action.Validate(); err != nil {
			invalidParams.AddNested("Action", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetAction sets the Action field's value.
func (s *ActivatedRule) SetAction(v *WafAction) *ActivatedRule {
	s.Action = v
	return s
}

// SetPriority sets the Priority field's value.
func (s *ActivatedRule) SetPriority(v int64) *ActivatedRule {
	s.Priority = &v
	return s
}

// SetRuleId sets the RuleId field's value.
func (s *ActivatedRule) SetRuleId(v string) *ActivatedRule {
	s.RuleId = &v
	return s
}

// SetType sets the Type field's value.
func (s *ActivatedRule) SetType(v WafRuleType) *ActivatedRule {
	s.Type = v
	return s
}

// In a GetByteMatchSet request, ByteMatchSet is a complex type that contains
// the ByteMatchSetId and Name of a ByteMatchSet, and the values that you specified
// when you updated the ByteMatchSet.
//
// A complex type that contains ByteMatchTuple objects, which specify the parts
// of web requests that you want AWS WAF to inspect and the values that you
// want AWS WAF to search for. If a ByteMatchSet contains more than one ByteMatchTuple
// object, a request needs to match the settings in only one ByteMatchTuple
// to be considered a match.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ByteMatchSet
type ByteMatchSet struct {
	_ struct{} `type:"structure"`

	// The ByteMatchSetId for a ByteMatchSet. You use ByteMatchSetId to get information
	// about a ByteMatchSet (see GetByteMatchSet), update a ByteMatchSet (see UpdateByteMatchSet),
	// insert a ByteMatchSet into a Rule or delete one from a Rule (see UpdateRule),
	// and delete a ByteMatchSet from AWS WAF (see DeleteByteMatchSet).
	//
	// ByteMatchSetId is returned by CreateByteMatchSet and by ListByteMatchSets.
	//
	// ByteMatchSetId is a required field
	ByteMatchSetId *string `min:"1" type:"string" required:"true"`

	// Specifies the bytes (typically a string that corresponds with ASCII characters)
	// that you want AWS WAF to search for in web requests, the location in requests
	// that you want AWS WAF to search, and other settings.
	//
	// ByteMatchTuples is a required field
	ByteMatchTuples []ByteMatchTuple `type:"list" required:"true"`

	// A friendly name or description of the ByteMatchSet. You can't change Name
	// after you create a ByteMatchSet.
	Name *string `min:"1" type:"string"`
}

// String returns the string representation
func (s ByteMatchSet) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ByteMatchSet) GoString() string {
	return s.String()
}

// SetByteMatchSetId sets the ByteMatchSetId field's value.
func (s *ByteMatchSet) SetByteMatchSetId(v string) *ByteMatchSet {
	s.ByteMatchSetId = &v
	return s
}

// SetByteMatchTuples sets the ByteMatchTuples field's value.
func (s *ByteMatchSet) SetByteMatchTuples(v []ByteMatchTuple) *ByteMatchSet {
	s.ByteMatchTuples = v
	return s
}

// SetName sets the Name field's value.
func (s *ByteMatchSet) SetName(v string) *ByteMatchSet {
	s.Name = &v
	return s
}

// Returned by ListByteMatchSets. Each ByteMatchSetSummary object includes the
// Name and ByteMatchSetId for one ByteMatchSet.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ByteMatchSetSummary
type ByteMatchSetSummary struct {
	_ struct{} `type:"structure"`

	// The ByteMatchSetId for a ByteMatchSet. You use ByteMatchSetId to get information
	// about a ByteMatchSet, update a ByteMatchSet, remove a ByteMatchSet from a
	// Rule, and delete a ByteMatchSet from AWS WAF.
	//
	// ByteMatchSetId is returned by CreateByteMatchSet and by ListByteMatchSets.
	//
	// ByteMatchSetId is a required field
	ByteMatchSetId *string `min:"1" type:"string" required:"true"`

	// A friendly name or description of the ByteMatchSet. You can't change Name
	// after you create a ByteMatchSet.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s ByteMatchSetSummary) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ByteMatchSetSummary) GoString() string {
	return s.String()
}

// SetByteMatchSetId sets the ByteMatchSetId field's value.
func (s *ByteMatchSetSummary) SetByteMatchSetId(v string) *ByteMatchSetSummary {
	s.ByteMatchSetId = &v
	return s
}

// SetName sets the Name field's value.
func (s *ByteMatchSetSummary) SetName(v string) *ByteMatchSetSummary {
	s.Name = &v
	return s
}

// In an UpdateByteMatchSet request, ByteMatchSetUpdate specifies whether to
// insert or delete a ByteMatchTuple and includes the settings for the ByteMatchTuple.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ByteMatchSetUpdate
type ByteMatchSetUpdate struct {
	_ struct{} `type:"structure"`

	// Specifies whether to insert or delete a ByteMatchTuple.
	//
	// Action is a required field
	Action ChangeAction `type:"string" required:"true" enum:"true"`

	// Information about the part of a web request that you want AWS WAF to inspect
	// and the value that you want AWS WAF to search for. If you specify DELETE
	// for the value of Action, the ByteMatchTuple values must exactly match the
	// values in the ByteMatchTuple that you want to delete from the ByteMatchSet.
	//
	// ByteMatchTuple is a required field
	ByteMatchTuple *ByteMatchTuple `type:"structure" required:"true"`
}

// String returns the string representation
func (s ByteMatchSetUpdate) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ByteMatchSetUpdate) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ByteMatchSetUpdate) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ByteMatchSetUpdate"}
	if len(s.Action) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("Action"))
	}

	if s.ByteMatchTuple == nil {
		invalidParams.Add(aws.NewErrParamRequired("ByteMatchTuple"))
	}
	if s.ByteMatchTuple != nil {
		if err := s.ByteMatchTuple.Validate(); err != nil {
			invalidParams.AddNested("ByteMatchTuple", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetAction sets the Action field's value.
func (s *ByteMatchSetUpdate) SetAction(v ChangeAction) *ByteMatchSetUpdate {
	s.Action = v
	return s
}

// SetByteMatchTuple sets the ByteMatchTuple field's value.
func (s *ByteMatchSetUpdate) SetByteMatchTuple(v *ByteMatchTuple) *ByteMatchSetUpdate {
	s.ByteMatchTuple = v
	return s
}

// The bytes (typically a string that corresponds with ASCII characters) that
// you want AWS WAF to search for in web requests, the location in requests
// that you want AWS WAF to search, and other settings.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ByteMatchTuple
type ByteMatchTuple struct {
	_ struct{} `type:"structure"`

	// The part of a web request that you want AWS WAF to search, such as a specified
	// header or a query string. For more information, see FieldToMatch.
	//
	// FieldToMatch is a required field
	FieldToMatch *FieldToMatch `type:"structure" required:"true"`

	// Within the portion of a web request that you want to search (for example,
	// in the query string, if any), specify where you want AWS WAF to search. Valid
	// values include the following:
	//
	// CONTAINS
	//
	// The specified part of the web request must include the value of TargetString,
	// but the location doesn't matter.
	//
	// CONTAINS_WORD
	//
	// The specified part of the web request must include the value of TargetString,
	// and TargetString must contain only alphanumeric characters or underscore
	// (A-Z, a-z, 0-9, or _). In addition, TargetString must be a word, which means
	// one of the following:
	//
	//    * TargetString exactly matches the value of the specified part of the
	//    web request, such as the value of a header.
	//
	//    * TargetString is at the beginning of the specified part of the web request
	//    and is followed by a character other than an alphanumeric character or
	//    underscore (_), for example, BadBot;.
	//
	//    * TargetString is at the end of the specified part of the web request
	//    and is preceded by a character other than an alphanumeric character or
	//    underscore (_), for example, ;BadBot.
	//
	//    * TargetString is in the middle of the specified part of the web request
	//    and is preceded and followed by characters other than alphanumeric characters
	//    or underscore (_), for example, -BadBot;.
	//
	// EXACTLY
	//
	// The value of the specified part of the web request must exactly match the
	// value of TargetString.
	//
	// STARTS_WITH
	//
	// The value of TargetString must appear at the beginning of the specified part
	// of the web request.
	//
	// ENDS_WITH
	//
	// The value of TargetString must appear at the end of the specified part of
	// the web request.
	//
	// PositionalConstraint is a required field
	PositionalConstraint PositionalConstraint `type:"string" required:"true" enum:"true"`

	// The value that you want AWS WAF to search for. AWS WAF searches for the specified
	// string in the part of web requests that you specified in FieldToMatch. The
	// maximum length of the value is 50 bytes.
	//
	// Valid values depend on the values that you specified for FieldToMatch:
	//
	//    * HEADER: The value that you want AWS WAF to search for in the request
	//    header that you specified in FieldToMatch, for example, the value of the
	//    User-Agent or Referer header.
	//
	//    * METHOD: The HTTP method, which indicates the type of operation specified
	//    in the request. CloudFront supports the following methods: DELETE, GET,
	//    HEAD, OPTIONS, PATCH, POST, and PUT.
	//
	//    * QUERY_STRING: The value that you want AWS WAF to search for in the query
	//    string, which is the part of a URL that appears after a ? character.
	//
	//    * URI: The value that you want AWS WAF to search for in the part of a
	//    URL that identifies a resource, for example, /images/daily-ad.jpg.
	//
	//    * BODY: The part of a request that contains any additional data that you
	//    want to send to your web server as the HTTP request body, such as data
	//    from a form. The request body immediately follows the request headers.
	//    Note that only the first 8192 bytes of the request body are forwarded
	//    to AWS WAF for inspection. To allow or block requests based on the length
	//    of the body, you can create a size constraint set. For more information,
	//    see CreateSizeConstraintSet.
	//
	// If TargetString includes alphabetic characters A-Z and a-z, note that the
	// value is case sensitive.
	//
	// If you're using the AWS WAF API
	//
	// Specify a base64-encoded version of the value. The maximum length of the
	// value before you base64-encode it is 50 bytes.
	//
	// For example, suppose the value of Type is HEADER and the value of Data is
	// User-Agent. If you want to search the User-Agent header for the value BadBot,
	// you base64-encode BadBot using MIME base64 encoding and include the resulting
	// value, QmFkQm90, in the value of TargetString.
	//
	// If you're using the AWS CLI or one of the AWS SDKs
	//
	// The value that you want AWS WAF to search for. The SDK automatically base64
	// encodes the value.
	//
	// TargetString is automatically base64 encoded/decoded by the SDK.
	//
	// TargetString is a required field
	TargetString []byte `type:"blob" required:"true"`

	// Text transformations eliminate some of the unusual formatting that attackers
	// use in web requests in an effort to bypass AWS WAF. If you specify a transformation,
	// AWS WAF performs the transformation on TargetString before inspecting a request
	// for a match.
	//
	// CMD_LINE
	//
	// When you're concerned that attackers are injecting an operating system commandline
	// command and using unusual formatting to disguise some or all of the command,
	// use this option to perform the following transformations:
	//
	//    * Delete the following characters: \ " ' ^
	//
	//    * Delete spaces before the following characters: / (
	//
	//    * Replace the following characters with a space: , ;
	//
	//    * Replace multiple spaces with one space
	//
	//    * Convert uppercase letters (A-Z) to lowercase (a-z)
	//
	// COMPRESS_WHITE_SPACE
	//
	// Use this option to replace the following characters with a space character
	// (decimal 32):
	//
	//    * \f, formfeed, decimal 12
	//
	//    * \t, tab, decimal 9
	//
	//    * \n, newline, decimal 10
	//
	//    * \r, carriage return, decimal 13
	//
	//    * \v, vertical tab, decimal 11
	//
	//    * non-breaking space, decimal 160
	//
	// COMPRESS_WHITE_SPACE also replaces multiple spaces with one space.
	//
	// HTML_ENTITY_DECODE
	//
	// Use this option to replace HTML-encoded characters with unencoded characters.
	// HTML_ENTITY_DECODE performs the following operations:
	//
	//    * Replaces (ampersand)quot; with "
	//
	//    * Replaces (ampersand)nbsp; with a non-breaking space, decimal 160
	//
	//    * Replaces (ampersand)lt; with a "less than" symbol
	//
	//    * Replaces (ampersand)gt; with >
	//
	//    * Replaces characters that are represented in hexadecimal format, (ampersand)#xhhhh;,
	//    with the corresponding characters
	//
	//    * Replaces characters that are represented in decimal format, (ampersand)#nnnn;,
	//    with the corresponding characters
	//
	// LOWERCASE
	//
	// Use this option to convert uppercase letters (A-Z) to lowercase (a-z).
	//
	// URL_DECODE
	//
	// Use this option to decode a URL-encoded value.
	//
	// NONE
	//
	// Specify NONE if you don't want to perform any text transformations.
	//
	// TextTransformation is a required field
	TextTransformation TextTransformation `type:"string" required:"true" enum:"true"`
}

// String returns the string representation
func (s ByteMatchTuple) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ByteMatchTuple) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ByteMatchTuple) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ByteMatchTuple"}

	if s.FieldToMatch == nil {
		invalidParams.Add(aws.NewErrParamRequired("FieldToMatch"))
	}
	if len(s.PositionalConstraint) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("PositionalConstraint"))
	}

	if s.TargetString == nil {
		invalidParams.Add(aws.NewErrParamRequired("TargetString"))
	}
	if len(s.TextTransformation) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("TextTransformation"))
	}
	if s.FieldToMatch != nil {
		if err := s.FieldToMatch.Validate(); err != nil {
			invalidParams.AddNested("FieldToMatch", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetFieldToMatch sets the FieldToMatch field's value.
func (s *ByteMatchTuple) SetFieldToMatch(v *FieldToMatch) *ByteMatchTuple {
	s.FieldToMatch = v
	return s
}

// SetPositionalConstraint sets the PositionalConstraint field's value.
func (s *ByteMatchTuple) SetPositionalConstraint(v PositionalConstraint) *ByteMatchTuple {
	s.PositionalConstraint = v
	return s
}

// SetTargetString sets the TargetString field's value.
func (s *ByteMatchTuple) SetTargetString(v []byte) *ByteMatchTuple {
	s.TargetString = v
	return s
}

// SetTextTransformation sets the TextTransformation field's value.
func (s *ByteMatchTuple) SetTextTransformation(v TextTransformation) *ByteMatchTuple {
	s.TextTransformation = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateByteMatchSetRequest
type CreateByteMatchSetInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// A friendly name or description of the ByteMatchSet. You can't change Name
	// after you create a ByteMatchSet.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s CreateByteMatchSetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateByteMatchSetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateByteMatchSetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreateByteMatchSetInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.Name == nil {
		invalidParams.Add(aws.NewErrParamRequired("Name"))
	}
	if s.Name != nil && len(*s.Name) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Name", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *CreateByteMatchSetInput) SetChangeToken(v string) *CreateByteMatchSetInput {
	s.ChangeToken = &v
	return s
}

// SetName sets the Name field's value.
func (s *CreateByteMatchSetInput) SetName(v string) *CreateByteMatchSetInput {
	s.Name = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateByteMatchSetResponse
type CreateByteMatchSetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// A ByteMatchSet that contains no ByteMatchTuple objects.
	ByteMatchSet *ByteMatchSet `type:"structure"`

	// The ChangeToken that you used to submit the CreateByteMatchSet request. You
	// can also use this value to query the status of the request. For more information,
	// see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s CreateByteMatchSetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateByteMatchSetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreateByteMatchSetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetByteMatchSet sets the ByteMatchSet field's value.
func (s *CreateByteMatchSetOutput) SetByteMatchSet(v *ByteMatchSet) *CreateByteMatchSetOutput {
	s.ByteMatchSet = v
	return s
}

// SetChangeToken sets the ChangeToken field's value.
func (s *CreateByteMatchSetOutput) SetChangeToken(v string) *CreateByteMatchSetOutput {
	s.ChangeToken = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateIPSetRequest
type CreateIPSetInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// A friendly name or description of the IPSet. You can't change Name after
	// you create the IPSet.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s CreateIPSetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateIPSetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateIPSetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreateIPSetInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.Name == nil {
		invalidParams.Add(aws.NewErrParamRequired("Name"))
	}
	if s.Name != nil && len(*s.Name) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Name", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *CreateIPSetInput) SetChangeToken(v string) *CreateIPSetInput {
	s.ChangeToken = &v
	return s
}

// SetName sets the Name field's value.
func (s *CreateIPSetInput) SetName(v string) *CreateIPSetInput {
	s.Name = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateIPSetResponse
type CreateIPSetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the CreateIPSet request. You can
	// also use this value to query the status of the request. For more information,
	// see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`

	// The IPSet returned in the CreateIPSet response.
	IPSet *IPSet `type:"structure"`
}

// String returns the string representation
func (s CreateIPSetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateIPSetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreateIPSetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *CreateIPSetOutput) SetChangeToken(v string) *CreateIPSetOutput {
	s.ChangeToken = &v
	return s
}

// SetIPSet sets the IPSet field's value.
func (s *CreateIPSetOutput) SetIPSet(v *IPSet) *CreateIPSetOutput {
	s.IPSet = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateRateBasedRuleRequest
type CreateRateBasedRuleInput struct {
	_ struct{} `type:"structure"`

	// The ChangeToken that you used to submit the CreateRateBasedRule request.
	// You can also use this value to query the status of the request. For more
	// information, see GetChangeTokenStatus.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// A friendly name or description for the metrics for this RateBasedRule. The
	// name can contain only alphanumeric characters (A-Z, a-z, 0-9); the name can't
	// contain whitespace. You can't change the name of the metric after you create
	// the RateBasedRule.
	//
	// MetricName is a required field
	MetricName *string `type:"string" required:"true"`

	// A friendly name or description of the RateBasedRule. You can't change the
	// name of a RateBasedRule after you create it.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// The field that AWS WAF uses to determine if requests are likely arriving
	// from a single source and thus subject to rate monitoring. The only valid
	// value for RateKey is IP. IP indicates that requests that arrive from the
	// same IP address are subject to the RateLimit that is specified in the RateBasedRule.
	//
	// RateKey is a required field
	RateKey RateKey `type:"string" required:"true" enum:"true"`

	// The maximum number of requests, which have an identical value in the field
	// that is specified by RateKey, allowed in a five-minute period. If the number
	// of requests exceeds the RateLimit and the other predicates specified in the
	// rule are also met, AWS WAF triggers the action that is specified for this
	// rule.
	//
	// RateLimit is a required field
	RateLimit *int64 `min:"2000" type:"long" required:"true"`
}

// String returns the string representation
func (s CreateRateBasedRuleInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateRateBasedRuleInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateRateBasedRuleInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreateRateBasedRuleInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.MetricName == nil {
		invalidParams.Add(aws.NewErrParamRequired("MetricName"))
	}

	if s.Name == nil {
		invalidParams.Add(aws.NewErrParamRequired("Name"))
	}
	if s.Name != nil && len(*s.Name) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Name", 1))
	}
	if len(s.RateKey) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("RateKey"))
	}

	if s.RateLimit == nil {
		invalidParams.Add(aws.NewErrParamRequired("RateLimit"))
	}
	if s.RateLimit != nil && *s.RateLimit < 2000 {
		invalidParams.Add(aws.NewErrParamMinValue("RateLimit", 2000))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *CreateRateBasedRuleInput) SetChangeToken(v string) *CreateRateBasedRuleInput {
	s.ChangeToken = &v
	return s
}

// SetMetricName sets the MetricName field's value.
func (s *CreateRateBasedRuleInput) SetMetricName(v string) *CreateRateBasedRuleInput {
	s.MetricName = &v
	return s
}

// SetName sets the Name field's value.
func (s *CreateRateBasedRuleInput) SetName(v string) *CreateRateBasedRuleInput {
	s.Name = &v
	return s
}

// SetRateKey sets the RateKey field's value.
func (s *CreateRateBasedRuleInput) SetRateKey(v RateKey) *CreateRateBasedRuleInput {
	s.RateKey = v
	return s
}

// SetRateLimit sets the RateLimit field's value.
func (s *CreateRateBasedRuleInput) SetRateLimit(v int64) *CreateRateBasedRuleInput {
	s.RateLimit = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateRateBasedRuleResponse
type CreateRateBasedRuleOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the CreateRateBasedRule request.
	// You can also use this value to query the status of the request. For more
	// information, see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`

	// The RateBasedRule that is returned in the CreateRateBasedRule response.
	Rule *RateBasedRule `type:"structure"`
}

// String returns the string representation
func (s CreateRateBasedRuleOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateRateBasedRuleOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreateRateBasedRuleOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *CreateRateBasedRuleOutput) SetChangeToken(v string) *CreateRateBasedRuleOutput {
	s.ChangeToken = &v
	return s
}

// SetRule sets the Rule field's value.
func (s *CreateRateBasedRuleOutput) SetRule(v *RateBasedRule) *CreateRateBasedRuleOutput {
	s.Rule = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateRuleRequest
type CreateRuleInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// A friendly name or description for the metrics for this Rule. The name can
	// contain only alphanumeric characters (A-Z, a-z, 0-9); the name can't contain
	// whitespace. You can't change the name of the metric after you create the
	// Rule.
	//
	// MetricName is a required field
	MetricName *string `type:"string" required:"true"`

	// A friendly name or description of the Rule. You can't change the name of
	// a Rule after you create it.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s CreateRuleInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateRuleInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateRuleInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreateRuleInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.MetricName == nil {
		invalidParams.Add(aws.NewErrParamRequired("MetricName"))
	}

	if s.Name == nil {
		invalidParams.Add(aws.NewErrParamRequired("Name"))
	}
	if s.Name != nil && len(*s.Name) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Name", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *CreateRuleInput) SetChangeToken(v string) *CreateRuleInput {
	s.ChangeToken = &v
	return s
}

// SetMetricName sets the MetricName field's value.
func (s *CreateRuleInput) SetMetricName(v string) *CreateRuleInput {
	s.MetricName = &v
	return s
}

// SetName sets the Name field's value.
func (s *CreateRuleInput) SetName(v string) *CreateRuleInput {
	s.Name = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateRuleResponse
type CreateRuleOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the CreateRule request. You can also
	// use this value to query the status of the request. For more information,
	// see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`

	// The Rule returned in the CreateRule response.
	Rule *Rule `type:"structure"`
}

// String returns the string representation
func (s CreateRuleOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateRuleOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreateRuleOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *CreateRuleOutput) SetChangeToken(v string) *CreateRuleOutput {
	s.ChangeToken = &v
	return s
}

// SetRule sets the Rule field's value.
func (s *CreateRuleOutput) SetRule(v *Rule) *CreateRuleOutput {
	s.Rule = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateSizeConstraintSetRequest
type CreateSizeConstraintSetInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// A friendly name or description of the SizeConstraintSet. You can't change
	// Name after you create a SizeConstraintSet.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s CreateSizeConstraintSetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateSizeConstraintSetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateSizeConstraintSetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreateSizeConstraintSetInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.Name == nil {
		invalidParams.Add(aws.NewErrParamRequired("Name"))
	}
	if s.Name != nil && len(*s.Name) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Name", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *CreateSizeConstraintSetInput) SetChangeToken(v string) *CreateSizeConstraintSetInput {
	s.ChangeToken = &v
	return s
}

// SetName sets the Name field's value.
func (s *CreateSizeConstraintSetInput) SetName(v string) *CreateSizeConstraintSetInput {
	s.Name = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateSizeConstraintSetResponse
type CreateSizeConstraintSetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the CreateSizeConstraintSet request.
	// You can also use this value to query the status of the request. For more
	// information, see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`

	// A SizeConstraintSet that contains no SizeConstraint objects.
	SizeConstraintSet *SizeConstraintSet `type:"structure"`
}

// String returns the string representation
func (s CreateSizeConstraintSetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateSizeConstraintSetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreateSizeConstraintSetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *CreateSizeConstraintSetOutput) SetChangeToken(v string) *CreateSizeConstraintSetOutput {
	s.ChangeToken = &v
	return s
}

// SetSizeConstraintSet sets the SizeConstraintSet field's value.
func (s *CreateSizeConstraintSetOutput) SetSizeConstraintSet(v *SizeConstraintSet) *CreateSizeConstraintSetOutput {
	s.SizeConstraintSet = v
	return s
}

// A request to create a SqlInjectionMatchSet.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateSqlInjectionMatchSetRequest
type CreateSqlInjectionMatchSetInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// A friendly name or description for the SqlInjectionMatchSet that you're creating.
	// You can't change Name after you create the SqlInjectionMatchSet.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s CreateSqlInjectionMatchSetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateSqlInjectionMatchSetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateSqlInjectionMatchSetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreateSqlInjectionMatchSetInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.Name == nil {
		invalidParams.Add(aws.NewErrParamRequired("Name"))
	}
	if s.Name != nil && len(*s.Name) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Name", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *CreateSqlInjectionMatchSetInput) SetChangeToken(v string) *CreateSqlInjectionMatchSetInput {
	s.ChangeToken = &v
	return s
}

// SetName sets the Name field's value.
func (s *CreateSqlInjectionMatchSetInput) SetName(v string) *CreateSqlInjectionMatchSetInput {
	s.Name = &v
	return s
}

// The response to a CreateSqlInjectionMatchSet request.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateSqlInjectionMatchSetResponse
type CreateSqlInjectionMatchSetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the CreateSqlInjectionMatchSet request.
	// You can also use this value to query the status of the request. For more
	// information, see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`

	// A SqlInjectionMatchSet.
	SqlInjectionMatchSet *SqlInjectionMatchSet `type:"structure"`
}

// String returns the string representation
func (s CreateSqlInjectionMatchSetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateSqlInjectionMatchSetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreateSqlInjectionMatchSetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *CreateSqlInjectionMatchSetOutput) SetChangeToken(v string) *CreateSqlInjectionMatchSetOutput {
	s.ChangeToken = &v
	return s
}

// SetSqlInjectionMatchSet sets the SqlInjectionMatchSet field's value.
func (s *CreateSqlInjectionMatchSetOutput) SetSqlInjectionMatchSet(v *SqlInjectionMatchSet) *CreateSqlInjectionMatchSetOutput {
	s.SqlInjectionMatchSet = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateWebACLRequest
type CreateWebACLInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// The action that you want AWS WAF to take when a request doesn't match the
	// criteria specified in any of the Rule objects that are associated with the
	// WebACL.
	//
	// DefaultAction is a required field
	DefaultAction *WafAction `type:"structure" required:"true"`

	// A friendly name or description for the metrics for this WebACL. The name
	// can contain only alphanumeric characters (A-Z, a-z, 0-9); the name can't
	// contain whitespace. You can't change MetricName after you create the WebACL.
	//
	// MetricName is a required field
	MetricName *string `type:"string" required:"true"`

	// A friendly name or description of the WebACL. You can't change Name after
	// you create the WebACL.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s CreateWebACLInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateWebACLInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateWebACLInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreateWebACLInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.DefaultAction == nil {
		invalidParams.Add(aws.NewErrParamRequired("DefaultAction"))
	}

	if s.MetricName == nil {
		invalidParams.Add(aws.NewErrParamRequired("MetricName"))
	}

	if s.Name == nil {
		invalidParams.Add(aws.NewErrParamRequired("Name"))
	}
	if s.Name != nil && len(*s.Name) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Name", 1))
	}
	if s.DefaultAction != nil {
		if err := s.DefaultAction.Validate(); err != nil {
			invalidParams.AddNested("DefaultAction", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *CreateWebACLInput) SetChangeToken(v string) *CreateWebACLInput {
	s.ChangeToken = &v
	return s
}

// SetDefaultAction sets the DefaultAction field's value.
func (s *CreateWebACLInput) SetDefaultAction(v *WafAction) *CreateWebACLInput {
	s.DefaultAction = v
	return s
}

// SetMetricName sets the MetricName field's value.
func (s *CreateWebACLInput) SetMetricName(v string) *CreateWebACLInput {
	s.MetricName = &v
	return s
}

// SetName sets the Name field's value.
func (s *CreateWebACLInput) SetName(v string) *CreateWebACLInput {
	s.Name = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateWebACLResponse
type CreateWebACLOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the CreateWebACL request. You can
	// also use this value to query the status of the request. For more information,
	// see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`

	// The WebACL returned in the CreateWebACL response.
	WebACL *WebACL `type:"structure"`
}

// String returns the string representation
func (s CreateWebACLOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateWebACLOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreateWebACLOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *CreateWebACLOutput) SetChangeToken(v string) *CreateWebACLOutput {
	s.ChangeToken = &v
	return s
}

// SetWebACL sets the WebACL field's value.
func (s *CreateWebACLOutput) SetWebACL(v *WebACL) *CreateWebACLOutput {
	s.WebACL = v
	return s
}

// A request to create an XssMatchSet.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateXssMatchSetRequest
type CreateXssMatchSetInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// A friendly name or description for the XssMatchSet that you're creating.
	// You can't change Name after you create the XssMatchSet.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s CreateXssMatchSetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateXssMatchSetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *CreateXssMatchSetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "CreateXssMatchSetInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.Name == nil {
		invalidParams.Add(aws.NewErrParamRequired("Name"))
	}
	if s.Name != nil && len(*s.Name) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("Name", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *CreateXssMatchSetInput) SetChangeToken(v string) *CreateXssMatchSetInput {
	s.ChangeToken = &v
	return s
}

// SetName sets the Name field's value.
func (s *CreateXssMatchSetInput) SetName(v string) *CreateXssMatchSetInput {
	s.Name = &v
	return s
}

// The response to a CreateXssMatchSet request.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/CreateXssMatchSetResponse
type CreateXssMatchSetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the CreateXssMatchSet request. You
	// can also use this value to query the status of the request. For more information,
	// see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`

	// An XssMatchSet.
	XssMatchSet *XssMatchSet `type:"structure"`
}

// String returns the string representation
func (s CreateXssMatchSetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s CreateXssMatchSetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s CreateXssMatchSetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *CreateXssMatchSetOutput) SetChangeToken(v string) *CreateXssMatchSetOutput {
	s.ChangeToken = &v
	return s
}

// SetXssMatchSet sets the XssMatchSet field's value.
func (s *CreateXssMatchSetOutput) SetXssMatchSet(v *XssMatchSet) *CreateXssMatchSetOutput {
	s.XssMatchSet = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteByteMatchSetRequest
type DeleteByteMatchSetInput struct {
	_ struct{} `type:"structure"`

	// The ByteMatchSetId of the ByteMatchSet that you want to delete. ByteMatchSetId
	// is returned by CreateByteMatchSet and by ListByteMatchSets.
	//
	// ByteMatchSetId is a required field
	ByteMatchSetId *string `min:"1" type:"string" required:"true"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s DeleteByteMatchSetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteByteMatchSetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteByteMatchSetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteByteMatchSetInput"}

	if s.ByteMatchSetId == nil {
		invalidParams.Add(aws.NewErrParamRequired("ByteMatchSetId"))
	}
	if s.ByteMatchSetId != nil && len(*s.ByteMatchSetId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ByteMatchSetId", 1))
	}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetByteMatchSetId sets the ByteMatchSetId field's value.
func (s *DeleteByteMatchSetInput) SetByteMatchSetId(v string) *DeleteByteMatchSetInput {
	s.ByteMatchSetId = &v
	return s
}

// SetChangeToken sets the ChangeToken field's value.
func (s *DeleteByteMatchSetInput) SetChangeToken(v string) *DeleteByteMatchSetInput {
	s.ChangeToken = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteByteMatchSetResponse
type DeleteByteMatchSetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the DeleteByteMatchSet request. You
	// can also use this value to query the status of the request. For more information,
	// see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s DeleteByteMatchSetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteByteMatchSetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteByteMatchSetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *DeleteByteMatchSetOutput) SetChangeToken(v string) *DeleteByteMatchSetOutput {
	s.ChangeToken = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteIPSetRequest
type DeleteIPSetInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// The IPSetId of the IPSet that you want to delete. IPSetId is returned by
	// CreateIPSet and by ListIPSets.
	//
	// IPSetId is a required field
	IPSetId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s DeleteIPSetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteIPSetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteIPSetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteIPSetInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.IPSetId == nil {
		invalidParams.Add(aws.NewErrParamRequired("IPSetId"))
	}
	if s.IPSetId != nil && len(*s.IPSetId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("IPSetId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *DeleteIPSetInput) SetChangeToken(v string) *DeleteIPSetInput {
	s.ChangeToken = &v
	return s
}

// SetIPSetId sets the IPSetId field's value.
func (s *DeleteIPSetInput) SetIPSetId(v string) *DeleteIPSetInput {
	s.IPSetId = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteIPSetResponse
type DeleteIPSetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the DeleteIPSet request. You can
	// also use this value to query the status of the request. For more information,
	// see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s DeleteIPSetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteIPSetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteIPSetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *DeleteIPSetOutput) SetChangeToken(v string) *DeleteIPSetOutput {
	s.ChangeToken = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteRateBasedRuleRequest
type DeleteRateBasedRuleInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// The RuleId of the RateBasedRule that you want to delete. RuleId is returned
	// by CreateRateBasedRule and by ListRateBasedRules.
	//
	// RuleId is a required field
	RuleId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s DeleteRateBasedRuleInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteRateBasedRuleInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteRateBasedRuleInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteRateBasedRuleInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.RuleId == nil {
		invalidParams.Add(aws.NewErrParamRequired("RuleId"))
	}
	if s.RuleId != nil && len(*s.RuleId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("RuleId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *DeleteRateBasedRuleInput) SetChangeToken(v string) *DeleteRateBasedRuleInput {
	s.ChangeToken = &v
	return s
}

// SetRuleId sets the RuleId field's value.
func (s *DeleteRateBasedRuleInput) SetRuleId(v string) *DeleteRateBasedRuleInput {
	s.RuleId = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteRateBasedRuleResponse
type DeleteRateBasedRuleOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the DeleteRateBasedRule request.
	// You can also use this value to query the status of the request. For more
	// information, see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s DeleteRateBasedRuleOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteRateBasedRuleOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteRateBasedRuleOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *DeleteRateBasedRuleOutput) SetChangeToken(v string) *DeleteRateBasedRuleOutput {
	s.ChangeToken = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteRuleRequest
type DeleteRuleInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// The RuleId of the Rule that you want to delete. RuleId is returned by CreateRule
	// and by ListRules.
	//
	// RuleId is a required field
	RuleId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s DeleteRuleInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteRuleInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteRuleInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteRuleInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.RuleId == nil {
		invalidParams.Add(aws.NewErrParamRequired("RuleId"))
	}
	if s.RuleId != nil && len(*s.RuleId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("RuleId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *DeleteRuleInput) SetChangeToken(v string) *DeleteRuleInput {
	s.ChangeToken = &v
	return s
}

// SetRuleId sets the RuleId field's value.
func (s *DeleteRuleInput) SetRuleId(v string) *DeleteRuleInput {
	s.RuleId = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteRuleResponse
type DeleteRuleOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the DeleteRule request. You can also
	// use this value to query the status of the request. For more information,
	// see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s DeleteRuleOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteRuleOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteRuleOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *DeleteRuleOutput) SetChangeToken(v string) *DeleteRuleOutput {
	s.ChangeToken = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteSizeConstraintSetRequest
type DeleteSizeConstraintSetInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// The SizeConstraintSetId of the SizeConstraintSet that you want to delete.
	// SizeConstraintSetId is returned by CreateSizeConstraintSet and by ListSizeConstraintSets.
	//
	// SizeConstraintSetId is a required field
	SizeConstraintSetId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s DeleteSizeConstraintSetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteSizeConstraintSetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteSizeConstraintSetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteSizeConstraintSetInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.SizeConstraintSetId == nil {
		invalidParams.Add(aws.NewErrParamRequired("SizeConstraintSetId"))
	}
	if s.SizeConstraintSetId != nil && len(*s.SizeConstraintSetId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("SizeConstraintSetId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *DeleteSizeConstraintSetInput) SetChangeToken(v string) *DeleteSizeConstraintSetInput {
	s.ChangeToken = &v
	return s
}

// SetSizeConstraintSetId sets the SizeConstraintSetId field's value.
func (s *DeleteSizeConstraintSetInput) SetSizeConstraintSetId(v string) *DeleteSizeConstraintSetInput {
	s.SizeConstraintSetId = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteSizeConstraintSetResponse
type DeleteSizeConstraintSetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the DeleteSizeConstraintSet request.
	// You can also use this value to query the status of the request. For more
	// information, see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s DeleteSizeConstraintSetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteSizeConstraintSetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteSizeConstraintSetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *DeleteSizeConstraintSetOutput) SetChangeToken(v string) *DeleteSizeConstraintSetOutput {
	s.ChangeToken = &v
	return s
}

// A request to delete a SqlInjectionMatchSet from AWS WAF.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteSqlInjectionMatchSetRequest
type DeleteSqlInjectionMatchSetInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// The SqlInjectionMatchSetId of the SqlInjectionMatchSet that you want to delete.
	// SqlInjectionMatchSetId is returned by CreateSqlInjectionMatchSet and by ListSqlInjectionMatchSets.
	//
	// SqlInjectionMatchSetId is a required field
	SqlInjectionMatchSetId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s DeleteSqlInjectionMatchSetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteSqlInjectionMatchSetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteSqlInjectionMatchSetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteSqlInjectionMatchSetInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.SqlInjectionMatchSetId == nil {
		invalidParams.Add(aws.NewErrParamRequired("SqlInjectionMatchSetId"))
	}
	if s.SqlInjectionMatchSetId != nil && len(*s.SqlInjectionMatchSetId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("SqlInjectionMatchSetId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *DeleteSqlInjectionMatchSetInput) SetChangeToken(v string) *DeleteSqlInjectionMatchSetInput {
	s.ChangeToken = &v
	return s
}

// SetSqlInjectionMatchSetId sets the SqlInjectionMatchSetId field's value.
func (s *DeleteSqlInjectionMatchSetInput) SetSqlInjectionMatchSetId(v string) *DeleteSqlInjectionMatchSetInput {
	s.SqlInjectionMatchSetId = &v
	return s
}

// The response to a request to delete a SqlInjectionMatchSet from AWS WAF.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteSqlInjectionMatchSetResponse
type DeleteSqlInjectionMatchSetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the DeleteSqlInjectionMatchSet request.
	// You can also use this value to query the status of the request. For more
	// information, see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s DeleteSqlInjectionMatchSetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteSqlInjectionMatchSetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteSqlInjectionMatchSetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *DeleteSqlInjectionMatchSetOutput) SetChangeToken(v string) *DeleteSqlInjectionMatchSetOutput {
	s.ChangeToken = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteWebACLRequest
type DeleteWebACLInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// The WebACLId of the WebACL that you want to delete. WebACLId is returned
	// by CreateWebACL and by ListWebACLs.
	//
	// WebACLId is a required field
	WebACLId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s DeleteWebACLInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteWebACLInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteWebACLInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteWebACLInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.WebACLId == nil {
		invalidParams.Add(aws.NewErrParamRequired("WebACLId"))
	}
	if s.WebACLId != nil && len(*s.WebACLId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("WebACLId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *DeleteWebACLInput) SetChangeToken(v string) *DeleteWebACLInput {
	s.ChangeToken = &v
	return s
}

// SetWebACLId sets the WebACLId field's value.
func (s *DeleteWebACLInput) SetWebACLId(v string) *DeleteWebACLInput {
	s.WebACLId = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteWebACLResponse
type DeleteWebACLOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the DeleteWebACL request. You can
	// also use this value to query the status of the request. For more information,
	// see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s DeleteWebACLOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteWebACLOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteWebACLOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *DeleteWebACLOutput) SetChangeToken(v string) *DeleteWebACLOutput {
	s.ChangeToken = &v
	return s
}

// A request to delete an XssMatchSet from AWS WAF.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteXssMatchSetRequest
type DeleteXssMatchSetInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// The XssMatchSetId of the XssMatchSet that you want to delete. XssMatchSetId
	// is returned by CreateXssMatchSet and by ListXssMatchSets.
	//
	// XssMatchSetId is a required field
	XssMatchSetId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s DeleteXssMatchSetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteXssMatchSetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *DeleteXssMatchSetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "DeleteXssMatchSetInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.XssMatchSetId == nil {
		invalidParams.Add(aws.NewErrParamRequired("XssMatchSetId"))
	}
	if s.XssMatchSetId != nil && len(*s.XssMatchSetId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("XssMatchSetId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *DeleteXssMatchSetInput) SetChangeToken(v string) *DeleteXssMatchSetInput {
	s.ChangeToken = &v
	return s
}

// SetXssMatchSetId sets the XssMatchSetId field's value.
func (s *DeleteXssMatchSetInput) SetXssMatchSetId(v string) *DeleteXssMatchSetInput {
	s.XssMatchSetId = &v
	return s
}

// The response to a request to delete an XssMatchSet from AWS WAF.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/DeleteXssMatchSetResponse
type DeleteXssMatchSetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the DeleteXssMatchSet request. You
	// can also use this value to query the status of the request. For more information,
	// see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s DeleteXssMatchSetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s DeleteXssMatchSetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s DeleteXssMatchSetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *DeleteXssMatchSetOutput) SetChangeToken(v string) *DeleteXssMatchSetOutput {
	s.ChangeToken = &v
	return s
}

// Specifies where in a web request to look for TargetString.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/FieldToMatch
type FieldToMatch struct {
	_ struct{} `type:"structure"`

	// When the value of Type is HEADER, enter the name of the header that you want
	// AWS WAF to search, for example, User-Agent or Referer. If the value of Type
	// is any other value, omit Data.
	//
	// The name of the header is not case sensitive.
	Data *string `type:"string"`

	// The part of the web request that you want AWS WAF to search for a specified
	// string. Parts of a request that you can search include the following:
	//
	//    * HEADER: A specified request header, for example, the value of the User-Agent
	//    or Referer header. If you choose HEADER for the type, specify the name
	//    of the header in Data.
	//
	//    * METHOD: The HTTP method, which indicated the type of operation that
	//    the request is asking the origin to perform. Amazon CloudFront supports
	//    the following methods: DELETE, GET, HEAD, OPTIONS, PATCH, POST, and PUT.
	//
	//    * QUERY_STRING: A query string, which is the part of a URL that appears
	//    after a ? character, if any.
	//
	//    * URI: The part of a web request that identifies a resource, for example,
	//    /images/daily-ad.jpg.
	//
	//    * BODY: The part of a request that contains any additional data that you
	//    want to send to your web server as the HTTP request body, such as data
	//    from a form. The request body immediately follows the request headers.
	//    Note that only the first 8192 bytes of the request body are forwarded
	//    to AWS WAF for inspection. To allow or block requests based on the length
	//    of the body, you can create a size constraint set. For more information,
	//    see CreateSizeConstraintSet.
	//
	// Type is a required field
	Type MatchFieldType `type:"string" required:"true" enum:"true"`
}

// String returns the string representation
func (s FieldToMatch) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s FieldToMatch) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *FieldToMatch) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "FieldToMatch"}
	if len(s.Type) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("Type"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetData sets the Data field's value.
func (s *FieldToMatch) SetData(v string) *FieldToMatch {
	s.Data = &v
	return s
}

// SetType sets the Type field's value.
func (s *FieldToMatch) SetType(v MatchFieldType) *FieldToMatch {
	s.Type = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetByteMatchSetRequest
type GetByteMatchSetInput struct {
	_ struct{} `type:"structure"`

	// The ByteMatchSetId of the ByteMatchSet that you want to get. ByteMatchSetId
	// is returned by CreateByteMatchSet and by ListByteMatchSets.
	//
	// ByteMatchSetId is a required field
	ByteMatchSetId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s GetByteMatchSetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetByteMatchSetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *GetByteMatchSetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "GetByteMatchSetInput"}

	if s.ByteMatchSetId == nil {
		invalidParams.Add(aws.NewErrParamRequired("ByteMatchSetId"))
	}
	if s.ByteMatchSetId != nil && len(*s.ByteMatchSetId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ByteMatchSetId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetByteMatchSetId sets the ByteMatchSetId field's value.
func (s *GetByteMatchSetInput) SetByteMatchSetId(v string) *GetByteMatchSetInput {
	s.ByteMatchSetId = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetByteMatchSetResponse
type GetByteMatchSetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the ByteMatchSet that you specified in the GetByteMatchSet
	// request. For more information, see the following topics:
	//
	//    * ByteMatchSet: Contains ByteMatchSetId, ByteMatchTuples, and Name
	//
	//    * ByteMatchTuples: Contains an array of ByteMatchTuple objects. Each ByteMatchTuple
	//    object contains FieldToMatch, PositionalConstraint, TargetString, and
	//    TextTransformation
	//
	//    * FieldToMatch: Contains Data and Type
	ByteMatchSet *ByteMatchSet `type:"structure"`
}

// String returns the string representation
func (s GetByteMatchSetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetByteMatchSetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s GetByteMatchSetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetByteMatchSet sets the ByteMatchSet field's value.
func (s *GetByteMatchSetOutput) SetByteMatchSet(v *ByteMatchSet) *GetByteMatchSetOutput {
	s.ByteMatchSet = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetChangeTokenRequest
type GetChangeTokenInput struct {
	_ struct{} `type:"structure"`
}

// String returns the string representation
func (s GetChangeTokenInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetChangeTokenInput) GoString() string {
	return s.String()
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetChangeTokenResponse
type GetChangeTokenOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used in the request. Use this value in a GetChangeTokenStatus
	// request to get the current status of the request.
	ChangeToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s GetChangeTokenOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetChangeTokenOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s GetChangeTokenOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *GetChangeTokenOutput) SetChangeToken(v string) *GetChangeTokenOutput {
	s.ChangeToken = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetChangeTokenStatusRequest
type GetChangeTokenStatusInput struct {
	_ struct{} `type:"structure"`

	// The change token for which you want to get the status. This change token
	// was previously returned in the GetChangeToken response.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s GetChangeTokenStatusInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetChangeTokenStatusInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *GetChangeTokenStatusInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "GetChangeTokenStatusInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *GetChangeTokenStatusInput) SetChangeToken(v string) *GetChangeTokenStatusInput {
	s.ChangeToken = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetChangeTokenStatusResponse
type GetChangeTokenStatusOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The status of the change token.
	ChangeTokenStatus ChangeTokenStatus `type:"string" enum:"true"`
}

// String returns the string representation
func (s GetChangeTokenStatusOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetChangeTokenStatusOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s GetChangeTokenStatusOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeTokenStatus sets the ChangeTokenStatus field's value.
func (s *GetChangeTokenStatusOutput) SetChangeTokenStatus(v ChangeTokenStatus) *GetChangeTokenStatusOutput {
	s.ChangeTokenStatus = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetIPSetRequest
type GetIPSetInput struct {
	_ struct{} `type:"structure"`

	// The IPSetId of the IPSet that you want to get. IPSetId is returned by CreateIPSet
	// and by ListIPSets.
	//
	// IPSetId is a required field
	IPSetId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s GetIPSetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetIPSetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *GetIPSetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "GetIPSetInput"}

	if s.IPSetId == nil {
		invalidParams.Add(aws.NewErrParamRequired("IPSetId"))
	}
	if s.IPSetId != nil && len(*s.IPSetId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("IPSetId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetIPSetId sets the IPSetId field's value.
func (s *GetIPSetInput) SetIPSetId(v string) *GetIPSetInput {
	s.IPSetId = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetIPSetResponse
type GetIPSetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the IPSet that you specified in the GetIPSet request. For
	// more information, see the following topics:
	//
	//    * IPSet: Contains IPSetDescriptors, IPSetId, and Name
	//
	//    * IPSetDescriptors: Contains an array of IPSetDescriptor objects. Each
	//    IPSetDescriptor object contains Type and Value
	IPSet *IPSet `type:"structure"`
}

// String returns the string representation
func (s GetIPSetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetIPSetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s GetIPSetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetIPSet sets the IPSet field's value.
func (s *GetIPSetOutput) SetIPSet(v *IPSet) *GetIPSetOutput {
	s.IPSet = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetRateBasedRuleRequest
type GetRateBasedRuleInput struct {
	_ struct{} `type:"structure"`

	// The RuleId of the RateBasedRule that you want to get. RuleId is returned
	// by CreateRateBasedRule and by ListRateBasedRules.
	//
	// RuleId is a required field
	RuleId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s GetRateBasedRuleInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetRateBasedRuleInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *GetRateBasedRuleInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "GetRateBasedRuleInput"}

	if s.RuleId == nil {
		invalidParams.Add(aws.NewErrParamRequired("RuleId"))
	}
	if s.RuleId != nil && len(*s.RuleId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("RuleId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetRuleId sets the RuleId field's value.
func (s *GetRateBasedRuleInput) SetRuleId(v string) *GetRateBasedRuleInput {
	s.RuleId = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetRateBasedRuleManagedKeysRequest
type GetRateBasedRuleManagedKeysInput struct {
	_ struct{} `type:"structure"`

	// A null value and not currently used. Do not include this in your request.
	NextMarker *string `min:"1" type:"string"`

	// The RuleId of the RateBasedRule for which you want to get a list of ManagedKeys.
	// RuleId is returned by CreateRateBasedRule and by ListRateBasedRules.
	//
	// RuleId is a required field
	RuleId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s GetRateBasedRuleManagedKeysInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetRateBasedRuleManagedKeysInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *GetRateBasedRuleManagedKeysInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "GetRateBasedRuleManagedKeysInput"}
	if s.NextMarker != nil && len(*s.NextMarker) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("NextMarker", 1))
	}

	if s.RuleId == nil {
		invalidParams.Add(aws.NewErrParamRequired("RuleId"))
	}
	if s.RuleId != nil && len(*s.RuleId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("RuleId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetNextMarker sets the NextMarker field's value.
func (s *GetRateBasedRuleManagedKeysInput) SetNextMarker(v string) *GetRateBasedRuleManagedKeysInput {
	s.NextMarker = &v
	return s
}

// SetRuleId sets the RuleId field's value.
func (s *GetRateBasedRuleManagedKeysInput) SetRuleId(v string) *GetRateBasedRuleManagedKeysInput {
	s.RuleId = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetRateBasedRuleManagedKeysResponse
type GetRateBasedRuleManagedKeysOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// An array of IP addresses that currently are blocked by the specified RateBasedRule.
	ManagedKeys []string `type:"list"`

	// A null value and not currently used.
	NextMarker *string `min:"1" type:"string"`
}

// String returns the string representation
func (s GetRateBasedRuleManagedKeysOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetRateBasedRuleManagedKeysOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s GetRateBasedRuleManagedKeysOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetManagedKeys sets the ManagedKeys field's value.
func (s *GetRateBasedRuleManagedKeysOutput) SetManagedKeys(v []string) *GetRateBasedRuleManagedKeysOutput {
	s.ManagedKeys = v
	return s
}

// SetNextMarker sets the NextMarker field's value.
func (s *GetRateBasedRuleManagedKeysOutput) SetNextMarker(v string) *GetRateBasedRuleManagedKeysOutput {
	s.NextMarker = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetRateBasedRuleResponse
type GetRateBasedRuleOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the RateBasedRule that you specified in the GetRateBasedRule
	// request.
	Rule *RateBasedRule `type:"structure"`
}

// String returns the string representation
func (s GetRateBasedRuleOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetRateBasedRuleOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s GetRateBasedRuleOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetRule sets the Rule field's value.
func (s *GetRateBasedRuleOutput) SetRule(v *RateBasedRule) *GetRateBasedRuleOutput {
	s.Rule = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetRuleRequest
type GetRuleInput struct {
	_ struct{} `type:"structure"`

	// The RuleId of the Rule that you want to get. RuleId is returned by CreateRule
	// and by ListRules.
	//
	// RuleId is a required field
	RuleId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s GetRuleInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetRuleInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *GetRuleInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "GetRuleInput"}

	if s.RuleId == nil {
		invalidParams.Add(aws.NewErrParamRequired("RuleId"))
	}
	if s.RuleId != nil && len(*s.RuleId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("RuleId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetRuleId sets the RuleId field's value.
func (s *GetRuleInput) SetRuleId(v string) *GetRuleInput {
	s.RuleId = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetRuleResponse
type GetRuleOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the Rule that you specified in the GetRule request. For
	// more information, see the following topics:
	//
	//    * Rule: Contains MetricName, Name, an array of Predicate objects, and
	//    RuleId
	//
	//    * Predicate: Each Predicate object contains DataId, Negated, and Type
	Rule *Rule `type:"structure"`
}

// String returns the string representation
func (s GetRuleOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetRuleOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s GetRuleOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetRule sets the Rule field's value.
func (s *GetRuleOutput) SetRule(v *Rule) *GetRuleOutput {
	s.Rule = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetSampledRequestsRequest
type GetSampledRequestsInput struct {
	_ struct{} `type:"structure"`

	// 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.
	//
	// MaxItems is a required field
	MaxItems *int64 `min:"1" type:"long" required:"true"`

	// RuleId is one of two values:
	//
	//    * The RuleId of the Rule for which you want GetSampledRequests to return
	//    a sample of requests.
	//
	//    * Default_Action, which causes GetSampledRequests to return a sample of
	//    the requests that didn't match any of the rules in the specified WebACL.
	//
	// RuleId is a required field
	RuleId *string `min:"1" type:"string" required:"true"`

	// 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. Specify the date
	// and time in the following format: "2016-09-27T14:50Z". You can specify any
	// time range in the previous three hours.
	//
	// TimeWindow is a required field
	TimeWindow *TimeWindow `type:"structure" required:"true"`

	// The WebACLId of the WebACL for which you want GetSampledRequests to return
	// a sample of requests.
	//
	// WebAclId is a required field
	WebAclId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s GetSampledRequestsInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetSampledRequestsInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *GetSampledRequestsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "GetSampledRequestsInput"}

	if s.MaxItems == nil {
		invalidParams.Add(aws.NewErrParamRequired("MaxItems"))
	}
	if s.MaxItems != nil && *s.MaxItems < 1 {
		invalidParams.Add(aws.NewErrParamMinValue("MaxItems", 1))
	}

	if s.RuleId == nil {
		invalidParams.Add(aws.NewErrParamRequired("RuleId"))
	}
	if s.RuleId != nil && len(*s.RuleId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("RuleId", 1))
	}

	if s.TimeWindow == nil {
		invalidParams.Add(aws.NewErrParamRequired("TimeWindow"))
	}

	if s.WebAclId == nil {
		invalidParams.Add(aws.NewErrParamRequired("WebAclId"))
	}
	if s.WebAclId != nil && len(*s.WebAclId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("WebAclId", 1))
	}
	if s.TimeWindow != nil {
		if err := s.TimeWindow.Validate(); err != nil {
			invalidParams.AddNested("TimeWindow", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetMaxItems sets the MaxItems field's value.
func (s *GetSampledRequestsInput) SetMaxItems(v int64) *GetSampledRequestsInput {
	s.MaxItems = &v
	return s
}

// SetRuleId sets the RuleId field's value.
func (s *GetSampledRequestsInput) SetRuleId(v string) *GetSampledRequestsInput {
	s.RuleId = &v
	return s
}

// SetTimeWindow sets the TimeWindow field's value.
func (s *GetSampledRequestsInput) SetTimeWindow(v *TimeWindow) *GetSampledRequestsInput {
	s.TimeWindow = v
	return s
}

// SetWebAclId sets the WebAclId field's value.
func (s *GetSampledRequestsInput) SetWebAclId(v string) *GetSampledRequestsInput {
	s.WebAclId = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetSampledRequestsResponse
type GetSampledRequestsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// 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 `type:"long"`

	// A complex type that contains detailed information about each of the requests
	// in the sample.
	SampledRequests []SampledHTTPRequest `type:"list"`

	// 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.
	TimeWindow *TimeWindow `type:"structure"`
}

// String returns the string representation
func (s GetSampledRequestsOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetSampledRequestsOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s GetSampledRequestsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetPopulationSize sets the PopulationSize field's value.
func (s *GetSampledRequestsOutput) SetPopulationSize(v int64) *GetSampledRequestsOutput {
	s.PopulationSize = &v
	return s
}

// SetSampledRequests sets the SampledRequests field's value.
func (s *GetSampledRequestsOutput) SetSampledRequests(v []SampledHTTPRequest) *GetSampledRequestsOutput {
	s.SampledRequests = v
	return s
}

// SetTimeWindow sets the TimeWindow field's value.
func (s *GetSampledRequestsOutput) SetTimeWindow(v *TimeWindow) *GetSampledRequestsOutput {
	s.TimeWindow = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetSizeConstraintSetRequest
type GetSizeConstraintSetInput struct {
	_ struct{} `type:"structure"`

	// The SizeConstraintSetId of the SizeConstraintSet that you want to get. SizeConstraintSetId
	// is returned by CreateSizeConstraintSet and by ListSizeConstraintSets.
	//
	// SizeConstraintSetId is a required field
	SizeConstraintSetId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s GetSizeConstraintSetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetSizeConstraintSetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *GetSizeConstraintSetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "GetSizeConstraintSetInput"}

	if s.SizeConstraintSetId == nil {
		invalidParams.Add(aws.NewErrParamRequired("SizeConstraintSetId"))
	}
	if s.SizeConstraintSetId != nil && len(*s.SizeConstraintSetId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("SizeConstraintSetId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetSizeConstraintSetId sets the SizeConstraintSetId field's value.
func (s *GetSizeConstraintSetInput) SetSizeConstraintSetId(v string) *GetSizeConstraintSetInput {
	s.SizeConstraintSetId = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetSizeConstraintSetResponse
type GetSizeConstraintSetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the SizeConstraintSet that you specified in the GetSizeConstraintSet
	// request. For more information, see the following topics:
	//
	//    * SizeConstraintSet: Contains SizeConstraintSetId, SizeConstraints, and
	//    Name
	//
	//    * SizeConstraints: Contains an array of SizeConstraint objects. Each SizeConstraint
	//    object contains FieldToMatch, TextTransformation, ComparisonOperator,
	//    and Size
	//
	//    * FieldToMatch: Contains Data and Type
	SizeConstraintSet *SizeConstraintSet `type:"structure"`
}

// String returns the string representation
func (s GetSizeConstraintSetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetSizeConstraintSetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s GetSizeConstraintSetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetSizeConstraintSet sets the SizeConstraintSet field's value.
func (s *GetSizeConstraintSetOutput) SetSizeConstraintSet(v *SizeConstraintSet) *GetSizeConstraintSetOutput {
	s.SizeConstraintSet = v
	return s
}

// A request to get a SqlInjectionMatchSet.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetSqlInjectionMatchSetRequest
type GetSqlInjectionMatchSetInput struct {
	_ struct{} `type:"structure"`

	// The SqlInjectionMatchSetId of the SqlInjectionMatchSet that you want to get.
	// SqlInjectionMatchSetId is returned by CreateSqlInjectionMatchSet and by ListSqlInjectionMatchSets.
	//
	// SqlInjectionMatchSetId is a required field
	SqlInjectionMatchSetId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s GetSqlInjectionMatchSetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetSqlInjectionMatchSetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *GetSqlInjectionMatchSetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "GetSqlInjectionMatchSetInput"}

	if s.SqlInjectionMatchSetId == nil {
		invalidParams.Add(aws.NewErrParamRequired("SqlInjectionMatchSetId"))
	}
	if s.SqlInjectionMatchSetId != nil && len(*s.SqlInjectionMatchSetId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("SqlInjectionMatchSetId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetSqlInjectionMatchSetId sets the SqlInjectionMatchSetId field's value.
func (s *GetSqlInjectionMatchSetInput) SetSqlInjectionMatchSetId(v string) *GetSqlInjectionMatchSetInput {
	s.SqlInjectionMatchSetId = &v
	return s
}

// The response to a GetSqlInjectionMatchSet request.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetSqlInjectionMatchSetResponse
type GetSqlInjectionMatchSetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the SqlInjectionMatchSet that you specified in the GetSqlInjectionMatchSet
	// request. For more information, see the following topics:
	//
	//    * SqlInjectionMatchSet: Contains Name, SqlInjectionMatchSetId, and an
	//    array of SqlInjectionMatchTuple objects
	//
	//    * SqlInjectionMatchTuple: Each SqlInjectionMatchTuple object contains
	//    FieldToMatch and TextTransformation
	//
	//    * FieldToMatch: Contains Data and Type
	SqlInjectionMatchSet *SqlInjectionMatchSet `type:"structure"`
}

// String returns the string representation
func (s GetSqlInjectionMatchSetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetSqlInjectionMatchSetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s GetSqlInjectionMatchSetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetSqlInjectionMatchSet sets the SqlInjectionMatchSet field's value.
func (s *GetSqlInjectionMatchSetOutput) SetSqlInjectionMatchSet(v *SqlInjectionMatchSet) *GetSqlInjectionMatchSetOutput {
	s.SqlInjectionMatchSet = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetWebACLRequest
type GetWebACLInput struct {
	_ struct{} `type:"structure"`

	// The WebACLId of the WebACL that you want to get. WebACLId is returned by
	// CreateWebACL and by ListWebACLs.
	//
	// WebACLId is a required field
	WebACLId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s GetWebACLInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetWebACLInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *GetWebACLInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "GetWebACLInput"}

	if s.WebACLId == nil {
		invalidParams.Add(aws.NewErrParamRequired("WebACLId"))
	}
	if s.WebACLId != nil && len(*s.WebACLId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("WebACLId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetWebACLId sets the WebACLId field's value.
func (s *GetWebACLInput) SetWebACLId(v string) *GetWebACLInput {
	s.WebACLId = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetWebACLResponse
type GetWebACLOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the WebACL that you specified in the GetWebACL request.
	// For more information, see the following topics:
	//
	//    * WebACL: Contains DefaultAction, MetricName, Name, an array of Rule objects,
	//    and WebACLId
	//
	//    * DefaultAction (Data type is WafAction): Contains Type
	//
	//    * Rules: Contains an array of ActivatedRule objects, which contain Action,
	//    Priority, and RuleId
	//
	//    * Action: Contains Type
	WebACL *WebACL `type:"structure"`
}

// String returns the string representation
func (s GetWebACLOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetWebACLOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s GetWebACLOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetWebACL sets the WebACL field's value.
func (s *GetWebACLOutput) SetWebACL(v *WebACL) *GetWebACLOutput {
	s.WebACL = v
	return s
}

// A request to get an XssMatchSet.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetXssMatchSetRequest
type GetXssMatchSetInput struct {
	_ struct{} `type:"structure"`

	// The XssMatchSetId of the XssMatchSet that you want to get. XssMatchSetId
	// is returned by CreateXssMatchSet and by ListXssMatchSets.
	//
	// XssMatchSetId is a required field
	XssMatchSetId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s GetXssMatchSetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetXssMatchSetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *GetXssMatchSetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "GetXssMatchSetInput"}

	if s.XssMatchSetId == nil {
		invalidParams.Add(aws.NewErrParamRequired("XssMatchSetId"))
	}
	if s.XssMatchSetId != nil && len(*s.XssMatchSetId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("XssMatchSetId", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetXssMatchSetId sets the XssMatchSetId field's value.
func (s *GetXssMatchSetInput) SetXssMatchSetId(v string) *GetXssMatchSetInput {
	s.XssMatchSetId = &v
	return s
}

// The response to a GetXssMatchSet request.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/GetXssMatchSetResponse
type GetXssMatchSetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// Information about the XssMatchSet that you specified in the GetXssMatchSet
	// request. For more information, see the following topics:
	//
	//    * XssMatchSet: Contains Name, XssMatchSetId, and an array of XssMatchTuple
	//    objects
	//
	//    * XssMatchTuple: Each XssMatchTuple object contains FieldToMatch and TextTransformation
	//
	//    * FieldToMatch: Contains Data and Type
	XssMatchSet *XssMatchSet `type:"structure"`
}

// String returns the string representation
func (s GetXssMatchSetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s GetXssMatchSetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s GetXssMatchSetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetXssMatchSet sets the XssMatchSet field's value.
func (s *GetXssMatchSetOutput) SetXssMatchSet(v *XssMatchSet) *GetXssMatchSetOutput {
	s.XssMatchSet = v
	return s
}

// The response from a GetSampledRequests request includes an HTTPHeader complex
// type that appears as Headers in the response syntax. HTTPHeader contains
// the names and values of all of the headers that appear in one of the web
// requests that were returned by GetSampledRequests.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/HTTPHeader
type HTTPHeader struct {
	_ struct{} `type:"structure"`

	// The name of one of the headers in the sampled web request.
	Name *string `type:"string"`

	// The value of one of the headers in the sampled web request.
	Value *string `type:"string"`
}

// String returns the string representation
func (s HTTPHeader) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s HTTPHeader) GoString() string {
	return s.String()
}

// SetName sets the Name field's value.
func (s *HTTPHeader) SetName(v string) *HTTPHeader {
	s.Name = &v
	return s
}

// SetValue sets the Value field's value.
func (s *HTTPHeader) SetValue(v string) *HTTPHeader {
	s.Value = &v
	return s
}

// The response from a GetSampledRequests request includes an HTTPRequest complex
// type that appears as Request in the response syntax. HTTPRequest contains
// information about one of the web requests that were returned by GetSampledRequests.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/HTTPRequest
type HTTPRequest struct {
	_ struct{} `type:"structure"`

	// The IP address that the request originated from. If the WebACL is associated
	// with a CloudFront distribution, this is the value of one of the following
	// fields in CloudFront access logs:
	//
	//    * c-ip, if the viewer did not use an HTTP proxy or a load balancer to
	//    send the request
	//
	//    * x-forwarded-for, if the viewer did use an HTTP proxy or a load balancer
	//    to send the request
	ClientIP *string `type:"string"`

	// The two-letter country code for the country that the request originated from.
	// For a current list of country codes, see the Wikipedia entry ISO 3166-1 alpha-2
	// (https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2).
	Country *string `type:"string"`

	// The HTTP version specified in the sampled web request, for example, HTTP/1.1.
	HTTPVersion *string `type:"string"`

	// A complex type that contains two values for each header in the sampled web
	// request: the name of the header and the value of the header.
	Headers []HTTPHeader `type:"list"`

	// The HTTP method specified in the sampled web request. CloudFront supports
	// the following methods: DELETE, GET, HEAD, OPTIONS, PATCH, POST, and PUT.
	Method *string `type:"string"`

	// The part of a web request that identifies the resource, for example, /images/daily-ad.jpg.
	URI *string `type:"string"`
}

// String returns the string representation
func (s HTTPRequest) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s HTTPRequest) GoString() string {
	return s.String()
}

// SetClientIP sets the ClientIP field's value.
func (s *HTTPRequest) SetClientIP(v string) *HTTPRequest {
	s.ClientIP = &v
	return s
}

// SetCountry sets the Country field's value.
func (s *HTTPRequest) SetCountry(v string) *HTTPRequest {
	s.Country = &v
	return s
}

// SetHTTPVersion sets the HTTPVersion field's value.
func (s *HTTPRequest) SetHTTPVersion(v string) *HTTPRequest {
	s.HTTPVersion = &v
	return s
}

// SetHeaders sets the Headers field's value.
func (s *HTTPRequest) SetHeaders(v []HTTPHeader) *HTTPRequest {
	s.Headers = v
	return s
}

// SetMethod sets the Method field's value.
func (s *HTTPRequest) SetMethod(v string) *HTTPRequest {
	s.Method = &v
	return s
}

// SetURI sets the URI field's value.
func (s *HTTPRequest) SetURI(v string) *HTTPRequest {
	s.URI = &v
	return s
}

// Contains one or more IP addresses or blocks of IP addresses specified in
// Classless Inter-Domain Routing (CIDR) notation. AWS WAF supports /8, /16,
// /24, and /32 IP address ranges for IPv4, and /24, /32, /48, /56, /64 and
// /128 for IPv6.
//
// To specify an individual IP address, you specify the four-part IP address
// followed by a /32, for example, 192.0.2.0/31. To block a range of IP addresses,
// you can specify a /128, /64, /56, /48, /32, /24, /16, or /8 CIDR. For more
// information about CIDR notation, see the Wikipedia entry Classless Inter-Domain
// Routing (https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing).
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/IPSet
type IPSet struct {
	_ struct{} `type:"structure"`

	// The IP address type (IPV4 or IPV6) and the IP address range (in CIDR notation)
	// that web requests originate from. If the WebACL is associated with a CloudFront
	// distribution and the viewer did not use an HTTP proxy or a load balancer
	// to send the request, this is the value of the c-ip field in the CloudFront
	// access logs.
	//
	// IPSetDescriptors is a required field
	IPSetDescriptors []IPSetDescriptor `type:"list" required:"true"`

	// The IPSetId for an IPSet. You use IPSetId to get information about an IPSet
	// (see GetIPSet), update an IPSet (see UpdateIPSet), insert an IPSet into a
	// Rule or delete one from a Rule (see UpdateRule), and delete an IPSet from
	// AWS WAF (see DeleteIPSet).
	//
	// IPSetId is returned by CreateIPSet and by ListIPSets.
	//
	// IPSetId is a required field
	IPSetId *string `min:"1" type:"string" required:"true"`

	// A friendly name or description of the IPSet. You can't change the name of
	// an IPSet after you create it.
	Name *string `min:"1" type:"string"`
}

// String returns the string representation
func (s IPSet) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s IPSet) GoString() string {
	return s.String()
}

// SetIPSetDescriptors sets the IPSetDescriptors field's value.
func (s *IPSet) SetIPSetDescriptors(v []IPSetDescriptor) *IPSet {
	s.IPSetDescriptors = v
	return s
}

// SetIPSetId sets the IPSetId field's value.
func (s *IPSet) SetIPSetId(v string) *IPSet {
	s.IPSetId = &v
	return s
}

// SetName sets the Name field's value.
func (s *IPSet) SetName(v string) *IPSet {
	s.Name = &v
	return s
}

// Specifies the IP address type (IPV4 or IPV6) and the IP address range (in
// CIDR format) that web requests originate from.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/IPSetDescriptor
type IPSetDescriptor struct {
	_ struct{} `type:"structure"`

	// Specify IPV4 or IPV6.
	//
	// Type is a required field
	Type IPSetDescriptorType `type:"string" required:"true" enum:"true"`

	// Specify an IPv4 address by using CIDR notation. For example:
	//
	//    * 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.
	//
	// For more information about CIDR notation, see the Wikipedia entry Classless
	// Inter-Domain Routing (https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing).
	//
	// Specify an IPv6 address by using CIDR notation. For example:
	//
	//    * 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.
	//
	// Value is a required field
	Value *string `type:"string" required:"true"`
}

// String returns the string representation
func (s IPSetDescriptor) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s IPSetDescriptor) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *IPSetDescriptor) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "IPSetDescriptor"}
	if len(s.Type) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("Type"))
	}

	if s.Value == nil {
		invalidParams.Add(aws.NewErrParamRequired("Value"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetType sets the Type field's value.
func (s *IPSetDescriptor) SetType(v IPSetDescriptorType) *IPSetDescriptor {
	s.Type = v
	return s
}

// SetValue sets the Value field's value.
func (s *IPSetDescriptor) SetValue(v string) *IPSetDescriptor {
	s.Value = &v
	return s
}

// Contains the identifier and the name of the IPSet.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/IPSetSummary
type IPSetSummary struct {
	_ struct{} `type:"structure"`

	// The IPSetId for an IPSet. You can use IPSetId in a GetIPSet request to get
	// detailed information about an IPSet.
	//
	// IPSetId is a required field
	IPSetId *string `min:"1" type:"string" required:"true"`

	// A friendly name or description of the IPSet. You can't change the name of
	// an IPSet after you create it.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s IPSetSummary) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s IPSetSummary) GoString() string {
	return s.String()
}

// SetIPSetId sets the IPSetId field's value.
func (s *IPSetSummary) SetIPSetId(v string) *IPSetSummary {
	s.IPSetId = &v
	return s
}

// SetName sets the Name field's value.
func (s *IPSetSummary) SetName(v string) *IPSetSummary {
	s.Name = &v
	return s
}

// Specifies the type of update to perform to an IPSet with UpdateIPSet.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/IPSetUpdate
type IPSetUpdate struct {
	_ struct{} `type:"structure"`

	// Specifies whether to insert or delete an IP address with UpdateIPSet.
	//
	// Action is a required field
	Action ChangeAction `type:"string" required:"true" enum:"true"`

	// The IP address type (IPV4 or IPV6) and the IP address range (in CIDR notation)
	// that web requests originate from.
	//
	// IPSetDescriptor is a required field
	IPSetDescriptor *IPSetDescriptor `type:"structure" required:"true"`
}

// String returns the string representation
func (s IPSetUpdate) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s IPSetUpdate) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *IPSetUpdate) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "IPSetUpdate"}
	if len(s.Action) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("Action"))
	}

	if s.IPSetDescriptor == nil {
		invalidParams.Add(aws.NewErrParamRequired("IPSetDescriptor"))
	}
	if s.IPSetDescriptor != nil {
		if err := s.IPSetDescriptor.Validate(); err != nil {
			invalidParams.AddNested("IPSetDescriptor", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetAction sets the Action field's value.
func (s *IPSetUpdate) SetAction(v ChangeAction) *IPSetUpdate {
	s.Action = v
	return s
}

// SetIPSetDescriptor sets the IPSetDescriptor field's value.
func (s *IPSetUpdate) SetIPSetDescriptor(v *IPSetDescriptor) *IPSetUpdate {
	s.IPSetDescriptor = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListByteMatchSetsRequest
type ListByteMatchSetsInput struct {
	_ struct{} `type:"structure"`

	// Specifies the number of ByteMatchSet objects that you want AWS WAF to return
	// for this request. If you have more ByteMatchSets objects than the number
	// you specify for Limit, the response includes a NextMarker value that you
	// can use to get another batch of ByteMatchSet objects.
	Limit *int64 `type:"integer"`

	// If you specify a value for Limit and you have more ByteMatchSets than the
	// value of Limit, AWS WAF returns a NextMarker value in the response that allows
	// you to list another group of ByteMatchSets. For the second and subsequent
	// ListByteMatchSets requests, specify the value of NextMarker from the previous
	// response to get information about another batch of ByteMatchSets.
	NextMarker *string `min:"1" type:"string"`
}

// String returns the string representation
func (s ListByteMatchSetsInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListByteMatchSetsInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListByteMatchSetsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ListByteMatchSetsInput"}
	if s.NextMarker != nil && len(*s.NextMarker) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("NextMarker", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetLimit sets the Limit field's value.
func (s *ListByteMatchSetsInput) SetLimit(v int64) *ListByteMatchSetsInput {
	s.Limit = &v
	return s
}

// SetNextMarker sets the NextMarker field's value.
func (s *ListByteMatchSetsInput) SetNextMarker(v string) *ListByteMatchSetsInput {
	s.NextMarker = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListByteMatchSetsResponse
type ListByteMatchSetsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// An array of ByteMatchSetSummary objects.
	ByteMatchSets []ByteMatchSetSummary `type:"list"`

	// If you have more ByteMatchSet objects than the number that you specified
	// for Limit in the request, the response includes a NextMarker value. To list
	// more ByteMatchSet objects, submit another ListByteMatchSets request, and
	// specify the NextMarker value from the response in the NextMarker value in
	// the next request.
	NextMarker *string `min:"1" type:"string"`
}

// String returns the string representation
func (s ListByteMatchSetsOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListByteMatchSetsOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s ListByteMatchSetsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetByteMatchSets sets the ByteMatchSets field's value.
func (s *ListByteMatchSetsOutput) SetByteMatchSets(v []ByteMatchSetSummary) *ListByteMatchSetsOutput {
	s.ByteMatchSets = v
	return s
}

// SetNextMarker sets the NextMarker field's value.
func (s *ListByteMatchSetsOutput) SetNextMarker(v string) *ListByteMatchSetsOutput {
	s.NextMarker = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListIPSetsRequest
type ListIPSetsInput struct {
	_ struct{} `type:"structure"`

	// Specifies the number of IPSet objects that you want AWS WAF to return for
	// this request. If you have more IPSet objects than the number you specify
	// for Limit, the response includes a NextMarker value that you can use to get
	// another batch of IPSet objects.
	Limit *int64 `type:"integer"`

	// If you specify a value for Limit and you have more IPSets than the value
	// of Limit, AWS WAF returns a NextMarker value in the response that allows
	// you to list another group of IPSets. For the second and subsequent ListIPSets
	// requests, specify the value of NextMarker from the previous response to get
	// information about another batch of ByteMatchSets.
	NextMarker *string `min:"1" type:"string"`
}

// String returns the string representation
func (s ListIPSetsInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListIPSetsInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListIPSetsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ListIPSetsInput"}
	if s.NextMarker != nil && len(*s.NextMarker) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("NextMarker", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetLimit sets the Limit field's value.
func (s *ListIPSetsInput) SetLimit(v int64) *ListIPSetsInput {
	s.Limit = &v
	return s
}

// SetNextMarker sets the NextMarker field's value.
func (s *ListIPSetsInput) SetNextMarker(v string) *ListIPSetsInput {
	s.NextMarker = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListIPSetsResponse
type ListIPSetsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// An array of IPSetSummary objects.
	IPSets []IPSetSummary `type:"list"`

	// If you have more IPSet objects than the number that you specified for Limit
	// in the request, the response includes a NextMarker value. To list more IPSet
	// objects, submit another ListIPSets request, and specify the NextMarker value
	// from the response in the NextMarker value in the next request.
	NextMarker *string `min:"1" type:"string"`
}

// String returns the string representation
func (s ListIPSetsOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListIPSetsOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s ListIPSetsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetIPSets sets the IPSets field's value.
func (s *ListIPSetsOutput) SetIPSets(v []IPSetSummary) *ListIPSetsOutput {
	s.IPSets = v
	return s
}

// SetNextMarker sets the NextMarker field's value.
func (s *ListIPSetsOutput) SetNextMarker(v string) *ListIPSetsOutput {
	s.NextMarker = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListRateBasedRulesRequest
type ListRateBasedRulesInput struct {
	_ struct{} `type:"structure"`

	// Specifies the number of Rules that you want AWS WAF to return for this request.
	// If you have more Rules than the number that you specify for Limit, the response
	// includes a NextMarker value that you can use to get another batch of Rules.
	Limit *int64 `type:"integer"`

	// If you specify a value for Limit and you have more Rules than the value of
	// Limit, AWS WAF returns a NextMarker value in the response that allows you
	// to list another group of Rules. For the second and subsequent ListRateBasedRules
	// requests, specify the value of NextMarker from the previous response to get
	// information about another batch of Rules.
	NextMarker *string `min:"1" type:"string"`
}

// String returns the string representation
func (s ListRateBasedRulesInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListRateBasedRulesInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListRateBasedRulesInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ListRateBasedRulesInput"}
	if s.NextMarker != nil && len(*s.NextMarker) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("NextMarker", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetLimit sets the Limit field's value.
func (s *ListRateBasedRulesInput) SetLimit(v int64) *ListRateBasedRulesInput {
	s.Limit = &v
	return s
}

// SetNextMarker sets the NextMarker field's value.
func (s *ListRateBasedRulesInput) SetNextMarker(v string) *ListRateBasedRulesInput {
	s.NextMarker = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListRateBasedRulesResponse
type ListRateBasedRulesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// If you have more Rules than the number that you specified for Limit in the
	// request, the response includes a NextMarker value. To list more Rules, submit
	// another ListRateBasedRules request, and specify the NextMarker value from
	// the response in the NextMarker value in the next request.
	NextMarker *string `min:"1" type:"string"`

	// An array of RuleSummary objects.
	Rules []RuleSummary `type:"list"`
}

// String returns the string representation
func (s ListRateBasedRulesOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListRateBasedRulesOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s ListRateBasedRulesOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetNextMarker sets the NextMarker field's value.
func (s *ListRateBasedRulesOutput) SetNextMarker(v string) *ListRateBasedRulesOutput {
	s.NextMarker = &v
	return s
}

// SetRules sets the Rules field's value.
func (s *ListRateBasedRulesOutput) SetRules(v []RuleSummary) *ListRateBasedRulesOutput {
	s.Rules = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListRulesRequest
type ListRulesInput struct {
	_ struct{} `type:"structure"`

	// Specifies the number of Rules that you want AWS WAF to return for this request.
	// If you have more Rules than the number that you specify for Limit, the response
	// includes a NextMarker value that you can use to get another batch of Rules.
	Limit *int64 `type:"integer"`

	// If you specify a value for Limit and you have more Rules than the value of
	// Limit, AWS WAF returns a NextMarker value in the response that allows you
	// to list another group of Rules. For the second and subsequent ListRules requests,
	// specify the value of NextMarker from the previous response to get information
	// about another batch of Rules.
	NextMarker *string `min:"1" type:"string"`
}

// String returns the string representation
func (s ListRulesInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListRulesInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListRulesInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ListRulesInput"}
	if s.NextMarker != nil && len(*s.NextMarker) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("NextMarker", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetLimit sets the Limit field's value.
func (s *ListRulesInput) SetLimit(v int64) *ListRulesInput {
	s.Limit = &v
	return s
}

// SetNextMarker sets the NextMarker field's value.
func (s *ListRulesInput) SetNextMarker(v string) *ListRulesInput {
	s.NextMarker = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListRulesResponse
type ListRulesOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// If you have more Rules than the number that you specified for Limit in the
	// request, the response includes a NextMarker value. To list more Rules, submit
	// another ListRules request, and specify the NextMarker value from the response
	// in the NextMarker value in the next request.
	NextMarker *string `min:"1" type:"string"`

	// An array of RuleSummary objects.
	Rules []RuleSummary `type:"list"`
}

// String returns the string representation
func (s ListRulesOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListRulesOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s ListRulesOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetNextMarker sets the NextMarker field's value.
func (s *ListRulesOutput) SetNextMarker(v string) *ListRulesOutput {
	s.NextMarker = &v
	return s
}

// SetRules sets the Rules field's value.
func (s *ListRulesOutput) SetRules(v []RuleSummary) *ListRulesOutput {
	s.Rules = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListSizeConstraintSetsRequest
type ListSizeConstraintSetsInput struct {
	_ struct{} `type:"structure"`

	// Specifies the number of SizeConstraintSet objects that you want AWS WAF to
	// return for this request. If you have more SizeConstraintSets objects than
	// the number you specify for Limit, the response includes a NextMarker value
	// that you can use to get another batch of SizeConstraintSet objects.
	Limit *int64 `type:"integer"`

	// If you specify a value for Limit and you have more SizeConstraintSets than
	// the value of Limit, AWS WAF returns a NextMarker value in the response that
	// allows you to list another group of SizeConstraintSets. For the second and
	// subsequent ListSizeConstraintSets requests, specify the value of NextMarker
	// from the previous response to get information about another batch of SizeConstraintSets.
	NextMarker *string `min:"1" type:"string"`
}

// String returns the string representation
func (s ListSizeConstraintSetsInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListSizeConstraintSetsInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListSizeConstraintSetsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ListSizeConstraintSetsInput"}
	if s.NextMarker != nil && len(*s.NextMarker) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("NextMarker", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetLimit sets the Limit field's value.
func (s *ListSizeConstraintSetsInput) SetLimit(v int64) *ListSizeConstraintSetsInput {
	s.Limit = &v
	return s
}

// SetNextMarker sets the NextMarker field's value.
func (s *ListSizeConstraintSetsInput) SetNextMarker(v string) *ListSizeConstraintSetsInput {
	s.NextMarker = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListSizeConstraintSetsResponse
type ListSizeConstraintSetsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// If you have more SizeConstraintSet objects than the number that you specified
	// for Limit in the request, the response includes a NextMarker value. To list
	// more SizeConstraintSet objects, submit another ListSizeConstraintSets request,
	// and specify the NextMarker value from the response in the NextMarker value
	// in the next request.
	NextMarker *string `min:"1" type:"string"`

	// An array of SizeConstraintSetSummary objects.
	SizeConstraintSets []SizeConstraintSetSummary `type:"list"`
}

// String returns the string representation
func (s ListSizeConstraintSetsOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListSizeConstraintSetsOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s ListSizeConstraintSetsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetNextMarker sets the NextMarker field's value.
func (s *ListSizeConstraintSetsOutput) SetNextMarker(v string) *ListSizeConstraintSetsOutput {
	s.NextMarker = &v
	return s
}

// SetSizeConstraintSets sets the SizeConstraintSets field's value.
func (s *ListSizeConstraintSetsOutput) SetSizeConstraintSets(v []SizeConstraintSetSummary) *ListSizeConstraintSetsOutput {
	s.SizeConstraintSets = v
	return s
}

// A request to list the SqlInjectionMatchSet objects created by the current
// AWS account.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListSqlInjectionMatchSetsRequest
type ListSqlInjectionMatchSetsInput struct {
	_ struct{} `type:"structure"`

	// Specifies the number of SqlInjectionMatchSet objects that you want AWS WAF
	// to return for this request. If you have more SqlInjectionMatchSet objects
	// than the number you specify for Limit, the response includes a NextMarker
	// value that you can use to get another batch of Rules.
	Limit *int64 `type:"integer"`

	// If you specify a value for Limit and you have more SqlInjectionMatchSet objects
	// than the value of Limit, AWS WAF returns a NextMarker value in the response
	// that allows you to list another group of SqlInjectionMatchSets. For the second
	// and subsequent ListSqlInjectionMatchSets requests, specify the value of NextMarker
	// from the previous response to get information about another batch of SqlInjectionMatchSets.
	NextMarker *string `min:"1" type:"string"`
}

// String returns the string representation
func (s ListSqlInjectionMatchSetsInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListSqlInjectionMatchSetsInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListSqlInjectionMatchSetsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ListSqlInjectionMatchSetsInput"}
	if s.NextMarker != nil && len(*s.NextMarker) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("NextMarker", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetLimit sets the Limit field's value.
func (s *ListSqlInjectionMatchSetsInput) SetLimit(v int64) *ListSqlInjectionMatchSetsInput {
	s.Limit = &v
	return s
}

// SetNextMarker sets the NextMarker field's value.
func (s *ListSqlInjectionMatchSetsInput) SetNextMarker(v string) *ListSqlInjectionMatchSetsInput {
	s.NextMarker = &v
	return s
}

// The response to a ListSqlInjectionMatchSets request.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListSqlInjectionMatchSetsResponse
type ListSqlInjectionMatchSetsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// If you have more SqlInjectionMatchSet objects than the number that you specified
	// for Limit in the request, the response includes a NextMarker value. To list
	// more SqlInjectionMatchSet objects, submit another ListSqlInjectionMatchSets
	// request, and specify the NextMarker value from the response in the NextMarker
	// value in the next request.
	NextMarker *string `min:"1" type:"string"`

	// An array of SqlInjectionMatchSetSummary objects.
	SqlInjectionMatchSets []SqlInjectionMatchSetSummary `type:"list"`
}

// String returns the string representation
func (s ListSqlInjectionMatchSetsOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListSqlInjectionMatchSetsOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s ListSqlInjectionMatchSetsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetNextMarker sets the NextMarker field's value.
func (s *ListSqlInjectionMatchSetsOutput) SetNextMarker(v string) *ListSqlInjectionMatchSetsOutput {
	s.NextMarker = &v
	return s
}

// SetSqlInjectionMatchSets sets the SqlInjectionMatchSets field's value.
func (s *ListSqlInjectionMatchSetsOutput) SetSqlInjectionMatchSets(v []SqlInjectionMatchSetSummary) *ListSqlInjectionMatchSetsOutput {
	s.SqlInjectionMatchSets = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListWebACLsRequest
type ListWebACLsInput struct {
	_ struct{} `type:"structure"`

	// Specifies the number of WebACL objects that you want AWS WAF to return for
	// this request. If you have more WebACL objects than the number that you specify
	// for Limit, the response includes a NextMarker value that you can use to get
	// another batch of WebACL objects.
	Limit *int64 `type:"integer"`

	// If you specify a value for Limit and you have more WebACL objects than the
	// number that you specify for Limit, AWS WAF returns a NextMarker value in
	// the response that allows you to list another group of WebACL objects. For
	// the second and subsequent ListWebACLs requests, specify the value of NextMarker
	// from the previous response to get information about another batch of WebACL
	// objects.
	NextMarker *string `min:"1" type:"string"`
}

// String returns the string representation
func (s ListWebACLsInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListWebACLsInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListWebACLsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ListWebACLsInput"}
	if s.NextMarker != nil && len(*s.NextMarker) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("NextMarker", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetLimit sets the Limit field's value.
func (s *ListWebACLsInput) SetLimit(v int64) *ListWebACLsInput {
	s.Limit = &v
	return s
}

// SetNextMarker sets the NextMarker field's value.
func (s *ListWebACLsInput) SetNextMarker(v string) *ListWebACLsInput {
	s.NextMarker = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListWebACLsResponse
type ListWebACLsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// If you have more WebACL objects than the number that you specified for Limit
	// in the request, the response includes a NextMarker value. To list more WebACL
	// objects, submit another ListWebACLs request, and specify the NextMarker value
	// from the response in the NextMarker value in the next request.
	NextMarker *string `min:"1" type:"string"`

	// An array of WebACLSummary objects.
	WebACLs []WebACLSummary `type:"list"`
}

// String returns the string representation
func (s ListWebACLsOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListWebACLsOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s ListWebACLsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetNextMarker sets the NextMarker field's value.
func (s *ListWebACLsOutput) SetNextMarker(v string) *ListWebACLsOutput {
	s.NextMarker = &v
	return s
}

// SetWebACLs sets the WebACLs field's value.
func (s *ListWebACLsOutput) SetWebACLs(v []WebACLSummary) *ListWebACLsOutput {
	s.WebACLs = v
	return s
}

// A request to list the XssMatchSet objects created by the current AWS account.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListXssMatchSetsRequest
type ListXssMatchSetsInput struct {
	_ struct{} `type:"structure"`

	// Specifies the number of XssMatchSet objects that you want AWS WAF to return
	// for this request. If you have more XssMatchSet objects than the number you
	// specify for Limit, the response includes a NextMarker value that you can
	// use to get another batch of Rules.
	Limit *int64 `type:"integer"`

	// If you specify a value for Limit and you have more XssMatchSet objects than
	// the value of Limit, AWS WAF returns a NextMarker value in the response that
	// allows you to list another group of XssMatchSets. For the second and subsequent
	// ListXssMatchSets requests, specify the value of NextMarker from the previous
	// response to get information about another batch of XssMatchSets.
	NextMarker *string `min:"1" type:"string"`
}

// String returns the string representation
func (s ListXssMatchSetsInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListXssMatchSetsInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *ListXssMatchSetsInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "ListXssMatchSetsInput"}
	if s.NextMarker != nil && len(*s.NextMarker) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("NextMarker", 1))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetLimit sets the Limit field's value.
func (s *ListXssMatchSetsInput) SetLimit(v int64) *ListXssMatchSetsInput {
	s.Limit = &v
	return s
}

// SetNextMarker sets the NextMarker field's value.
func (s *ListXssMatchSetsInput) SetNextMarker(v string) *ListXssMatchSetsInput {
	s.NextMarker = &v
	return s
}

// The response to a ListXssMatchSets request.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/ListXssMatchSetsResponse
type ListXssMatchSetsOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// If you have more XssMatchSet objects than the number that you specified for
	// Limit in the request, the response includes a NextMarker value. To list more
	// XssMatchSet objects, submit another ListXssMatchSets request, and specify
	// the NextMarker value from the response in the NextMarker value in the next
	// request.
	NextMarker *string `min:"1" type:"string"`

	// An array of XssMatchSetSummary objects.
	XssMatchSets []XssMatchSetSummary `type:"list"`
}

// String returns the string representation
func (s ListXssMatchSetsOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s ListXssMatchSetsOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s ListXssMatchSetsOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetNextMarker sets the NextMarker field's value.
func (s *ListXssMatchSetsOutput) SetNextMarker(v string) *ListXssMatchSetsOutput {
	s.NextMarker = &v
	return s
}

// SetXssMatchSets sets the XssMatchSets field's value.
func (s *ListXssMatchSetsOutput) SetXssMatchSets(v []XssMatchSetSummary) *ListXssMatchSetsOutput {
	s.XssMatchSets = v
	return s
}

// Specifies the ByteMatchSet, IPSet, SqlInjectionMatchSet, XssMatchSet, and
// SizeConstraintSet objects that you want to add to a Rule and, for each object,
// indicates whether you want to negate the settings, for example, requests
// that do NOT originate from the IP address 192.0.2.44.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/Predicate
type Predicate struct {
	_ struct{} `type:"structure"`

	// A unique identifier for a predicate in a Rule, such as ByteMatchSetId or
	// IPSetId. The ID is returned by the corresponding Create or List command.
	//
	// DataId is a required field
	DataId *string `min:"1" type:"string" required:"true"`

	// Set Negated to False if you want AWS WAF to allow, block, or count requests
	// based on the settings in the specified ByteMatchSet, IPSet, SqlInjectionMatchSet,
	// XssMatchSet, or SizeConstraintSet. For example, if an IPSet includes the
	// IP address 192.0.2.44, AWS WAF will allow or block requests based on that
	// IP address.
	//
	// Set Negated to True if you want AWS WAF to allow or block a request based
	// on the negation of the settings in the ByteMatchSet, IPSet, SqlInjectionMatchSet,
	// XssMatchSet, or SizeConstraintSet. For example, if an IPSet includes the
	// IP address 192.0.2.44, AWS WAF will allow, block, or count requests based
	// on all IP addresses except192.0.2.44.
	//
	// Negated is a required field
	Negated *bool `type:"boolean" required:"true"`

	// The type of predicate in a Rule, such as ByteMatchSet or IPSet.
	//
	// Type is a required field
	Type PredicateType `type:"string" required:"true" enum:"true"`
}

// String returns the string representation
func (s Predicate) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s Predicate) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *Predicate) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "Predicate"}

	if s.DataId == nil {
		invalidParams.Add(aws.NewErrParamRequired("DataId"))
	}
	if s.DataId != nil && len(*s.DataId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("DataId", 1))
	}

	if s.Negated == nil {
		invalidParams.Add(aws.NewErrParamRequired("Negated"))
	}
	if len(s.Type) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("Type"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetDataId sets the DataId field's value.
func (s *Predicate) SetDataId(v string) *Predicate {
	s.DataId = &v
	return s
}

// SetNegated sets the Negated field's value.
func (s *Predicate) SetNegated(v bool) *Predicate {
	s.Negated = &v
	return s
}

// SetType sets the Type field's value.
func (s *Predicate) SetType(v PredicateType) *Predicate {
	s.Type = v
	return s
}

// A RateBasedRule is identical to a regular Rule, with one addition: a RateBasedRule
// counts the number of requests that arrive from a specified IP address every
// five minutes. For example, based on recent requests that you've seen from
// an attacker, you might create a RateBasedRule that includes the following
// conditions:
//
//    * The requests come from 192.0.2.44.
//
//    * They contain the value BadBot in the User-Agent header.
//
// In the rule, you also define the rate limit as 15,000.
//
// Requests that meet both of these conditions and exceed 15,000 requests every
// five minutes trigger the rule's action (block or count), which is defined
// in the web ACL.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/RateBasedRule
type RateBasedRule struct {
	_ struct{} `type:"structure"`

	// The Predicates object contains one Predicate element for each ByteMatchSet,
	// IPSet, or SqlInjectionMatchSet object that you want to include in a RateBasedRule.
	//
	// MatchPredicates is a required field
	MatchPredicates []Predicate `type:"list" required:"true"`

	// A friendly name or description for the metrics for a RateBasedRule. The name
	// can contain only alphanumeric characters (A-Z, a-z, 0-9); the name can't
	// contain whitespace. You can't change the name of the metric after you create
	// the RateBasedRule.
	MetricName *string `type:"string"`

	// A friendly name or description for a RateBasedRule. You can't change the
	// name of a RateBasedRule after you create it.
	Name *string `min:"1" type:"string"`

	// The field that AWS WAF uses to determine if requests are likely arriving
	// from single source and thus subject to rate monitoring. The only valid value
	// for RateKey is IP. IP indicates that requests arriving from the same IP address
	// are subject to the RateLimit that is specified in the RateBasedRule.
	//
	// RateKey is a required field
	RateKey RateKey `type:"string" required:"true" enum:"true"`

	// The maximum number of requests, which have an identical value in the field
	// specified by the RateKey, allowed in a five-minute period. If the number
	// of requests exceeds the RateLimit and the other predicates specified in the
	// rule are also met, AWS WAF triggers the action that is specified for this
	// rule.
	//
	// RateLimit is a required field
	RateLimit *int64 `min:"2000" type:"long" required:"true"`

	// A unique identifier for a RateBasedRule. You use RuleId to get more information
	// about a RateBasedRule (see GetRateBasedRule), update a RateBasedRule (see
	// UpdateRateBasedRule), insert a RateBasedRule into a WebACL or delete one
	// from a WebACL (see UpdateWebACL), or delete a RateBasedRule from AWS WAF
	// (see DeleteRateBasedRule).
	//
	// RuleId is a required field
	RuleId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s RateBasedRule) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s RateBasedRule) GoString() string {
	return s.String()
}

// SetMatchPredicates sets the MatchPredicates field's value.
func (s *RateBasedRule) SetMatchPredicates(v []Predicate) *RateBasedRule {
	s.MatchPredicates = v
	return s
}

// SetMetricName sets the MetricName field's value.
func (s *RateBasedRule) SetMetricName(v string) *RateBasedRule {
	s.MetricName = &v
	return s
}

// SetName sets the Name field's value.
func (s *RateBasedRule) SetName(v string) *RateBasedRule {
	s.Name = &v
	return s
}

// SetRateKey sets the RateKey field's value.
func (s *RateBasedRule) SetRateKey(v RateKey) *RateBasedRule {
	s.RateKey = v
	return s
}

// SetRateLimit sets the RateLimit field's value.
func (s *RateBasedRule) SetRateLimit(v int64) *RateBasedRule {
	s.RateLimit = &v
	return s
}

// SetRuleId sets the RuleId field's value.
func (s *RateBasedRule) SetRuleId(v string) *RateBasedRule {
	s.RuleId = &v
	return s
}

// A combination of ByteMatchSet, IPSet, and/or SqlInjectionMatchSet objects
// that identify the web requests that you want to allow, block, or count. For
// example, you might create a Rule that includes the following predicates:
//
//    * An IPSet that causes AWS WAF to search for web requests that originate
//    from the IP address 192.0.2.44
//
//    * A ByteMatchSet that causes AWS WAF to search for web requests for which
//    the value of the User-Agent header is BadBot.
//
// To match the settings in this Rule, a request must originate from 192.0.2.44
// AND include a User-Agent header for which the value is BadBot.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/Rule
type Rule struct {
	_ struct{} `type:"structure"`

	// A friendly name or description for the metrics for this Rule. The name can
	// contain only alphanumeric characters (A-Z, a-z, 0-9); the name can't contain
	// whitespace. You can't change MetricName after you create the Rule.
	MetricName *string `type:"string"`

	// The friendly name or description for the Rule. You can't change the name
	// of a Rule after you create it.
	Name *string `min:"1" type:"string"`

	// The Predicates object contains one Predicate element for each ByteMatchSet,
	// IPSet, or SqlInjectionMatchSet object that you want to include in a Rule.
	//
	// Predicates is a required field
	Predicates []Predicate `type:"list" required:"true"`

	// A unique identifier for a Rule. You use RuleId to get more information about
	// a Rule (see GetRule), update a Rule (see UpdateRule), insert a Rule into
	// a WebACL or delete a one from a WebACL (see UpdateWebACL), or delete a Rule
	// from AWS WAF (see DeleteRule).
	//
	// RuleId is returned by CreateRule and by ListRules.
	//
	// RuleId is a required field
	RuleId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s Rule) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s Rule) GoString() string {
	return s.String()
}

// SetMetricName sets the MetricName field's value.
func (s *Rule) SetMetricName(v string) *Rule {
	s.MetricName = &v
	return s
}

// SetName sets the Name field's value.
func (s *Rule) SetName(v string) *Rule {
	s.Name = &v
	return s
}

// SetPredicates sets the Predicates field's value.
func (s *Rule) SetPredicates(v []Predicate) *Rule {
	s.Predicates = v
	return s
}

// SetRuleId sets the RuleId field's value.
func (s *Rule) SetRuleId(v string) *Rule {
	s.RuleId = &v
	return s
}

// Contains the identifier and the friendly name or description of the Rule.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/RuleSummary
type RuleSummary struct {
	_ struct{} `type:"structure"`

	// A friendly name or description of the Rule. You can't change the name of
	// a Rule after you create it.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// A unique identifier for a Rule. You use RuleId to get more information about
	// a Rule (see GetRule), update a Rule (see UpdateRule), insert a Rule into
	// a WebACL or delete one from a WebACL (see UpdateWebACL), or delete a Rule
	// from AWS WAF (see DeleteRule).
	//
	// RuleId is returned by CreateRule and by ListRules.
	//
	// RuleId is a required field
	RuleId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s RuleSummary) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s RuleSummary) GoString() string {
	return s.String()
}

// SetName sets the Name field's value.
func (s *RuleSummary) SetName(v string) *RuleSummary {
	s.Name = &v
	return s
}

// SetRuleId sets the RuleId field's value.
func (s *RuleSummary) SetRuleId(v string) *RuleSummary {
	s.RuleId = &v
	return s
}

// Specifies a Predicate (such as an IPSet) and indicates whether you want to
// add it to a Rule or delete it from a Rule.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/RuleUpdate
type RuleUpdate struct {
	_ struct{} `type:"structure"`

	// Specify INSERT to add a Predicate to a Rule. Use DELETE to remove a Predicate
	// from a Rule.
	//
	// Action is a required field
	Action ChangeAction `type:"string" required:"true" enum:"true"`

	// The ID of the Predicate (such as an IPSet) that you want to add to a Rule.
	//
	// Predicate is a required field
	Predicate *Predicate `type:"structure" required:"true"`
}

// String returns the string representation
func (s RuleUpdate) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s RuleUpdate) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *RuleUpdate) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "RuleUpdate"}
	if len(s.Action) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("Action"))
	}

	if s.Predicate == nil {
		invalidParams.Add(aws.NewErrParamRequired("Predicate"))
	}
	if s.Predicate != nil {
		if err := s.Predicate.Validate(); err != nil {
			invalidParams.AddNested("Predicate", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetAction sets the Action field's value.
func (s *RuleUpdate) SetAction(v ChangeAction) *RuleUpdate {
	s.Action = v
	return s
}

// SetPredicate sets the Predicate field's value.
func (s *RuleUpdate) SetPredicate(v *Predicate) *RuleUpdate {
	s.Predicate = v
	return s
}

// The response from a GetSampledRequests request includes a SampledHTTPRequests
// complex type that appears as SampledRequests in the response syntax. SampledHTTPRequests
// contains one SampledHTTPRequest object for each web request that is returned
// by GetSampledRequests.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/SampledHTTPRequest
type SampledHTTPRequest struct {
	_ struct{} `type:"structure"`

	// The action for the Rule that the request matched: ALLOW, BLOCK, or COUNT.
	Action *string `type:"string"`

	// A complex type that contains detailed information about the request.
	//
	// Request is a required field
	Request *HTTPRequest `type:"structure" required:"true"`

	// The time at which AWS WAF received the request from your AWS resource, in
	// Unix time format (in seconds).
	Timestamp *time.Time `type:"timestamp" timestampFormat:"unix"`

	// A value that indicates how one result in the response relates proportionally
	// to other results in the response. A result that has a weight of 2 represents
	// roughly twice as many CloudFront web requests as a result that has a weight
	// of 1.
	//
	// Weight is a required field
	Weight *int64 `type:"long" required:"true"`
}

// String returns the string representation
func (s SampledHTTPRequest) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s SampledHTTPRequest) GoString() string {
	return s.String()
}

// SetAction sets the Action field's value.
func (s *SampledHTTPRequest) SetAction(v string) *SampledHTTPRequest {
	s.Action = &v
	return s
}

// SetRequest sets the Request field's value.
func (s *SampledHTTPRequest) SetRequest(v *HTTPRequest) *SampledHTTPRequest {
	s.Request = v
	return s
}

// SetTimestamp sets the Timestamp field's value.
func (s *SampledHTTPRequest) SetTimestamp(v time.Time) *SampledHTTPRequest {
	s.Timestamp = &v
	return s
}

// SetWeight sets the Weight field's value.
func (s *SampledHTTPRequest) SetWeight(v int64) *SampledHTTPRequest {
	s.Weight = &v
	return s
}

// Specifies a constraint on the size of a part of the web request. AWS WAF
// uses the Size, ComparisonOperator, and FieldToMatch to build an expression
// in the form of "SizeComparisonOperator size in bytes of FieldToMatch". If
// that expression is true, the SizeConstraint is considered to match.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/SizeConstraint
type SizeConstraint struct {
	_ struct{} `type:"structure"`

	// The type of comparison you want AWS WAF to perform. AWS WAF uses this in
	// combination with the provided Size and FieldToMatch to build an expression
	// in the form of "SizeComparisonOperator size in bytes of FieldToMatch". If
	// that expression is true, the SizeConstraint is considered to match.
	//
	// EQ: Used to test if the Size is equal to the size of the FieldToMatch
	//
	// NE: Used to test if the Size is not equal to the size of the FieldToMatch
	//
	// LE: Used to test if the Size is less than or equal to the size of the FieldToMatch
	//
	// LT: Used to test if the Size is strictly less than the size of the FieldToMatch
	//
	// GE: Used to test if the Size is greater than or equal to the size of the
	// FieldToMatch
	//
	// GT: Used to test if the Size is strictly greater than the size of the FieldToMatch
	//
	// ComparisonOperator is a required field
	ComparisonOperator ComparisonOperator `type:"string" required:"true" enum:"true"`

	// Specifies where in a web request to look for the size constraint.
	//
	// FieldToMatch is a required field
	FieldToMatch *FieldToMatch `type:"structure" required:"true"`

	// The size in bytes that you want AWS WAF to compare against the size of the
	// specified FieldToMatch. AWS WAF uses this in combination with ComparisonOperator
	// and FieldToMatch to build an expression in the form of "SizeComparisonOperator
	// size in bytes of FieldToMatch". If that expression is true, the SizeConstraint
	// is considered to match.
	//
	// Valid values for size are 0 - 21474836480 bytes (0 - 20 GB).
	//
	// If you specify URI for the value of Type, the / in the URI counts as one
	// character. For example, the URI /logo.jpg is nine characters long.
	//
	// Size is a required field
	Size *int64 `type:"long" required:"true"`

	// Text transformations eliminate some of the unusual formatting that attackers
	// use in web requests in an effort to bypass AWS WAF. If you specify a transformation,
	// AWS WAF performs the transformation on FieldToMatch before inspecting a request
	// for a match.
	//
	// Note that if you choose BODY for the value of Type, you must choose NONE
	// for TextTransformation because CloudFront forwards only the first 8192 bytes
	// for inspection.
	//
	// NONE
	//
	// Specify NONE if you don't want to perform any text transformations.
	//
	// CMD_LINE
	//
	// When you're concerned that attackers are injecting an operating system command
	// line command and using unusual formatting to disguise some or all of the
	// command, use this option to perform the following transformations:
	//
	//    * Delete the following characters: \ " ' ^
	//
	//    * Delete spaces before the following characters: / (
	//
	//    * Replace the following characters with a space: , ;
	//
	//    * Replace multiple spaces with one space
	//
	//    * Convert uppercase letters (A-Z) to lowercase (a-z)
	//
	// COMPRESS_WHITE_SPACE
	//
	// Use this option to replace the following characters with a space character
	// (decimal 32):
	//
	//    * \f, formfeed, decimal 12
	//
	//    * \t, tab, decimal 9
	//
	//    * \n, newline, decimal 10
	//
	//    * \r, carriage return, decimal 13
	//
	//    * \v, vertical tab, decimal 11
	//
	//    * non-breaking space, decimal 160
	//
	// COMPRESS_WHITE_SPACE also replaces multiple spaces with one space.
	//
	// HTML_ENTITY_DECODE
	//
	// Use this option to replace HTML-encoded characters with unencoded characters.
	// HTML_ENTITY_DECODE performs the following operations:
	//
	//    * Replaces (ampersand)quot; with "
	//
	//    * Replaces (ampersand)nbsp; with a non-breaking space, decimal 160
	//
	//    * Replaces (ampersand)lt; with a "less than" symbol
	//
	//    * Replaces (ampersand)gt; with >
	//
	//    * Replaces characters that are represented in hexadecimal format, (ampersand)#xhhhh;,
	//    with the corresponding characters
	//
	//    * Replaces characters that are represented in decimal format, (ampersand)#nnnn;,
	//    with the corresponding characters
	//
	// LOWERCASE
	//
	// Use this option to convert uppercase letters (A-Z) to lowercase (a-z).
	//
	// URL_DECODE
	//
	// Use this option to decode a URL-encoded value.
	//
	// TextTransformation is a required field
	TextTransformation TextTransformation `type:"string" required:"true" enum:"true"`
}

// String returns the string representation
func (s SizeConstraint) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s SizeConstraint) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *SizeConstraint) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "SizeConstraint"}
	if len(s.ComparisonOperator) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("ComparisonOperator"))
	}

	if s.FieldToMatch == nil {
		invalidParams.Add(aws.NewErrParamRequired("FieldToMatch"))
	}

	if s.Size == nil {
		invalidParams.Add(aws.NewErrParamRequired("Size"))
	}
	if len(s.TextTransformation) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("TextTransformation"))
	}
	if s.FieldToMatch != nil {
		if err := s.FieldToMatch.Validate(); err != nil {
			invalidParams.AddNested("FieldToMatch", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetComparisonOperator sets the ComparisonOperator field's value.
func (s *SizeConstraint) SetComparisonOperator(v ComparisonOperator) *SizeConstraint {
	s.ComparisonOperator = v
	return s
}

// SetFieldToMatch sets the FieldToMatch field's value.
func (s *SizeConstraint) SetFieldToMatch(v *FieldToMatch) *SizeConstraint {
	s.FieldToMatch = v
	return s
}

// SetSize sets the Size field's value.
func (s *SizeConstraint) SetSize(v int64) *SizeConstraint {
	s.Size = &v
	return s
}

// SetTextTransformation sets the TextTransformation field's value.
func (s *SizeConstraint) SetTextTransformation(v TextTransformation) *SizeConstraint {
	s.TextTransformation = v
	return s
}

// A complex type that contains SizeConstraint objects, which specify the parts
// of web requests that you want AWS WAF to inspect the size of. If a SizeConstraintSet
// contains more than one SizeConstraint object, a request only needs to match
// one constraint to be considered a match.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/SizeConstraintSet
type SizeConstraintSet struct {
	_ struct{} `type:"structure"`

	// The name, if any, of the SizeConstraintSet.
	Name *string `min:"1" type:"string"`

	// A unique identifier for a SizeConstraintSet. You use SizeConstraintSetId
	// to get information about a SizeConstraintSet (see GetSizeConstraintSet),
	// update a SizeConstraintSet (see UpdateSizeConstraintSet), insert a SizeConstraintSet
	// into a Rule or delete one from a Rule (see UpdateRule), and delete a SizeConstraintSet
	// from AWS WAF (see DeleteSizeConstraintSet).
	//
	// SizeConstraintSetId is returned by CreateSizeConstraintSet and by ListSizeConstraintSets.
	//
	// SizeConstraintSetId is a required field
	SizeConstraintSetId *string `min:"1" type:"string" required:"true"`

	// Specifies the parts of web requests that you want to inspect the size of.
	//
	// SizeConstraints is a required field
	SizeConstraints []SizeConstraint `type:"list" required:"true"`
}

// String returns the string representation
func (s SizeConstraintSet) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s SizeConstraintSet) GoString() string {
	return s.String()
}

// SetName sets the Name field's value.
func (s *SizeConstraintSet) SetName(v string) *SizeConstraintSet {
	s.Name = &v
	return s
}

// SetSizeConstraintSetId sets the SizeConstraintSetId field's value.
func (s *SizeConstraintSet) SetSizeConstraintSetId(v string) *SizeConstraintSet {
	s.SizeConstraintSetId = &v
	return s
}

// SetSizeConstraints sets the SizeConstraints field's value.
func (s *SizeConstraintSet) SetSizeConstraints(v []SizeConstraint) *SizeConstraintSet {
	s.SizeConstraints = v
	return s
}

// The Id and Name of a SizeConstraintSet.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/SizeConstraintSetSummary
type SizeConstraintSetSummary struct {
	_ struct{} `type:"structure"`

	// The name of the SizeConstraintSet, if any.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// A unique identifier for a SizeConstraintSet. You use SizeConstraintSetId
	// to get information about a SizeConstraintSet (see GetSizeConstraintSet),
	// update a SizeConstraintSet (see UpdateSizeConstraintSet), insert a SizeConstraintSet
	// into a Rule or delete one from a Rule (see UpdateRule), and delete a SizeConstraintSet
	// from AWS WAF (see DeleteSizeConstraintSet).
	//
	// SizeConstraintSetId is returned by CreateSizeConstraintSet and by ListSizeConstraintSets.
	//
	// SizeConstraintSetId is a required field
	SizeConstraintSetId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s SizeConstraintSetSummary) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s SizeConstraintSetSummary) GoString() string {
	return s.String()
}

// SetName sets the Name field's value.
func (s *SizeConstraintSetSummary) SetName(v string) *SizeConstraintSetSummary {
	s.Name = &v
	return s
}

// SetSizeConstraintSetId sets the SizeConstraintSetId field's value.
func (s *SizeConstraintSetSummary) SetSizeConstraintSetId(v string) *SizeConstraintSetSummary {
	s.SizeConstraintSetId = &v
	return s
}

// Specifies the part of a web request that you want to inspect the size of
// and indicates whether you want to add the specification to a SizeConstraintSet
// or delete it from a SizeConstraintSet.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/SizeConstraintSetUpdate
type SizeConstraintSetUpdate struct {
	_ struct{} `type:"structure"`

	// Specify INSERT to add a SizeConstraintSetUpdate to a SizeConstraintSet. Use
	// DELETE to remove a SizeConstraintSetUpdate from a SizeConstraintSet.
	//
	// Action is a required field
	Action ChangeAction `type:"string" required:"true" enum:"true"`

	// Specifies a constraint on the size of a part of the web request. AWS WAF
	// uses the Size, ComparisonOperator, and FieldToMatch to build an expression
	// in the form of "SizeComparisonOperator size in bytes of FieldToMatch". If
	// that expression is true, the SizeConstraint is considered to match.
	//
	// SizeConstraint is a required field
	SizeConstraint *SizeConstraint `type:"structure" required:"true"`
}

// String returns the string representation
func (s SizeConstraintSetUpdate) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s SizeConstraintSetUpdate) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *SizeConstraintSetUpdate) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "SizeConstraintSetUpdate"}
	if len(s.Action) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("Action"))
	}

	if s.SizeConstraint == nil {
		invalidParams.Add(aws.NewErrParamRequired("SizeConstraint"))
	}
	if s.SizeConstraint != nil {
		if err := s.SizeConstraint.Validate(); err != nil {
			invalidParams.AddNested("SizeConstraint", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetAction sets the Action field's value.
func (s *SizeConstraintSetUpdate) SetAction(v ChangeAction) *SizeConstraintSetUpdate {
	s.Action = v
	return s
}

// SetSizeConstraint sets the SizeConstraint field's value.
func (s *SizeConstraintSetUpdate) SetSizeConstraint(v *SizeConstraint) *SizeConstraintSetUpdate {
	s.SizeConstraint = v
	return s
}

// A complex type that contains SqlInjectionMatchTuple objects, which specify
// the parts of web requests that you want AWS WAF to inspect for snippets of
// malicious SQL code and, if you want AWS WAF to inspect a header, the name
// of the header. If a SqlInjectionMatchSet contains more than one SqlInjectionMatchTuple
// object, a request needs to include snippets of SQL code in only one of the
// specified parts of the request to be considered a match.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/SqlInjectionMatchSet
type SqlInjectionMatchSet struct {
	_ struct{} `type:"structure"`

	// The name, if any, of the SqlInjectionMatchSet.
	Name *string `min:"1" type:"string"`

	// A unique identifier for a SqlInjectionMatchSet. You use SqlInjectionMatchSetId
	// to get information about a SqlInjectionMatchSet (see GetSqlInjectionMatchSet),
	// update a SqlInjectionMatchSet (see UpdateSqlInjectionMatchSet), insert a
	// SqlInjectionMatchSet into a Rule or delete one from a Rule (see UpdateRule),
	// and delete a SqlInjectionMatchSet from AWS WAF (see DeleteSqlInjectionMatchSet).
	//
	// SqlInjectionMatchSetId is returned by CreateSqlInjectionMatchSet and by ListSqlInjectionMatchSets.
	//
	// SqlInjectionMatchSetId is a required field
	SqlInjectionMatchSetId *string `min:"1" type:"string" required:"true"`

	// Specifies the parts of web requests that you want to inspect for snippets
	// of malicious SQL code.
	//
	// SqlInjectionMatchTuples is a required field
	SqlInjectionMatchTuples []SqlInjectionMatchTuple `type:"list" required:"true"`
}

// String returns the string representation
func (s SqlInjectionMatchSet) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s SqlInjectionMatchSet) GoString() string {
	return s.String()
}

// SetName sets the Name field's value.
func (s *SqlInjectionMatchSet) SetName(v string) *SqlInjectionMatchSet {
	s.Name = &v
	return s
}

// SetSqlInjectionMatchSetId sets the SqlInjectionMatchSetId field's value.
func (s *SqlInjectionMatchSet) SetSqlInjectionMatchSetId(v string) *SqlInjectionMatchSet {
	s.SqlInjectionMatchSetId = &v
	return s
}

// SetSqlInjectionMatchTuples sets the SqlInjectionMatchTuples field's value.
func (s *SqlInjectionMatchSet) SetSqlInjectionMatchTuples(v []SqlInjectionMatchTuple) *SqlInjectionMatchSet {
	s.SqlInjectionMatchTuples = v
	return s
}

// The Id and Name of a SqlInjectionMatchSet.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/SqlInjectionMatchSetSummary
type SqlInjectionMatchSetSummary struct {
	_ struct{} `type:"structure"`

	// The name of the SqlInjectionMatchSet, if any, specified by Id.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// A unique identifier for a SqlInjectionMatchSet. You use SqlInjectionMatchSetId
	// to get information about a SqlInjectionMatchSet (see GetSqlInjectionMatchSet),
	// update a SqlInjectionMatchSet (see UpdateSqlInjectionMatchSet), insert a
	// SqlInjectionMatchSet into a Rule or delete one from a Rule (see UpdateRule),
	// and delete a SqlInjectionMatchSet from AWS WAF (see DeleteSqlInjectionMatchSet).
	//
	// SqlInjectionMatchSetId is returned by CreateSqlInjectionMatchSet and by ListSqlInjectionMatchSets.
	//
	// SqlInjectionMatchSetId is a required field
	SqlInjectionMatchSetId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s SqlInjectionMatchSetSummary) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s SqlInjectionMatchSetSummary) GoString() string {
	return s.String()
}

// SetName sets the Name field's value.
func (s *SqlInjectionMatchSetSummary) SetName(v string) *SqlInjectionMatchSetSummary {
	s.Name = &v
	return s
}

// SetSqlInjectionMatchSetId sets the SqlInjectionMatchSetId field's value.
func (s *SqlInjectionMatchSetSummary) SetSqlInjectionMatchSetId(v string) *SqlInjectionMatchSetSummary {
	s.SqlInjectionMatchSetId = &v
	return s
}

// Specifies the part of a web request that you want to inspect for snippets
// of malicious SQL code and indicates whether you want to add the specification
// to a SqlInjectionMatchSet or delete it from a SqlInjectionMatchSet.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/SqlInjectionMatchSetUpdate
type SqlInjectionMatchSetUpdate struct {
	_ struct{} `type:"structure"`

	// Specify INSERT to add a SqlInjectionMatchSetUpdate to a SqlInjectionMatchSet.
	// Use DELETE to remove a SqlInjectionMatchSetUpdate from a SqlInjectionMatchSet.
	//
	// Action is a required field
	Action ChangeAction `type:"string" required:"true" enum:"true"`

	// Specifies the part of a web request that you want AWS WAF to inspect for
	// snippets of malicious SQL code and, if you want AWS WAF to inspect a header,
	// the name of the header.
	//
	// SqlInjectionMatchTuple is a required field
	SqlInjectionMatchTuple *SqlInjectionMatchTuple `type:"structure" required:"true"`
}

// String returns the string representation
func (s SqlInjectionMatchSetUpdate) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s SqlInjectionMatchSetUpdate) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *SqlInjectionMatchSetUpdate) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "SqlInjectionMatchSetUpdate"}
	if len(s.Action) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("Action"))
	}

	if s.SqlInjectionMatchTuple == nil {
		invalidParams.Add(aws.NewErrParamRequired("SqlInjectionMatchTuple"))
	}
	if s.SqlInjectionMatchTuple != nil {
		if err := s.SqlInjectionMatchTuple.Validate(); err != nil {
			invalidParams.AddNested("SqlInjectionMatchTuple", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetAction sets the Action field's value.
func (s *SqlInjectionMatchSetUpdate) SetAction(v ChangeAction) *SqlInjectionMatchSetUpdate {
	s.Action = v
	return s
}

// SetSqlInjectionMatchTuple sets the SqlInjectionMatchTuple field's value.
func (s *SqlInjectionMatchSetUpdate) SetSqlInjectionMatchTuple(v *SqlInjectionMatchTuple) *SqlInjectionMatchSetUpdate {
	s.SqlInjectionMatchTuple = v
	return s
}

// Specifies the part of a web request that you want AWS WAF to inspect for
// snippets of malicious SQL code and, if you want AWS WAF to inspect a header,
// the name of the header.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/SqlInjectionMatchTuple
type SqlInjectionMatchTuple struct {
	_ struct{} `type:"structure"`

	// Specifies where in a web request to look for snippets of malicious SQL code.
	//
	// FieldToMatch is a required field
	FieldToMatch *FieldToMatch `type:"structure" required:"true"`

	// Text transformations eliminate some of the unusual formatting that attackers
	// use in web requests in an effort to bypass AWS WAF. If you specify a transformation,
	// AWS WAF performs the transformation on FieldToMatch before inspecting a request
	// for a match.
	//
	// CMD_LINE
	//
	// When you're concerned that attackers are injecting an operating system commandline
	// command and using unusual formatting to disguise some or all of the command,
	// use this option to perform the following transformations:
	//
	//    * Delete the following characters: \ " ' ^
	//
	//    * Delete spaces before the following characters: / (
	//
	//    * Replace the following characters with a space: , ;
	//
	//    * Replace multiple spaces with one space
	//
	//    * Convert uppercase letters (A-Z) to lowercase (a-z)
	//
	// COMPRESS_WHITE_SPACE
	//
	// Use this option to replace the following characters with a space character
	// (decimal 32):
	//
	//    * \f, formfeed, decimal 12
	//
	//    * \t, tab, decimal 9
	//
	//    * \n, newline, decimal 10
	//
	//    * \r, carriage return, decimal 13
	//
	//    * \v, vertical tab, decimal 11
	//
	//    * non-breaking space, decimal 160
	//
	// COMPRESS_WHITE_SPACE also replaces multiple spaces with one space.
	//
	// HTML_ENTITY_DECODE
	//
	// Use this option to replace HTML-encoded characters with unencoded characters.
	// HTML_ENTITY_DECODE performs the following operations:
	//
	//    * Replaces (ampersand)quot; with "
	//
	//    * Replaces (ampersand)nbsp; with a non-breaking space, decimal 160
	//
	//    * Replaces (ampersand)lt; with a "less than" symbol
	//
	//    * Replaces (ampersand)gt; with >
	//
	//    * Replaces characters that are represented in hexadecimal format, (ampersand)#xhhhh;,
	//    with the corresponding characters
	//
	//    * Replaces characters that are represented in decimal format, (ampersand)#nnnn;,
	//    with the corresponding characters
	//
	// LOWERCASE
	//
	// Use this option to convert uppercase letters (A-Z) to lowercase (a-z).
	//
	// URL_DECODE
	//
	// Use this option to decode a URL-encoded value.
	//
	// NONE
	//
	// Specify NONE if you don't want to perform any text transformations.
	//
	// TextTransformation is a required field
	TextTransformation TextTransformation `type:"string" required:"true" enum:"true"`
}

// String returns the string representation
func (s SqlInjectionMatchTuple) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s SqlInjectionMatchTuple) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *SqlInjectionMatchTuple) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "SqlInjectionMatchTuple"}

	if s.FieldToMatch == nil {
		invalidParams.Add(aws.NewErrParamRequired("FieldToMatch"))
	}
	if len(s.TextTransformation) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("TextTransformation"))
	}
	if s.FieldToMatch != nil {
		if err := s.FieldToMatch.Validate(); err != nil {
			invalidParams.AddNested("FieldToMatch", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetFieldToMatch sets the FieldToMatch field's value.
func (s *SqlInjectionMatchTuple) SetFieldToMatch(v *FieldToMatch) *SqlInjectionMatchTuple {
	s.FieldToMatch = v
	return s
}

// SetTextTransformation sets the TextTransformation field's value.
func (s *SqlInjectionMatchTuple) SetTextTransformation(v TextTransformation) *SqlInjectionMatchTuple {
	s.TextTransformation = v
	return s
}

// In a GetSampledRequests request, the StartTime and EndTime objects specify
// the time range for which you want AWS WAF to return a sample of web requests.
//
// In a GetSampledRequests response, the StartTime and EndTime objects specify
// the time range for which AWS WAF actually returned a sample of web requests.
// AWS WAF gets the specified number of requests from among the first 5,000
// requests that your AWS resource receives during the specified time period.
// If your resource receives more than 5,000 requests during that period, AWS
// WAF stops sampling after the 5,000th request. In that case, EndTime is the
// time that AWS WAF received the 5,000th request.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/TimeWindow
type TimeWindow struct {
	_ struct{} `type:"structure"`

	// The end of the time range from which you want GetSampledRequests to return
	// a sample of the requests that your AWS resource received. Specify the date
	// and time in the following format: "2016-09-27T14:50Z". You can specify any
	// time range in the previous three hours.
	//
	// EndTime is a required field
	EndTime *time.Time `type:"timestamp" timestampFormat:"unix" required:"true"`

	// The beginning of the time range from which you want GetSampledRequests to
	// return a sample of the requests that your AWS resource received. Specify
	// the date and time in the following format: "2016-09-27T14:50Z". You can specify
	// any time range in the previous three hours.
	//
	// StartTime is a required field
	StartTime *time.Time `type:"timestamp" timestampFormat:"unix" required:"true"`
}

// String returns the string representation
func (s TimeWindow) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s TimeWindow) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *TimeWindow) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "TimeWindow"}

	if s.EndTime == nil {
		invalidParams.Add(aws.NewErrParamRequired("EndTime"))
	}

	if s.StartTime == nil {
		invalidParams.Add(aws.NewErrParamRequired("StartTime"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetEndTime sets the EndTime field's value.
func (s *TimeWindow) SetEndTime(v time.Time) *TimeWindow {
	s.EndTime = &v
	return s
}

// SetStartTime sets the StartTime field's value.
func (s *TimeWindow) SetStartTime(v time.Time) *TimeWindow {
	s.StartTime = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateByteMatchSetRequest
type UpdateByteMatchSetInput struct {
	_ struct{} `type:"structure"`

	// The ByteMatchSetId of the ByteMatchSet that you want to update. ByteMatchSetId
	// is returned by CreateByteMatchSet and by ListByteMatchSets.
	//
	// ByteMatchSetId is a required field
	ByteMatchSetId *string `min:"1" type:"string" required:"true"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// An array of ByteMatchSetUpdate objects that you want to insert into or delete
	// from a ByteMatchSet. For more information, see the applicable data types:
	//
	//    * ByteMatchSetUpdate: Contains Action and ByteMatchTuple
	//
	//    * ByteMatchTuple: Contains FieldToMatch, PositionalConstraint, TargetString,
	//    and TextTransformation
	//
	//    * FieldToMatch: Contains Data and Type
	//
	// Updates is a required field
	Updates []ByteMatchSetUpdate `type:"list" required:"true"`
}

// String returns the string representation
func (s UpdateByteMatchSetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateByteMatchSetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateByteMatchSetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UpdateByteMatchSetInput"}

	if s.ByteMatchSetId == nil {
		invalidParams.Add(aws.NewErrParamRequired("ByteMatchSetId"))
	}
	if s.ByteMatchSetId != nil && len(*s.ByteMatchSetId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ByteMatchSetId", 1))
	}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.Updates == nil {
		invalidParams.Add(aws.NewErrParamRequired("Updates"))
	}
	if s.Updates != nil {
		for i, v := range s.Updates {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Updates", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetByteMatchSetId sets the ByteMatchSetId field's value.
func (s *UpdateByteMatchSetInput) SetByteMatchSetId(v string) *UpdateByteMatchSetInput {
	s.ByteMatchSetId = &v
	return s
}

// SetChangeToken sets the ChangeToken field's value.
func (s *UpdateByteMatchSetInput) SetChangeToken(v string) *UpdateByteMatchSetInput {
	s.ChangeToken = &v
	return s
}

// SetUpdates sets the Updates field's value.
func (s *UpdateByteMatchSetInput) SetUpdates(v []ByteMatchSetUpdate) *UpdateByteMatchSetInput {
	s.Updates = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateByteMatchSetResponse
type UpdateByteMatchSetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the UpdateByteMatchSet request. You
	// can also use this value to query the status of the request. For more information,
	// see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s UpdateByteMatchSetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateByteMatchSetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s UpdateByteMatchSetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *UpdateByteMatchSetOutput) SetChangeToken(v string) *UpdateByteMatchSetOutput {
	s.ChangeToken = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateIPSetRequest
type UpdateIPSetInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// The IPSetId of the IPSet that you want to update. IPSetId is returned by
	// CreateIPSet and by ListIPSets.
	//
	// IPSetId is a required field
	IPSetId *string `min:"1" type:"string" required:"true"`

	// An array of IPSetUpdate objects that you want to insert into or delete from
	// an IPSet. For more information, see the applicable data types:
	//
	//    * IPSetUpdate: Contains Action and IPSetDescriptor
	//
	//    * IPSetDescriptor: Contains Type and Value
	//
	// Updates is a required field
	Updates []IPSetUpdate `type:"list" required:"true"`
}

// String returns the string representation
func (s UpdateIPSetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateIPSetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateIPSetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UpdateIPSetInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.IPSetId == nil {
		invalidParams.Add(aws.NewErrParamRequired("IPSetId"))
	}
	if s.IPSetId != nil && len(*s.IPSetId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("IPSetId", 1))
	}

	if s.Updates == nil {
		invalidParams.Add(aws.NewErrParamRequired("Updates"))
	}
	if s.Updates != nil {
		for i, v := range s.Updates {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Updates", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *UpdateIPSetInput) SetChangeToken(v string) *UpdateIPSetInput {
	s.ChangeToken = &v
	return s
}

// SetIPSetId sets the IPSetId field's value.
func (s *UpdateIPSetInput) SetIPSetId(v string) *UpdateIPSetInput {
	s.IPSetId = &v
	return s
}

// SetUpdates sets the Updates field's value.
func (s *UpdateIPSetInput) SetUpdates(v []IPSetUpdate) *UpdateIPSetInput {
	s.Updates = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateIPSetResponse
type UpdateIPSetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the UpdateIPSet request. You can
	// also use this value to query the status of the request. For more information,
	// see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s UpdateIPSetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateIPSetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s UpdateIPSetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *UpdateIPSetOutput) SetChangeToken(v string) *UpdateIPSetOutput {
	s.ChangeToken = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateRateBasedRuleRequest
type UpdateRateBasedRuleInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// The maximum number of requests, which have an identical value in the field
	// specified by the RateKey, allowed in a five-minute period. If the number
	// of requests exceeds the RateLimit and the other predicates specified in the
	// rule are also met, AWS WAF triggers the action that is specified for this
	// rule.
	//
	// RateLimit is a required field
	RateLimit *int64 `min:"2000" type:"long" required:"true"`

	// The RuleId of the RateBasedRule that you want to update. RuleId is returned
	// by CreateRateBasedRule and by ListRateBasedRules.
	//
	// RuleId is a required field
	RuleId *string `min:"1" type:"string" required:"true"`

	// An array of RuleUpdate objects that you want to insert into or delete from
	// a RateBasedRule.
	//
	// Updates is a required field
	Updates []RuleUpdate `type:"list" required:"true"`
}

// String returns the string representation
func (s UpdateRateBasedRuleInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateRateBasedRuleInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateRateBasedRuleInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UpdateRateBasedRuleInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.RateLimit == nil {
		invalidParams.Add(aws.NewErrParamRequired("RateLimit"))
	}
	if s.RateLimit != nil && *s.RateLimit < 2000 {
		invalidParams.Add(aws.NewErrParamMinValue("RateLimit", 2000))
	}

	if s.RuleId == nil {
		invalidParams.Add(aws.NewErrParamRequired("RuleId"))
	}
	if s.RuleId != nil && len(*s.RuleId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("RuleId", 1))
	}

	if s.Updates == nil {
		invalidParams.Add(aws.NewErrParamRequired("Updates"))
	}
	if s.Updates != nil {
		for i, v := range s.Updates {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Updates", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *UpdateRateBasedRuleInput) SetChangeToken(v string) *UpdateRateBasedRuleInput {
	s.ChangeToken = &v
	return s
}

// SetRateLimit sets the RateLimit field's value.
func (s *UpdateRateBasedRuleInput) SetRateLimit(v int64) *UpdateRateBasedRuleInput {
	s.RateLimit = &v
	return s
}

// SetRuleId sets the RuleId field's value.
func (s *UpdateRateBasedRuleInput) SetRuleId(v string) *UpdateRateBasedRuleInput {
	s.RuleId = &v
	return s
}

// SetUpdates sets the Updates field's value.
func (s *UpdateRateBasedRuleInput) SetUpdates(v []RuleUpdate) *UpdateRateBasedRuleInput {
	s.Updates = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateRateBasedRuleResponse
type UpdateRateBasedRuleOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the UpdateRateBasedRule request.
	// You can also use this value to query the status of the request. For more
	// information, see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s UpdateRateBasedRuleOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateRateBasedRuleOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s UpdateRateBasedRuleOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *UpdateRateBasedRuleOutput) SetChangeToken(v string) *UpdateRateBasedRuleOutput {
	s.ChangeToken = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateRuleRequest
type UpdateRuleInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// The RuleId of the Rule that you want to update. RuleId is returned by CreateRule
	// and by ListRules.
	//
	// RuleId is a required field
	RuleId *string `min:"1" type:"string" required:"true"`

	// An array of RuleUpdate objects that you want to insert into or delete from
	// a Rule. For more information, see the applicable data types:
	//
	//    * RuleUpdate: Contains Action and Predicate
	//
	//    * Predicate: Contains DataId, Negated, and Type
	//
	//    * FieldToMatch: Contains Data and Type
	//
	// Updates is a required field
	Updates []RuleUpdate `type:"list" required:"true"`
}

// String returns the string representation
func (s UpdateRuleInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateRuleInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateRuleInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UpdateRuleInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.RuleId == nil {
		invalidParams.Add(aws.NewErrParamRequired("RuleId"))
	}
	if s.RuleId != nil && len(*s.RuleId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("RuleId", 1))
	}

	if s.Updates == nil {
		invalidParams.Add(aws.NewErrParamRequired("Updates"))
	}
	if s.Updates != nil {
		for i, v := range s.Updates {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Updates", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *UpdateRuleInput) SetChangeToken(v string) *UpdateRuleInput {
	s.ChangeToken = &v
	return s
}

// SetRuleId sets the RuleId field's value.
func (s *UpdateRuleInput) SetRuleId(v string) *UpdateRuleInput {
	s.RuleId = &v
	return s
}

// SetUpdates sets the Updates field's value.
func (s *UpdateRuleInput) SetUpdates(v []RuleUpdate) *UpdateRuleInput {
	s.Updates = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateRuleResponse
type UpdateRuleOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the UpdateRule request. You can also
	// use this value to query the status of the request. For more information,
	// see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s UpdateRuleOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateRuleOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s UpdateRuleOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *UpdateRuleOutput) SetChangeToken(v string) *UpdateRuleOutput {
	s.ChangeToken = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateSizeConstraintSetRequest
type UpdateSizeConstraintSetInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// The SizeConstraintSetId of the SizeConstraintSet that you want to update.
	// SizeConstraintSetId is returned by CreateSizeConstraintSet and by ListSizeConstraintSets.
	//
	// SizeConstraintSetId is a required field
	SizeConstraintSetId *string `min:"1" type:"string" required:"true"`

	// An array of SizeConstraintSetUpdate objects that you want to insert into
	// or delete from a SizeConstraintSet. For more information, see the applicable
	// data types:
	//
	//    * SizeConstraintSetUpdate: Contains Action and SizeConstraint
	//
	//    * SizeConstraint: Contains FieldToMatch, TextTransformation, ComparisonOperator,
	//    and Size
	//
	//    * FieldToMatch: Contains Data and Type
	//
	// Updates is a required field
	Updates []SizeConstraintSetUpdate `type:"list" required:"true"`
}

// String returns the string representation
func (s UpdateSizeConstraintSetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateSizeConstraintSetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateSizeConstraintSetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UpdateSizeConstraintSetInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.SizeConstraintSetId == nil {
		invalidParams.Add(aws.NewErrParamRequired("SizeConstraintSetId"))
	}
	if s.SizeConstraintSetId != nil && len(*s.SizeConstraintSetId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("SizeConstraintSetId", 1))
	}

	if s.Updates == nil {
		invalidParams.Add(aws.NewErrParamRequired("Updates"))
	}
	if s.Updates != nil {
		for i, v := range s.Updates {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Updates", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *UpdateSizeConstraintSetInput) SetChangeToken(v string) *UpdateSizeConstraintSetInput {
	s.ChangeToken = &v
	return s
}

// SetSizeConstraintSetId sets the SizeConstraintSetId field's value.
func (s *UpdateSizeConstraintSetInput) SetSizeConstraintSetId(v string) *UpdateSizeConstraintSetInput {
	s.SizeConstraintSetId = &v
	return s
}

// SetUpdates sets the Updates field's value.
func (s *UpdateSizeConstraintSetInput) SetUpdates(v []SizeConstraintSetUpdate) *UpdateSizeConstraintSetInput {
	s.Updates = v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateSizeConstraintSetResponse
type UpdateSizeConstraintSetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the UpdateSizeConstraintSet request.
	// You can also use this value to query the status of the request. For more
	// information, see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s UpdateSizeConstraintSetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateSizeConstraintSetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s UpdateSizeConstraintSetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *UpdateSizeConstraintSetOutput) SetChangeToken(v string) *UpdateSizeConstraintSetOutput {
	s.ChangeToken = &v
	return s
}

// A request to update a SqlInjectionMatchSet.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateSqlInjectionMatchSetRequest
type UpdateSqlInjectionMatchSetInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// The SqlInjectionMatchSetId of the SqlInjectionMatchSet that you want to update.
	// SqlInjectionMatchSetId is returned by CreateSqlInjectionMatchSet and by ListSqlInjectionMatchSets.
	//
	// SqlInjectionMatchSetId is a required field
	SqlInjectionMatchSetId *string `min:"1" type:"string" required:"true"`

	// An array of SqlInjectionMatchSetUpdate objects that you want to insert into
	// or delete from a SqlInjectionMatchSet. For more information, see the applicable
	// data types:
	//
	//    * SqlInjectionMatchSetUpdate: Contains Action and SqlInjectionMatchTuple
	//
	//    * SqlInjectionMatchTuple: Contains FieldToMatch and TextTransformation
	//
	//    * FieldToMatch: Contains Data and Type
	//
	// Updates is a required field
	Updates []SqlInjectionMatchSetUpdate `type:"list" required:"true"`
}

// String returns the string representation
func (s UpdateSqlInjectionMatchSetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateSqlInjectionMatchSetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateSqlInjectionMatchSetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UpdateSqlInjectionMatchSetInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.SqlInjectionMatchSetId == nil {
		invalidParams.Add(aws.NewErrParamRequired("SqlInjectionMatchSetId"))
	}
	if s.SqlInjectionMatchSetId != nil && len(*s.SqlInjectionMatchSetId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("SqlInjectionMatchSetId", 1))
	}

	if s.Updates == nil {
		invalidParams.Add(aws.NewErrParamRequired("Updates"))
	}
	if s.Updates != nil {
		for i, v := range s.Updates {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Updates", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *UpdateSqlInjectionMatchSetInput) SetChangeToken(v string) *UpdateSqlInjectionMatchSetInput {
	s.ChangeToken = &v
	return s
}

// SetSqlInjectionMatchSetId sets the SqlInjectionMatchSetId field's value.
func (s *UpdateSqlInjectionMatchSetInput) SetSqlInjectionMatchSetId(v string) *UpdateSqlInjectionMatchSetInput {
	s.SqlInjectionMatchSetId = &v
	return s
}

// SetUpdates sets the Updates field's value.
func (s *UpdateSqlInjectionMatchSetInput) SetUpdates(v []SqlInjectionMatchSetUpdate) *UpdateSqlInjectionMatchSetInput {
	s.Updates = v
	return s
}

// The response to an UpdateSqlInjectionMatchSets request.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateSqlInjectionMatchSetResponse
type UpdateSqlInjectionMatchSetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the UpdateSqlInjectionMatchSet request.
	// You can also use this value to query the status of the request. For more
	// information, see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s UpdateSqlInjectionMatchSetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateSqlInjectionMatchSetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s UpdateSqlInjectionMatchSetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *UpdateSqlInjectionMatchSetOutput) SetChangeToken(v string) *UpdateSqlInjectionMatchSetOutput {
	s.ChangeToken = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateWebACLRequest
type UpdateWebACLInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// A default action for the web ACL, either ALLOW or BLOCK. AWS WAF performs
	// the default action if a request doesn't match the criteria in any of the
	// rules in a web ACL.
	DefaultAction *WafAction `type:"structure"`

	// An array of updates to make to the WebACL.
	//
	// An array of WebACLUpdate objects that you want to insert into or delete from
	// a WebACL. For more information, see the applicable data types:
	//
	//    * WebACLUpdate: Contains Action and ActivatedRule
	//
	//    * ActivatedRule: Contains Action, Priority, RuleId, and Type
	//
	//    * WafAction: Contains Type
	Updates []WebACLUpdate `type:"list"`

	// The WebACLId of the WebACL that you want to update. WebACLId is returned
	// by CreateWebACL and by ListWebACLs.
	//
	// WebACLId is a required field
	WebACLId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s UpdateWebACLInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateWebACLInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateWebACLInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UpdateWebACLInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.WebACLId == nil {
		invalidParams.Add(aws.NewErrParamRequired("WebACLId"))
	}
	if s.WebACLId != nil && len(*s.WebACLId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("WebACLId", 1))
	}
	if s.DefaultAction != nil {
		if err := s.DefaultAction.Validate(); err != nil {
			invalidParams.AddNested("DefaultAction", err.(aws.ErrInvalidParams))
		}
	}
	if s.Updates != nil {
		for i, v := range s.Updates {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Updates", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *UpdateWebACLInput) SetChangeToken(v string) *UpdateWebACLInput {
	s.ChangeToken = &v
	return s
}

// SetDefaultAction sets the DefaultAction field's value.
func (s *UpdateWebACLInput) SetDefaultAction(v *WafAction) *UpdateWebACLInput {
	s.DefaultAction = v
	return s
}

// SetUpdates sets the Updates field's value.
func (s *UpdateWebACLInput) SetUpdates(v []WebACLUpdate) *UpdateWebACLInput {
	s.Updates = v
	return s
}

// SetWebACLId sets the WebACLId field's value.
func (s *UpdateWebACLInput) SetWebACLId(v string) *UpdateWebACLInput {
	s.WebACLId = &v
	return s
}

// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateWebACLResponse
type UpdateWebACLOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the UpdateWebACL request. You can
	// also use this value to query the status of the request. For more information,
	// see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s UpdateWebACLOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateWebACLOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s UpdateWebACLOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *UpdateWebACLOutput) SetChangeToken(v string) *UpdateWebACLOutput {
	s.ChangeToken = &v
	return s
}

// A request to update an XssMatchSet.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateXssMatchSetRequest
type UpdateXssMatchSetInput struct {
	_ struct{} `type:"structure"`

	// The value returned by the most recent call to GetChangeToken.
	//
	// ChangeToken is a required field
	ChangeToken *string `min:"1" type:"string" required:"true"`

	// An array of XssMatchSetUpdate objects that you want to insert into or delete
	// from a XssMatchSet. For more information, see the applicable data types:
	//
	//    * XssMatchSetUpdate: Contains Action and XssMatchTuple
	//
	//    * XssMatchTuple: Contains FieldToMatch and TextTransformation
	//
	//    * FieldToMatch: Contains Data and Type
	//
	// Updates is a required field
	Updates []XssMatchSetUpdate `type:"list" required:"true"`

	// The XssMatchSetId of the XssMatchSet that you want to update. XssMatchSetId
	// is returned by CreateXssMatchSet and by ListXssMatchSets.
	//
	// XssMatchSetId is a required field
	XssMatchSetId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s UpdateXssMatchSetInput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateXssMatchSetInput) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *UpdateXssMatchSetInput) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "UpdateXssMatchSetInput"}

	if s.ChangeToken == nil {
		invalidParams.Add(aws.NewErrParamRequired("ChangeToken"))
	}
	if s.ChangeToken != nil && len(*s.ChangeToken) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("ChangeToken", 1))
	}

	if s.Updates == nil {
		invalidParams.Add(aws.NewErrParamRequired("Updates"))
	}

	if s.XssMatchSetId == nil {
		invalidParams.Add(aws.NewErrParamRequired("XssMatchSetId"))
	}
	if s.XssMatchSetId != nil && len(*s.XssMatchSetId) < 1 {
		invalidParams.Add(aws.NewErrParamMinLen("XssMatchSetId", 1))
	}
	if s.Updates != nil {
		for i, v := range s.Updates {
			if err := v.Validate(); err != nil {
				invalidParams.AddNested(fmt.Sprintf("%s[%v]", "Updates", i), err.(aws.ErrInvalidParams))
			}
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetChangeToken sets the ChangeToken field's value.
func (s *UpdateXssMatchSetInput) SetChangeToken(v string) *UpdateXssMatchSetInput {
	s.ChangeToken = &v
	return s
}

// SetUpdates sets the Updates field's value.
func (s *UpdateXssMatchSetInput) SetUpdates(v []XssMatchSetUpdate) *UpdateXssMatchSetInput {
	s.Updates = v
	return s
}

// SetXssMatchSetId sets the XssMatchSetId field's value.
func (s *UpdateXssMatchSetInput) SetXssMatchSetId(v string) *UpdateXssMatchSetInput {
	s.XssMatchSetId = &v
	return s
}

// The response to an UpdateXssMatchSets request.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/UpdateXssMatchSetResponse
type UpdateXssMatchSetOutput struct {
	_ struct{} `type:"structure"`

	responseMetadata aws.Response

	// The ChangeToken that you used to submit the UpdateXssMatchSet request. You
	// can also use this value to query the status of the request. For more information,
	// see GetChangeTokenStatus.
	ChangeToken *string `min:"1" type:"string"`
}

// String returns the string representation
func (s UpdateXssMatchSetOutput) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s UpdateXssMatchSetOutput) GoString() string {
	return s.String()
}

// SDKResponseMetdata return sthe response metadata for the API.
func (s UpdateXssMatchSetOutput) SDKResponseMetadata() aws.Response {
	return s.responseMetadata
}

// SetChangeToken sets the ChangeToken field's value.
func (s *UpdateXssMatchSetOutput) SetChangeToken(v string) *UpdateXssMatchSetOutput {
	s.ChangeToken = &v
	return s
}

// For the action that is associated with a rule in a WebACL, specifies the
// action that you want AWS WAF to perform when a web request matches all of
// the conditions in a rule. For the default action in a WebACL, specifies the
// action that you want AWS WAF to take when a web request doesn't match all
// of the conditions in any of the rules in a WebACL.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/WafAction
type WafAction struct {
	_ struct{} `type:"structure"`

	// Specifies how you want AWS WAF to respond to requests that match the settings
	// in a Rule. Valid settings include the following:
	//
	//    * ALLOW: AWS WAF allows requests
	//
	//    * BLOCK: AWS WAF blocks requests
	//
	//    * COUNT: AWS WAF increments a counter of the requests that match all of
	//    the conditions in the rule. AWS WAF then continues to inspect the web
	//    request based on the remaining rules in the web ACL. You can't specify
	//    COUNT for the default action for a WebACL.
	//
	// Type is a required field
	Type WafActionType `type:"string" required:"true" enum:"true"`
}

// String returns the string representation
func (s WafAction) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s WafAction) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *WafAction) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "WafAction"}
	if len(s.Type) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("Type"))
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetType sets the Type field's value.
func (s *WafAction) SetType(v WafActionType) *WafAction {
	s.Type = v
	return s
}

// Contains the Rules that identify the requests that you want to allow, block,
// or count. In a WebACL, you also specify a default action (ALLOW or BLOCK),
// and the action for each Rule that you add to a WebACL, for example, block
// requests from specified IP addresses or block requests from specified referrers.
// You also associate the WebACL with a CloudFront distribution to identify
// the requests that you want AWS WAF to filter. If you add more than one Rule
// to a WebACL, a request needs to match only one of the specifications to be
// allowed, blocked, or counted. For more information, see UpdateWebACL.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/WebACL
type WebACL struct {
	_ struct{} `type:"structure"`

	// The action to perform if none of the Rules contained in the WebACL match.
	// The action is specified by the WafAction object.
	//
	// DefaultAction is a required field
	DefaultAction *WafAction `type:"structure" required:"true"`

	// A friendly name or description for the metrics for this WebACL. The name
	// can contain only alphanumeric characters (A-Z, a-z, 0-9); the name can't
	// contain whitespace. You can't change MetricName after you create the WebACL.
	MetricName *string `type:"string"`

	// A friendly name or description of the WebACL. You can't change the name of
	// a WebACL after you create it.
	Name *string `min:"1" type:"string"`

	// An array that contains the action for each Rule in a WebACL, the priority
	// of the Rule, and the ID of the Rule.
	//
	// Rules is a required field
	Rules []ActivatedRule `type:"list" required:"true"`

	// A unique identifier for a WebACL. You use WebACLId to get information about
	// a WebACL (see GetWebACL), update a WebACL (see UpdateWebACL), and delete
	// a WebACL from AWS WAF (see DeleteWebACL).
	//
	// WebACLId is returned by CreateWebACL and by ListWebACLs.
	//
	// WebACLId is a required field
	WebACLId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s WebACL) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s WebACL) GoString() string {
	return s.String()
}

// SetDefaultAction sets the DefaultAction field's value.
func (s *WebACL) SetDefaultAction(v *WafAction) *WebACL {
	s.DefaultAction = v
	return s
}

// SetMetricName sets the MetricName field's value.
func (s *WebACL) SetMetricName(v string) *WebACL {
	s.MetricName = &v
	return s
}

// SetName sets the Name field's value.
func (s *WebACL) SetName(v string) *WebACL {
	s.Name = &v
	return s
}

// SetRules sets the Rules field's value.
func (s *WebACL) SetRules(v []ActivatedRule) *WebACL {
	s.Rules = v
	return s
}

// SetWebACLId sets the WebACLId field's value.
func (s *WebACL) SetWebACLId(v string) *WebACL {
	s.WebACLId = &v
	return s
}

// Contains the identifier and the name or description of the WebACL.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/WebACLSummary
type WebACLSummary struct {
	_ struct{} `type:"structure"`

	// A friendly name or description of the WebACL. You can't change the name of
	// a WebACL after you create it.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// A unique identifier for a WebACL. You use WebACLId to get information about
	// a WebACL (see GetWebACL), update a WebACL (see UpdateWebACL), and delete
	// a WebACL from AWS WAF (see DeleteWebACL).
	//
	// WebACLId is returned by CreateWebACL and by ListWebACLs.
	//
	// WebACLId is a required field
	WebACLId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s WebACLSummary) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s WebACLSummary) GoString() string {
	return s.String()
}

// SetName sets the Name field's value.
func (s *WebACLSummary) SetName(v string) *WebACLSummary {
	s.Name = &v
	return s
}

// SetWebACLId sets the WebACLId field's value.
func (s *WebACLSummary) SetWebACLId(v string) *WebACLSummary {
	s.WebACLId = &v
	return s
}

// Specifies whether to insert a Rule into or delete a Rule from a WebACL.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/WebACLUpdate
type WebACLUpdate struct {
	_ struct{} `type:"structure"`

	// Specifies whether to insert a Rule into or delete a Rule from a WebACL.
	//
	// Action is a required field
	Action ChangeAction `type:"string" required:"true" enum:"true"`

	// The ActivatedRule object in an UpdateWebACL request specifies a Rule that
	// you want to insert or delete, the priority of the Rule in the WebACL, and
	// the action that you want AWS WAF to take when a web request matches the Rule
	// (ALLOW, BLOCK, or COUNT).
	//
	// ActivatedRule is a required field
	ActivatedRule *ActivatedRule `type:"structure" required:"true"`
}

// String returns the string representation
func (s WebACLUpdate) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s WebACLUpdate) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *WebACLUpdate) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "WebACLUpdate"}
	if len(s.Action) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("Action"))
	}

	if s.ActivatedRule == nil {
		invalidParams.Add(aws.NewErrParamRequired("ActivatedRule"))
	}
	if s.ActivatedRule != nil {
		if err := s.ActivatedRule.Validate(); err != nil {
			invalidParams.AddNested("ActivatedRule", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetAction sets the Action field's value.
func (s *WebACLUpdate) SetAction(v ChangeAction) *WebACLUpdate {
	s.Action = v
	return s
}

// SetActivatedRule sets the ActivatedRule field's value.
func (s *WebACLUpdate) SetActivatedRule(v *ActivatedRule) *WebACLUpdate {
	s.ActivatedRule = v
	return s
}

// A complex type that contains XssMatchTuple objects, which specify the parts
// of web requests that you want AWS WAF to inspect for cross-site scripting
// attacks and, if you want AWS WAF to inspect a header, the name of the header.
// If a XssMatchSet contains more than one XssMatchTuple object, a request needs
// to include cross-site scripting attacks in only one of the specified parts
// of the request to be considered a match.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/XssMatchSet
type XssMatchSet struct {
	_ struct{} `type:"structure"`

	// The name, if any, of the XssMatchSet.
	Name *string `min:"1" type:"string"`

	// A unique identifier for an XssMatchSet. You use XssMatchSetId to get information
	// about an XssMatchSet (see GetXssMatchSet), update an XssMatchSet (see UpdateXssMatchSet),
	// insert an XssMatchSet into a Rule or delete one from a Rule (see UpdateRule),
	// and delete an XssMatchSet from AWS WAF (see DeleteXssMatchSet).
	//
	// XssMatchSetId is returned by CreateXssMatchSet and by ListXssMatchSets.
	//
	// XssMatchSetId is a required field
	XssMatchSetId *string `min:"1" type:"string" required:"true"`

	// Specifies the parts of web requests that you want to inspect for cross-site
	// scripting attacks.
	//
	// XssMatchTuples is a required field
	XssMatchTuples []XssMatchTuple `type:"list" required:"true"`
}

// String returns the string representation
func (s XssMatchSet) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s XssMatchSet) GoString() string {
	return s.String()
}

// SetName sets the Name field's value.
func (s *XssMatchSet) SetName(v string) *XssMatchSet {
	s.Name = &v
	return s
}

// SetXssMatchSetId sets the XssMatchSetId field's value.
func (s *XssMatchSet) SetXssMatchSetId(v string) *XssMatchSet {
	s.XssMatchSetId = &v
	return s
}

// SetXssMatchTuples sets the XssMatchTuples field's value.
func (s *XssMatchSet) SetXssMatchTuples(v []XssMatchTuple) *XssMatchSet {
	s.XssMatchTuples = v
	return s
}

// The Id and Name of an XssMatchSet.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/XssMatchSetSummary
type XssMatchSetSummary struct {
	_ struct{} `type:"structure"`

	// The name of the XssMatchSet, if any, specified by Id.
	//
	// Name is a required field
	Name *string `min:"1" type:"string" required:"true"`

	// A unique identifier for an XssMatchSet. You use XssMatchSetId to get information
	// about a XssMatchSet (see GetXssMatchSet), update an XssMatchSet (see UpdateXssMatchSet),
	// insert an XssMatchSet into a Rule or delete one from a Rule (see UpdateRule),
	// and delete an XssMatchSet from AWS WAF (see DeleteXssMatchSet).
	//
	// XssMatchSetId is returned by CreateXssMatchSet and by ListXssMatchSets.
	//
	// XssMatchSetId is a required field
	XssMatchSetId *string `min:"1" type:"string" required:"true"`
}

// String returns the string representation
func (s XssMatchSetSummary) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s XssMatchSetSummary) GoString() string {
	return s.String()
}

// SetName sets the Name field's value.
func (s *XssMatchSetSummary) SetName(v string) *XssMatchSetSummary {
	s.Name = &v
	return s
}

// SetXssMatchSetId sets the XssMatchSetId field's value.
func (s *XssMatchSetSummary) SetXssMatchSetId(v string) *XssMatchSetSummary {
	s.XssMatchSetId = &v
	return s
}

// Specifies the part of a web request that you want to inspect for cross-site
// scripting attacks and indicates whether you want to add the specification
// to an XssMatchSet or delete it from an XssMatchSet.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/XssMatchSetUpdate
type XssMatchSetUpdate struct {
	_ struct{} `type:"structure"`

	// Specify INSERT to add a XssMatchSetUpdate to an XssMatchSet. Use DELETE to
	// remove a XssMatchSetUpdate from an XssMatchSet.
	//
	// Action is a required field
	Action ChangeAction `type:"string" required:"true" enum:"true"`

	// Specifies the part of a web request that you want AWS WAF to inspect for
	// cross-site scripting attacks and, if you want AWS WAF to inspect a header,
	// the name of the header.
	//
	// XssMatchTuple is a required field
	XssMatchTuple *XssMatchTuple `type:"structure" required:"true"`
}

// String returns the string representation
func (s XssMatchSetUpdate) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s XssMatchSetUpdate) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *XssMatchSetUpdate) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "XssMatchSetUpdate"}
	if len(s.Action) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("Action"))
	}

	if s.XssMatchTuple == nil {
		invalidParams.Add(aws.NewErrParamRequired("XssMatchTuple"))
	}
	if s.XssMatchTuple != nil {
		if err := s.XssMatchTuple.Validate(); err != nil {
			invalidParams.AddNested("XssMatchTuple", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetAction sets the Action field's value.
func (s *XssMatchSetUpdate) SetAction(v ChangeAction) *XssMatchSetUpdate {
	s.Action = v
	return s
}

// SetXssMatchTuple sets the XssMatchTuple field's value.
func (s *XssMatchSetUpdate) SetXssMatchTuple(v *XssMatchTuple) *XssMatchSetUpdate {
	s.XssMatchTuple = v
	return s
}

// Specifies the part of a web request that you want AWS WAF to inspect for
// cross-site scripting attacks and, if you want AWS WAF to inspect a header,
// the name of the header.
// Please also see https://docs.aws.amazon.com/goto/WebAPI/waf-2015-08-24/XssMatchTuple
type XssMatchTuple struct {
	_ struct{} `type:"structure"`

	// Specifies where in a web request to look for cross-site scripting attacks.
	//
	// FieldToMatch is a required field
	FieldToMatch *FieldToMatch `type:"structure" required:"true"`

	// Text transformations eliminate some of the unusual formatting that attackers
	// use in web requests in an effort to bypass AWS WAF. If you specify a transformation,
	// AWS WAF performs the transformation on FieldToMatch before inspecting a request
	// for a match.
	//
	// CMD_LINE
	//
	// When you're concerned that attackers are injecting an operating system commandline
	// command and using unusual formatting to disguise some or all of the command,
	// use this option to perform the following transformations:
	//
	//    * Delete the following characters: \ " ' ^
	//
	//    * Delete spaces before the following characters: / (
	//
	//    * Replace the following characters with a space: , ;
	//
	//    * Replace multiple spaces with one space
	//
	//    * Convert uppercase letters (A-Z) to lowercase (a-z)
	//
	// COMPRESS_WHITE_SPACE
	//
	// Use this option to replace the following characters with a space character
	// (decimal 32):
	//
	//    * \f, formfeed, decimal 12
	//
	//    * \t, tab, decimal 9
	//
	//    * \n, newline, decimal 10
	//
	//    * \r, carriage return, decimal 13
	//
	//    * \v, vertical tab, decimal 11
	//
	//    * non-breaking space, decimal 160
	//
	// COMPRESS_WHITE_SPACE also replaces multiple spaces with one space.
	//
	// HTML_ENTITY_DECODE
	//
	// Use this option to replace HTML-encoded characters with unencoded characters.
	// HTML_ENTITY_DECODE performs the following operations:
	//
	//    * Replaces (ampersand)quot; with "
	//
	//    * Replaces (ampersand)nbsp; with a non-breaking space, decimal 160
	//
	//    * Replaces (ampersand)lt; with a "less than" symbol
	//
	//    * Replaces (ampersand)gt; with >
	//
	//    * Replaces characters that are represented in hexadecimal format, (ampersand)#xhhhh;,
	//    with the corresponding characters
	//
	//    * Replaces characters that are represented in decimal format, (ampersand)#nnnn;,
	//    with the corresponding characters
	//
	// LOWERCASE
	//
	// Use this option to convert uppercase letters (A-Z) to lowercase (a-z).
	//
	// URL_DECODE
	//
	// Use this option to decode a URL-encoded value.
	//
	// NONE
	//
	// Specify NONE if you don't want to perform any text transformations.
	//
	// TextTransformation is a required field
	TextTransformation TextTransformation `type:"string" required:"true" enum:"true"`
}

// String returns the string representation
func (s XssMatchTuple) String() string {
	return awsutil.Prettify(s)
}

// GoString returns the string representation
func (s XssMatchTuple) GoString() string {
	return s.String()
}

// Validate inspects the fields of the type to determine if they are valid.
func (s *XssMatchTuple) Validate() error {
	invalidParams := aws.ErrInvalidParams{Context: "XssMatchTuple"}

	if s.FieldToMatch == nil {
		invalidParams.Add(aws.NewErrParamRequired("FieldToMatch"))
	}
	if len(s.TextTransformation) == 0 {
		invalidParams.Add(aws.NewErrParamRequired("TextTransformation"))
	}
	if s.FieldToMatch != nil {
		if err := s.FieldToMatch.Validate(); err != nil {
			invalidParams.AddNested("FieldToMatch", err.(aws.ErrInvalidParams))
		}
	}

	if invalidParams.Len() > 0 {
		return invalidParams
	}
	return nil
}

// SetFieldToMatch sets the FieldToMatch field's value.
func (s *XssMatchTuple) SetFieldToMatch(v *FieldToMatch) *XssMatchTuple {
	s.FieldToMatch = v
	return s
}

// SetTextTransformation sets the TextTransformation field's value.
func (s *XssMatchTuple) SetTextTransformation(v TextTransformation) *XssMatchTuple {
	s.TextTransformation = v
	return s
}

type ChangeAction string

// Enum values for ChangeAction
const (
	ChangeActionInsert ChangeAction = "INSERT"
	ChangeActionDelete ChangeAction = "DELETE"
)

type ChangeTokenStatus string

// Enum values for ChangeTokenStatus
const (
	ChangeTokenStatusProvisioned ChangeTokenStatus = "PROVISIONED"
	ChangeTokenStatusPending     ChangeTokenStatus = "PENDING"
	ChangeTokenStatusInsync      ChangeTokenStatus = "INSYNC"
)

type ComparisonOperator string

// Enum values for ComparisonOperator
const (
	ComparisonOperatorEq ComparisonOperator = "EQ"
	ComparisonOperatorNe ComparisonOperator = "NE"
	ComparisonOperatorLe ComparisonOperator = "LE"
	ComparisonOperatorLt ComparisonOperator = "LT"
	ComparisonOperatorGe ComparisonOperator = "GE"
	ComparisonOperatorGt ComparisonOperator = "GT"
)

type IPSetDescriptorType string

// Enum values for IPSetDescriptorType
const (
	IPSetDescriptorTypeIpv4 IPSetDescriptorType = "IPV4"
	IPSetDescriptorTypeIpv6 IPSetDescriptorType = "IPV6"
)

type MatchFieldType string

// Enum values for MatchFieldType
const (
	MatchFieldTypeUri         MatchFieldType = "URI"
	MatchFieldTypeQueryString MatchFieldType = "QUERY_STRING"
	MatchFieldTypeHeader      MatchFieldType = "HEADER"
	MatchFieldTypeMethod      MatchFieldType = "METHOD"
	MatchFieldTypeBody        MatchFieldType = "BODY"
)

type ParameterExceptionField string

// Enum values for ParameterExceptionField
const (
	ParameterExceptionFieldChangeAction                     ParameterExceptionField = "CHANGE_ACTION"
	ParameterExceptionFieldWafAction                        ParameterExceptionField = "WAF_ACTION"
	ParameterExceptionFieldPredicateType                    ParameterExceptionField = "PREDICATE_TYPE"
	ParameterExceptionFieldIpsetType                        ParameterExceptionField = "IPSET_TYPE"
	ParameterExceptionFieldByteMatchFieldType               ParameterExceptionField = "BYTE_MATCH_FIELD_TYPE"
	ParameterExceptionFieldSqlInjectionMatchFieldType       ParameterExceptionField = "SQL_INJECTION_MATCH_FIELD_TYPE"
	ParameterExceptionFieldByteMatchTextTransformation      ParameterExceptionField = "BYTE_MATCH_TEXT_TRANSFORMATION"
	ParameterExceptionFieldByteMatchPositionalConstraint    ParameterExceptionField = "BYTE_MATCH_POSITIONAL_CONSTRAINT"
	ParameterExceptionFieldSizeConstraintComparisonOperator ParameterExceptionField = "SIZE_CONSTRAINT_COMPARISON_OPERATOR"
	ParameterExceptionFieldRateKey                          ParameterExceptionField = "RATE_KEY"
	ParameterExceptionFieldRuleType                         ParameterExceptionField = "RULE_TYPE"
	ParameterExceptionFieldNextMarker                       ParameterExceptionField = "NEXT_MARKER"
)

type ParameterExceptionReason string

// Enum values for ParameterExceptionReason
const (
	ParameterExceptionReasonInvalidOption      ParameterExceptionReason = "INVALID_OPTION"
	ParameterExceptionReasonIllegalCombination ParameterExceptionReason = "ILLEGAL_COMBINATION"
)

type PositionalConstraint string

// Enum values for PositionalConstraint
const (
	PositionalConstraintExactly      PositionalConstraint = "EXACTLY"
	PositionalConstraintStartsWith   PositionalConstraint = "STARTS_WITH"
	PositionalConstraintEndsWith     PositionalConstraint = "ENDS_WITH"
	PositionalConstraintContains     PositionalConstraint = "CONTAINS"
	PositionalConstraintContainsWord PositionalConstraint = "CONTAINS_WORD"
)

type PredicateType string

// Enum values for PredicateType
const (
	PredicateTypeIpmatch           PredicateType = "IPMatch"
	PredicateTypeByteMatch         PredicateType = "ByteMatch"
	PredicateTypeSqlInjectionMatch PredicateType = "SqlInjectionMatch"
	PredicateTypeSizeConstraint    PredicateType = "SizeConstraint"
	PredicateTypeXssMatch          PredicateType = "XssMatch"
)

type RateKey string

// Enum values for RateKey
const (
	RateKeyIp RateKey = "IP"
)

type TextTransformation string

// Enum values for TextTransformation
const (
	TextTransformationNone               TextTransformation = "NONE"
	TextTransformationCompressWhiteSpace TextTransformation = "COMPRESS_WHITE_SPACE"
	TextTransformationHtmlEntityDecode   TextTransformation = "HTML_ENTITY_DECODE"
	TextTransformationLowercase          TextTransformation = "LOWERCASE"
	TextTransformationCmdLine            TextTransformation = "CMD_LINE"
	TextTransformationUrlDecode          TextTransformation = "URL_DECODE"
)

type WafActionType string

// Enum values for WafActionType
const (
	WafActionTypeBlock WafActionType = "BLOCK"
	WafActionTypeAllow WafActionType = "ALLOW"
	WafActionTypeCount WafActionType = "COUNT"
)

type WafRuleType string

// Enum values for WafRuleType
const (
	WafRuleTypeRegular   WafRuleType = "REGULAR"
	WafRuleTypeRateBased WafRuleType = "RATE_BASED"
)