validators.go

// Code generated by smithy-go-codegen DO NOT EDIT.

package waf

import (
	"context"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/waf/types"
	smithy "github.com/aws/smithy-go"
	"github.com/aws/smithy-go/middleware"
)

type validateOpCreateByteMatchSet struct {
}

func (*validateOpCreateByteMatchSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateByteMatchSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateByteMatchSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateByteMatchSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateGeoMatchSet struct {
}

func (*validateOpCreateGeoMatchSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateGeoMatchSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateGeoMatchSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateGeoMatchSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateIPSet struct {
}

func (*validateOpCreateIPSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateIPSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateIPSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateIPSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateRateBasedRule struct {
}

func (*validateOpCreateRateBasedRule) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateRateBasedRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateRateBasedRuleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateRateBasedRuleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateRegexMatchSet struct {
}

func (*validateOpCreateRegexMatchSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateRegexMatchSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateRegexMatchSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateRegexMatchSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateRegexPatternSet struct {
}

func (*validateOpCreateRegexPatternSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateRegexPatternSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateRegexPatternSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateRegexPatternSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateRuleGroup struct {
}

func (*validateOpCreateRuleGroup) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateRuleGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateRuleGroupInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateRuleGroupInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateRule struct {
}

func (*validateOpCreateRule) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateRuleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateRuleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateSizeConstraintSet struct {
}

func (*validateOpCreateSizeConstraintSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateSizeConstraintSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateSizeConstraintSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateSizeConstraintSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateSqlInjectionMatchSet struct {
}

func (*validateOpCreateSqlInjectionMatchSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateSqlInjectionMatchSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateSqlInjectionMatchSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateSqlInjectionMatchSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateWebACL struct {
}

func (*validateOpCreateWebACL) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateWebACL) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateWebACLInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateWebACLInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateWebACLMigrationStack struct {
}

func (*validateOpCreateWebACLMigrationStack) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateWebACLMigrationStack) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateWebACLMigrationStackInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateWebACLMigrationStackInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateXssMatchSet struct {
}

func (*validateOpCreateXssMatchSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateXssMatchSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateXssMatchSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateXssMatchSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteByteMatchSet struct {
}

func (*validateOpDeleteByteMatchSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteByteMatchSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteByteMatchSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteByteMatchSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteGeoMatchSet struct {
}

func (*validateOpDeleteGeoMatchSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteGeoMatchSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteGeoMatchSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteGeoMatchSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteIPSet struct {
}

func (*validateOpDeleteIPSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteIPSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteIPSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteIPSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteLoggingConfiguration struct {
}

func (*validateOpDeleteLoggingConfiguration) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteLoggingConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteLoggingConfigurationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteLoggingConfigurationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeletePermissionPolicy struct {
}

func (*validateOpDeletePermissionPolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeletePermissionPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeletePermissionPolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeletePermissionPolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteRateBasedRule struct {
}

func (*validateOpDeleteRateBasedRule) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteRateBasedRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteRateBasedRuleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteRateBasedRuleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteRegexMatchSet struct {
}

func (*validateOpDeleteRegexMatchSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteRegexMatchSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteRegexMatchSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteRegexMatchSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteRegexPatternSet struct {
}

func (*validateOpDeleteRegexPatternSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteRegexPatternSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteRegexPatternSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteRegexPatternSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteRuleGroup struct {
}

func (*validateOpDeleteRuleGroup) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteRuleGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteRuleGroupInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteRuleGroupInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteRule struct {
}

func (*validateOpDeleteRule) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteRuleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteRuleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteSizeConstraintSet struct {
}

func (*validateOpDeleteSizeConstraintSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteSizeConstraintSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteSizeConstraintSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteSizeConstraintSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteSqlInjectionMatchSet struct {
}

func (*validateOpDeleteSqlInjectionMatchSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteSqlInjectionMatchSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteSqlInjectionMatchSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteSqlInjectionMatchSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteWebACL struct {
}

func (*validateOpDeleteWebACL) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteWebACL) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteWebACLInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteWebACLInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteXssMatchSet struct {
}

func (*validateOpDeleteXssMatchSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteXssMatchSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteXssMatchSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteXssMatchSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetByteMatchSet struct {
}

func (*validateOpGetByteMatchSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetByteMatchSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetByteMatchSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetByteMatchSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetChangeTokenStatus struct {
}

func (*validateOpGetChangeTokenStatus) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetChangeTokenStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetChangeTokenStatusInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetChangeTokenStatusInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetGeoMatchSet struct {
}

func (*validateOpGetGeoMatchSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetGeoMatchSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetGeoMatchSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetGeoMatchSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetIPSet struct {
}

func (*validateOpGetIPSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetIPSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetIPSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetIPSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetLoggingConfiguration struct {
}

func (*validateOpGetLoggingConfiguration) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetLoggingConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetLoggingConfigurationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetLoggingConfigurationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetPermissionPolicy struct {
}

func (*validateOpGetPermissionPolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetPermissionPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetPermissionPolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetPermissionPolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetRateBasedRule struct {
}

func (*validateOpGetRateBasedRule) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetRateBasedRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetRateBasedRuleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetRateBasedRuleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetRateBasedRuleManagedKeys struct {
}

func (*validateOpGetRateBasedRuleManagedKeys) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetRateBasedRuleManagedKeys) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetRateBasedRuleManagedKeysInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetRateBasedRuleManagedKeysInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetRegexMatchSet struct {
}

func (*validateOpGetRegexMatchSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetRegexMatchSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetRegexMatchSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetRegexMatchSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetRegexPatternSet struct {
}

func (*validateOpGetRegexPatternSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetRegexPatternSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetRegexPatternSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetRegexPatternSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetRuleGroup struct {
}

func (*validateOpGetRuleGroup) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetRuleGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetRuleGroupInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetRuleGroupInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetRule struct {
}

func (*validateOpGetRule) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetRuleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetRuleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetSampledRequests struct {
}

func (*validateOpGetSampledRequests) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetSampledRequests) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetSampledRequestsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetSampledRequestsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetSizeConstraintSet struct {
}

func (*validateOpGetSizeConstraintSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetSizeConstraintSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetSizeConstraintSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetSizeConstraintSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetSqlInjectionMatchSet struct {
}

func (*validateOpGetSqlInjectionMatchSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetSqlInjectionMatchSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetSqlInjectionMatchSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetSqlInjectionMatchSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetWebACL struct {
}

func (*validateOpGetWebACL) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetWebACL) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetWebACLInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetWebACLInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetXssMatchSet struct {
}

func (*validateOpGetXssMatchSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetXssMatchSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetXssMatchSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetXssMatchSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListTagsForResource struct {
}

func (*validateOpListTagsForResource) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListTagsForResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListTagsForResourceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutLoggingConfiguration struct {
}

func (*validateOpPutLoggingConfiguration) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutLoggingConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutLoggingConfigurationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutLoggingConfigurationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutPermissionPolicy struct {
}

func (*validateOpPutPermissionPolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutPermissionPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutPermissionPolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutPermissionPolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpTagResource struct {
}

func (*validateOpTagResource) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*TagResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpTagResourceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUntagResource struct {
}

func (*validateOpUntagResource) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UntagResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUntagResourceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateByteMatchSet struct {
}

func (*validateOpUpdateByteMatchSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateByteMatchSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateByteMatchSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateByteMatchSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateGeoMatchSet struct {
}

func (*validateOpUpdateGeoMatchSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateGeoMatchSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateGeoMatchSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateGeoMatchSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateIPSet struct {
}

func (*validateOpUpdateIPSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateIPSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateIPSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateIPSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateRateBasedRule struct {
}

func (*validateOpUpdateRateBasedRule) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateRateBasedRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateRateBasedRuleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateRateBasedRuleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateRegexMatchSet struct {
}

func (*validateOpUpdateRegexMatchSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateRegexMatchSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateRegexMatchSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateRegexMatchSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateRegexPatternSet struct {
}

func (*validateOpUpdateRegexPatternSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateRegexPatternSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateRegexPatternSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateRegexPatternSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateRuleGroup struct {
}

func (*validateOpUpdateRuleGroup) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateRuleGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateRuleGroupInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateRuleGroupInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateRule struct {
}

func (*validateOpUpdateRule) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateRuleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateRuleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateSizeConstraintSet struct {
}

func (*validateOpUpdateSizeConstraintSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateSizeConstraintSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateSizeConstraintSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateSizeConstraintSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateSqlInjectionMatchSet struct {
}

func (*validateOpUpdateSqlInjectionMatchSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateSqlInjectionMatchSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateSqlInjectionMatchSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateSqlInjectionMatchSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateWebACL struct {
}

func (*validateOpUpdateWebACL) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateWebACL) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateWebACLInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateWebACLInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateXssMatchSet struct {
}

func (*validateOpUpdateXssMatchSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateXssMatchSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateXssMatchSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateXssMatchSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

func addOpCreateByteMatchSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateByteMatchSet{}, middleware.After)
}

func addOpCreateGeoMatchSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateGeoMatchSet{}, middleware.After)
}

func addOpCreateIPSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateIPSet{}, middleware.After)
}

func addOpCreateRateBasedRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateRateBasedRule{}, middleware.After)
}

func addOpCreateRegexMatchSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateRegexMatchSet{}, middleware.After)
}

func addOpCreateRegexPatternSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateRegexPatternSet{}, middleware.After)
}

func addOpCreateRuleGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateRuleGroup{}, middleware.After)
}

func addOpCreateRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateRule{}, middleware.After)
}

func addOpCreateSizeConstraintSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateSizeConstraintSet{}, middleware.After)
}

func addOpCreateSqlInjectionMatchSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateSqlInjectionMatchSet{}, middleware.After)
}

func addOpCreateWebACLValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateWebACL{}, middleware.After)
}

func addOpCreateWebACLMigrationStackValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateWebACLMigrationStack{}, middleware.After)
}

func addOpCreateXssMatchSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateXssMatchSet{}, middleware.After)
}

func addOpDeleteByteMatchSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteByteMatchSet{}, middleware.After)
}

func addOpDeleteGeoMatchSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteGeoMatchSet{}, middleware.After)
}

func addOpDeleteIPSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteIPSet{}, middleware.After)
}

func addOpDeleteLoggingConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteLoggingConfiguration{}, middleware.After)
}

func addOpDeletePermissionPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeletePermissionPolicy{}, middleware.After)
}

func addOpDeleteRateBasedRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteRateBasedRule{}, middleware.After)
}

func addOpDeleteRegexMatchSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteRegexMatchSet{}, middleware.After)
}

func addOpDeleteRegexPatternSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteRegexPatternSet{}, middleware.After)
}

func addOpDeleteRuleGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteRuleGroup{}, middleware.After)
}

func addOpDeleteRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteRule{}, middleware.After)
}

func addOpDeleteSizeConstraintSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteSizeConstraintSet{}, middleware.After)
}

func addOpDeleteSqlInjectionMatchSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteSqlInjectionMatchSet{}, middleware.After)
}

func addOpDeleteWebACLValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteWebACL{}, middleware.After)
}

func addOpDeleteXssMatchSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteXssMatchSet{}, middleware.After)
}

func addOpGetByteMatchSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetByteMatchSet{}, middleware.After)
}

func addOpGetChangeTokenStatusValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetChangeTokenStatus{}, middleware.After)
}

func addOpGetGeoMatchSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetGeoMatchSet{}, middleware.After)
}

func addOpGetIPSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetIPSet{}, middleware.After)
}

func addOpGetLoggingConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetLoggingConfiguration{}, middleware.After)
}

func addOpGetPermissionPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetPermissionPolicy{}, middleware.After)
}

func addOpGetRateBasedRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetRateBasedRule{}, middleware.After)
}

func addOpGetRateBasedRuleManagedKeysValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetRateBasedRuleManagedKeys{}, middleware.After)
}

func addOpGetRegexMatchSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetRegexMatchSet{}, middleware.After)
}

func addOpGetRegexPatternSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetRegexPatternSet{}, middleware.After)
}

func addOpGetRuleGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetRuleGroup{}, middleware.After)
}

func addOpGetRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetRule{}, middleware.After)
}

func addOpGetSampledRequestsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetSampledRequests{}, middleware.After)
}

func addOpGetSizeConstraintSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetSizeConstraintSet{}, middleware.After)
}

func addOpGetSqlInjectionMatchSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetSqlInjectionMatchSet{}, middleware.After)
}

func addOpGetWebACLValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetWebACL{}, middleware.After)
}

func addOpGetXssMatchSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetXssMatchSet{}, middleware.After)
}

func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
}

func addOpPutLoggingConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutLoggingConfiguration{}, middleware.After)
}

func addOpPutPermissionPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutPermissionPolicy{}, middleware.After)
}

func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
}

func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
}

func addOpUpdateByteMatchSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateByteMatchSet{}, middleware.After)
}

func addOpUpdateGeoMatchSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateGeoMatchSet{}, middleware.After)
}

func addOpUpdateIPSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateIPSet{}, middleware.After)
}

func addOpUpdateRateBasedRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateRateBasedRule{}, middleware.After)
}

func addOpUpdateRegexMatchSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateRegexMatchSet{}, middleware.After)
}

func addOpUpdateRegexPatternSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateRegexPatternSet{}, middleware.After)
}

func addOpUpdateRuleGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateRuleGroup{}, middleware.After)
}

func addOpUpdateRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateRule{}, middleware.After)
}

func addOpUpdateSizeConstraintSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateSizeConstraintSet{}, middleware.After)
}

func addOpUpdateSqlInjectionMatchSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateSqlInjectionMatchSet{}, middleware.After)
}

func addOpUpdateWebACLValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateWebACL{}, middleware.After)
}

func addOpUpdateXssMatchSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateXssMatchSet{}, middleware.After)
}

func validateActivatedRule(v *types.ActivatedRule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ActivatedRule"}
	if v.Priority == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Priority"))
	}
	if v.RuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleId"))
	}
	if v.Action != nil {
		if err := validateWafAction(v.Action); err != nil {
			invalidParams.AddNested("Action", err.(smithy.InvalidParamsError))
		}
	}
	if v.OverrideAction != nil {
		if err := validateWafOverrideAction(v.OverrideAction); err != nil {
			invalidParams.AddNested("OverrideAction", err.(smithy.InvalidParamsError))
		}
	}
	if v.ExcludedRules != nil {
		if err := validateExcludedRules(v.ExcludedRules); err != nil {
			invalidParams.AddNested("ExcludedRules", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateByteMatchSetUpdate(v *types.ByteMatchSetUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ByteMatchSetUpdate"}
	if len(v.Action) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if v.ByteMatchTuple == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ByteMatchTuple"))
	} else if v.ByteMatchTuple != nil {
		if err := validateByteMatchTuple(v.ByteMatchTuple); err != nil {
			invalidParams.AddNested("ByteMatchTuple", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateByteMatchSetUpdates(v []types.ByteMatchSetUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ByteMatchSetUpdates"}
	for i := range v {
		if err := validateByteMatchSetUpdate(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateByteMatchTuple(v *types.ByteMatchTuple) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ByteMatchTuple"}
	if v.FieldToMatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldToMatch"))
	} else if v.FieldToMatch != nil {
		if err := validateFieldToMatch(v.FieldToMatch); err != nil {
			invalidParams.AddNested("FieldToMatch", err.(smithy.InvalidParamsError))
		}
	}
	if v.TargetString == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetString"))
	}
	if len(v.TextTransformation) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TextTransformation"))
	}
	if len(v.PositionalConstraint) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PositionalConstraint"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateExcludedRule(v *types.ExcludedRule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExcludedRule"}
	if v.RuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateExcludedRules(v []types.ExcludedRule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExcludedRules"}
	for i := range v {
		if err := validateExcludedRule(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFieldToMatch(v *types.FieldToMatch) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FieldToMatch"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGeoMatchConstraint(v *types.GeoMatchConstraint) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GeoMatchConstraint"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if len(v.Value) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGeoMatchSetUpdate(v *types.GeoMatchSetUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GeoMatchSetUpdate"}
	if len(v.Action) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if v.GeoMatchConstraint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GeoMatchConstraint"))
	} else if v.GeoMatchConstraint != nil {
		if err := validateGeoMatchConstraint(v.GeoMatchConstraint); err != nil {
			invalidParams.AddNested("GeoMatchConstraint", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGeoMatchSetUpdates(v []types.GeoMatchSetUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GeoMatchSetUpdates"}
	for i := range v {
		if err := validateGeoMatchSetUpdate(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateIPSetDescriptor(v *types.IPSetDescriptor) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IPSetDescriptor"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateIPSetUpdate(v *types.IPSetUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IPSetUpdate"}
	if len(v.Action) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if v.IPSetDescriptor == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IPSetDescriptor"))
	} else if v.IPSetDescriptor != nil {
		if err := validateIPSetDescriptor(v.IPSetDescriptor); err != nil {
			invalidParams.AddNested("IPSetDescriptor", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateIPSetUpdates(v []types.IPSetUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IPSetUpdates"}
	for i := range v {
		if err := validateIPSetUpdate(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLoggingConfiguration(v *types.LoggingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LoggingConfiguration"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if v.LogDestinationConfigs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LogDestinationConfigs"))
	}
	if v.RedactedFields != nil {
		if err := validateRedactedFields(v.RedactedFields); err != nil {
			invalidParams.AddNested("RedactedFields", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePredicate(v *types.Predicate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Predicate"}
	if v.Negated == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Negated"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.DataId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRedactedFields(v []types.FieldToMatch) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RedactedFields"}
	for i := range v {
		if err := validateFieldToMatch(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRegexMatchSetUpdate(v *types.RegexMatchSetUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegexMatchSetUpdate"}
	if len(v.Action) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if v.RegexMatchTuple == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RegexMatchTuple"))
	} else if v.RegexMatchTuple != nil {
		if err := validateRegexMatchTuple(v.RegexMatchTuple); err != nil {
			invalidParams.AddNested("RegexMatchTuple", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRegexMatchSetUpdates(v []types.RegexMatchSetUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegexMatchSetUpdates"}
	for i := range v {
		if err := validateRegexMatchSetUpdate(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRegexMatchTuple(v *types.RegexMatchTuple) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegexMatchTuple"}
	if v.FieldToMatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldToMatch"))
	} else if v.FieldToMatch != nil {
		if err := validateFieldToMatch(v.FieldToMatch); err != nil {
			invalidParams.AddNested("FieldToMatch", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.TextTransformation) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TextTransformation"))
	}
	if v.RegexPatternSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RegexPatternSetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRegexPatternSetUpdate(v *types.RegexPatternSetUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegexPatternSetUpdate"}
	if len(v.Action) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if v.RegexPatternString == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RegexPatternString"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRegexPatternSetUpdates(v []types.RegexPatternSetUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegexPatternSetUpdates"}
	for i := range v {
		if err := validateRegexPatternSetUpdate(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRuleGroupUpdate(v *types.RuleGroupUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RuleGroupUpdate"}
	if len(v.Action) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if v.ActivatedRule == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActivatedRule"))
	} else if v.ActivatedRule != nil {
		if err := validateActivatedRule(v.ActivatedRule); err != nil {
			invalidParams.AddNested("ActivatedRule", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRuleGroupUpdates(v []types.RuleGroupUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RuleGroupUpdates"}
	for i := range v {
		if err := validateRuleGroupUpdate(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRuleUpdate(v *types.RuleUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RuleUpdate"}
	if len(v.Action) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if v.Predicate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Predicate"))
	} else if v.Predicate != nil {
		if err := validatePredicate(v.Predicate); err != nil {
			invalidParams.AddNested("Predicate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRuleUpdates(v []types.RuleUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RuleUpdates"}
	for i := range v {
		if err := validateRuleUpdate(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSizeConstraint(v *types.SizeConstraint) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SizeConstraint"}
	if v.FieldToMatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldToMatch"))
	} else if v.FieldToMatch != nil {
		if err := validateFieldToMatch(v.FieldToMatch); err != nil {
			invalidParams.AddNested("FieldToMatch", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.TextTransformation) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TextTransformation"))
	}
	if len(v.ComparisonOperator) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ComparisonOperator"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSizeConstraintSetUpdate(v *types.SizeConstraintSetUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SizeConstraintSetUpdate"}
	if len(v.Action) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if v.SizeConstraint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SizeConstraint"))
	} else if v.SizeConstraint != nil {
		if err := validateSizeConstraint(v.SizeConstraint); err != nil {
			invalidParams.AddNested("SizeConstraint", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSizeConstraintSetUpdates(v []types.SizeConstraintSetUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SizeConstraintSetUpdates"}
	for i := range v {
		if err := validateSizeConstraintSetUpdate(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSqlInjectionMatchSetUpdate(v *types.SqlInjectionMatchSetUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SqlInjectionMatchSetUpdate"}
	if len(v.Action) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if v.SqlInjectionMatchTuple == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SqlInjectionMatchTuple"))
	} else if v.SqlInjectionMatchTuple != nil {
		if err := validateSqlInjectionMatchTuple(v.SqlInjectionMatchTuple); err != nil {
			invalidParams.AddNested("SqlInjectionMatchTuple", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSqlInjectionMatchSetUpdates(v []types.SqlInjectionMatchSetUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SqlInjectionMatchSetUpdates"}
	for i := range v {
		if err := validateSqlInjectionMatchSetUpdate(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSqlInjectionMatchTuple(v *types.SqlInjectionMatchTuple) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SqlInjectionMatchTuple"}
	if v.FieldToMatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldToMatch"))
	} else if v.FieldToMatch != nil {
		if err := validateFieldToMatch(v.FieldToMatch); err != nil {
			invalidParams.AddNested("FieldToMatch", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.TextTransformation) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TextTransformation"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTag(v *types.Tag) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Tag"}
	if v.Key == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Key"))
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTagList(v []types.Tag) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
	for i := range v {
		if err := validateTag(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTimeWindow(v *types.TimeWindow) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TimeWindow"}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWafAction(v *types.WafAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WafAction"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWafOverrideAction(v *types.WafOverrideAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WafOverrideAction"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWebACLUpdate(v *types.WebACLUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WebACLUpdate"}
	if len(v.Action) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if v.ActivatedRule == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActivatedRule"))
	} else if v.ActivatedRule != nil {
		if err := validateActivatedRule(v.ActivatedRule); err != nil {
			invalidParams.AddNested("ActivatedRule", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWebACLUpdates(v []types.WebACLUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WebACLUpdates"}
	for i := range v {
		if err := validateWebACLUpdate(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateXssMatchSetUpdate(v *types.XssMatchSetUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "XssMatchSetUpdate"}
	if len(v.Action) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if v.XssMatchTuple == nil {
		invalidParams.Add(smithy.NewErrParamRequired("XssMatchTuple"))
	} else if v.XssMatchTuple != nil {
		if err := validateXssMatchTuple(v.XssMatchTuple); err != nil {
			invalidParams.AddNested("XssMatchTuple", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateXssMatchSetUpdates(v []types.XssMatchSetUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "XssMatchSetUpdates"}
	for i := range v {
		if err := validateXssMatchSetUpdate(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateXssMatchTuple(v *types.XssMatchTuple) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "XssMatchTuple"}
	if v.FieldToMatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldToMatch"))
	} else if v.FieldToMatch != nil {
		if err := validateFieldToMatch(v.FieldToMatch); err != nil {
			invalidParams.AddNested("FieldToMatch", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.TextTransformation) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TextTransformation"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateByteMatchSetInput(v *CreateByteMatchSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateByteMatchSetInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateGeoMatchSetInput(v *CreateGeoMatchSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateGeoMatchSetInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateIPSetInput(v *CreateIPSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateIPSetInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRateBasedRuleInput(v *CreateRateBasedRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRateBasedRuleInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.MetricName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
	}
	if len(v.RateKey) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RateKey"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRegexMatchSetInput(v *CreateRegexMatchSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRegexMatchSetInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRegexPatternSetInput(v *CreateRegexPatternSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRegexPatternSetInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRuleGroupInput(v *CreateRuleGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRuleGroupInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.MetricName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRuleInput(v *CreateRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRuleInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.MetricName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSizeConstraintSetInput(v *CreateSizeConstraintSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSizeConstraintSetInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSqlInjectionMatchSetInput(v *CreateSqlInjectionMatchSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSqlInjectionMatchSetInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateWebACLInput(v *CreateWebACLInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateWebACLInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.MetricName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
	}
	if v.DefaultAction == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultAction"))
	} else if v.DefaultAction != nil {
		if err := validateWafAction(v.DefaultAction); err != nil {
			invalidParams.AddNested("DefaultAction", err.(smithy.InvalidParamsError))
		}
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateWebACLMigrationStackInput(v *CreateWebACLMigrationStackInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateWebACLMigrationStackInput"}
	if v.WebACLId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WebACLId"))
	}
	if v.S3BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3BucketName"))
	}
	if v.IgnoreUnsupportedType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IgnoreUnsupportedType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateXssMatchSetInput(v *CreateXssMatchSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateXssMatchSetInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteByteMatchSetInput(v *DeleteByteMatchSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteByteMatchSetInput"}
	if v.ByteMatchSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ByteMatchSetId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteGeoMatchSetInput(v *DeleteGeoMatchSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteGeoMatchSetInput"}
	if v.GeoMatchSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GeoMatchSetId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteIPSetInput(v *DeleteIPSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIPSetInput"}
	if v.IPSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IPSetId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteLoggingConfigurationInput(v *DeleteLoggingConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteLoggingConfigurationInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeletePermissionPolicyInput(v *DeletePermissionPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeletePermissionPolicyInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRateBasedRuleInput(v *DeleteRateBasedRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRateBasedRuleInput"}
	if v.RuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRegexMatchSetInput(v *DeleteRegexMatchSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRegexMatchSetInput"}
	if v.RegexMatchSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RegexMatchSetId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRegexPatternSetInput(v *DeleteRegexPatternSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRegexPatternSetInput"}
	if v.RegexPatternSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RegexPatternSetId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRuleGroupInput(v *DeleteRuleGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRuleGroupInput"}
	if v.RuleGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleGroupId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRuleInput(v *DeleteRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRuleInput"}
	if v.RuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteSizeConstraintSetInput(v *DeleteSizeConstraintSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteSizeConstraintSetInput"}
	if v.SizeConstraintSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SizeConstraintSetId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteSqlInjectionMatchSetInput(v *DeleteSqlInjectionMatchSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteSqlInjectionMatchSetInput"}
	if v.SqlInjectionMatchSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SqlInjectionMatchSetId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteWebACLInput(v *DeleteWebACLInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteWebACLInput"}
	if v.WebACLId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WebACLId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteXssMatchSetInput(v *DeleteXssMatchSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteXssMatchSetInput"}
	if v.XssMatchSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("XssMatchSetId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetByteMatchSetInput(v *GetByteMatchSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetByteMatchSetInput"}
	if v.ByteMatchSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ByteMatchSetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetChangeTokenStatusInput(v *GetChangeTokenStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetChangeTokenStatusInput"}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetGeoMatchSetInput(v *GetGeoMatchSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetGeoMatchSetInput"}
	if v.GeoMatchSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GeoMatchSetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIPSetInput(v *GetIPSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIPSetInput"}
	if v.IPSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IPSetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetLoggingConfigurationInput(v *GetLoggingConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetLoggingConfigurationInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetPermissionPolicyInput(v *GetPermissionPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPermissionPolicyInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetRateBasedRuleInput(v *GetRateBasedRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRateBasedRuleInput"}
	if v.RuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetRateBasedRuleManagedKeysInput(v *GetRateBasedRuleManagedKeysInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRateBasedRuleManagedKeysInput"}
	if v.RuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetRegexMatchSetInput(v *GetRegexMatchSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRegexMatchSetInput"}
	if v.RegexMatchSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RegexMatchSetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetRegexPatternSetInput(v *GetRegexPatternSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRegexPatternSetInput"}
	if v.RegexPatternSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RegexPatternSetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetRuleGroupInput(v *GetRuleGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRuleGroupInput"}
	if v.RuleGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleGroupId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetRuleInput(v *GetRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRuleInput"}
	if v.RuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSampledRequestsInput(v *GetSampledRequestsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSampledRequestsInput"}
	if v.WebAclId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WebAclId"))
	}
	if v.RuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleId"))
	}
	if v.TimeWindow == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimeWindow"))
	} else if v.TimeWindow != nil {
		if err := validateTimeWindow(v.TimeWindow); err != nil {
			invalidParams.AddNested("TimeWindow", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSizeConstraintSetInput(v *GetSizeConstraintSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSizeConstraintSetInput"}
	if v.SizeConstraintSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SizeConstraintSetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSqlInjectionMatchSetInput(v *GetSqlInjectionMatchSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSqlInjectionMatchSetInput"}
	if v.SqlInjectionMatchSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SqlInjectionMatchSetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetWebACLInput(v *GetWebACLInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetWebACLInput"}
	if v.WebACLId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WebACLId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetXssMatchSetInput(v *GetXssMatchSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetXssMatchSetInput"}
	if v.XssMatchSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("XssMatchSetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
	if v.ResourceARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutLoggingConfigurationInput(v *PutLoggingConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutLoggingConfigurationInput"}
	if v.LoggingConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LoggingConfiguration"))
	} else if v.LoggingConfiguration != nil {
		if err := validateLoggingConfiguration(v.LoggingConfiguration); err != nil {
			invalidParams.AddNested("LoggingConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutPermissionPolicyInput(v *PutPermissionPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutPermissionPolicyInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if v.Policy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Policy"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTagResourceInput(v *TagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
	if v.ResourceARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	} else if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUntagResourceInput(v *UntagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
	if v.ResourceARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
	}
	if v.TagKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateByteMatchSetInput(v *UpdateByteMatchSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateByteMatchSetInput"}
	if v.ByteMatchSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ByteMatchSetId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if v.Updates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Updates"))
	} else if v.Updates != nil {
		if err := validateByteMatchSetUpdates(v.Updates); err != nil {
			invalidParams.AddNested("Updates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateGeoMatchSetInput(v *UpdateGeoMatchSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateGeoMatchSetInput"}
	if v.GeoMatchSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GeoMatchSetId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if v.Updates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Updates"))
	} else if v.Updates != nil {
		if err := validateGeoMatchSetUpdates(v.Updates); err != nil {
			invalidParams.AddNested("Updates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateIPSetInput(v *UpdateIPSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateIPSetInput"}
	if v.IPSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IPSetId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if v.Updates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Updates"))
	} else if v.Updates != nil {
		if err := validateIPSetUpdates(v.Updates); err != nil {
			invalidParams.AddNested("Updates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRateBasedRuleInput(v *UpdateRateBasedRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRateBasedRuleInput"}
	if v.RuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if v.Updates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Updates"))
	} else if v.Updates != nil {
		if err := validateRuleUpdates(v.Updates); err != nil {
			invalidParams.AddNested("Updates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRegexMatchSetInput(v *UpdateRegexMatchSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRegexMatchSetInput"}
	if v.RegexMatchSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RegexMatchSetId"))
	}
	if v.Updates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Updates"))
	} else if v.Updates != nil {
		if err := validateRegexMatchSetUpdates(v.Updates); err != nil {
			invalidParams.AddNested("Updates", err.(smithy.InvalidParamsError))
		}
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRegexPatternSetInput(v *UpdateRegexPatternSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRegexPatternSetInput"}
	if v.RegexPatternSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RegexPatternSetId"))
	}
	if v.Updates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Updates"))
	} else if v.Updates != nil {
		if err := validateRegexPatternSetUpdates(v.Updates); err != nil {
			invalidParams.AddNested("Updates", err.(smithy.InvalidParamsError))
		}
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRuleGroupInput(v *UpdateRuleGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRuleGroupInput"}
	if v.RuleGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleGroupId"))
	}
	if v.Updates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Updates"))
	} else if v.Updates != nil {
		if err := validateRuleGroupUpdates(v.Updates); err != nil {
			invalidParams.AddNested("Updates", err.(smithy.InvalidParamsError))
		}
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRuleInput(v *UpdateRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRuleInput"}
	if v.RuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if v.Updates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Updates"))
	} else if v.Updates != nil {
		if err := validateRuleUpdates(v.Updates); err != nil {
			invalidParams.AddNested("Updates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateSizeConstraintSetInput(v *UpdateSizeConstraintSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSizeConstraintSetInput"}
	if v.SizeConstraintSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SizeConstraintSetId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if v.Updates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Updates"))
	} else if v.Updates != nil {
		if err := validateSizeConstraintSetUpdates(v.Updates); err != nil {
			invalidParams.AddNested("Updates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateSqlInjectionMatchSetInput(v *UpdateSqlInjectionMatchSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSqlInjectionMatchSetInput"}
	if v.SqlInjectionMatchSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SqlInjectionMatchSetId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if v.Updates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Updates"))
	} else if v.Updates != nil {
		if err := validateSqlInjectionMatchSetUpdates(v.Updates); err != nil {
			invalidParams.AddNested("Updates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateWebACLInput(v *UpdateWebACLInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateWebACLInput"}
	if v.WebACLId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WebACLId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if v.Updates != nil {
		if err := validateWebACLUpdates(v.Updates); err != nil {
			invalidParams.AddNested("Updates", err.(smithy.InvalidParamsError))
		}
	}
	if v.DefaultAction != nil {
		if err := validateWafAction(v.DefaultAction); err != nil {
			invalidParams.AddNested("DefaultAction", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateXssMatchSetInput(v *UpdateXssMatchSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateXssMatchSetInput"}
	if v.XssMatchSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("XssMatchSetId"))
	}
	if v.ChangeToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeToken"))
	}
	if v.Updates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Updates"))
	} else if v.Updates != nil {
		if err := validateXssMatchSetUpdates(v.Updates); err != nil {
			invalidParams.AddNested("Updates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}