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

package wafv2

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

type validateOpAssociateWebACL struct {
}

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

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

type validateOpCheckCapacity struct {
}

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

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

type validateOpCreateAPIKey struct {
}

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

func (m *validateOpCreateAPIKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateAPIKeyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateAPIKeyInput(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 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 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 validateOpDeleteFirewallManagerRuleGroups struct {
}

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

func (m *validateOpDeleteFirewallManagerRuleGroups) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteFirewallManagerRuleGroupsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteFirewallManagerRuleGroupsInput(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 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 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 validateOpDescribeAllManagedProducts struct {
}

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

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

type validateOpDescribeManagedProductsByVendor struct {
}

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

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

type validateOpDescribeManagedRuleGroup struct {
}

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

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

type validateOpDisassociateWebACL struct {
}

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

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

type validateOpGenerateMobileSdkReleaseUrl struct {
}

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

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

type validateOpGetDecryptedAPIKey struct {
}

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

func (m *validateOpGetDecryptedAPIKey) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetDecryptedAPIKeyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetDecryptedAPIKeyInput(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 validateOpGetManagedRuleSet struct {
}

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

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

type validateOpGetMobileSdkRelease struct {
}

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

func (m *validateOpGetMobileSdkRelease) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetMobileSdkReleaseInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetMobileSdkReleaseInput(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 validateOpGetRateBasedStatementManagedKeys struct {
}

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

func (m *validateOpGetRateBasedStatementManagedKeys) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetRateBasedStatementManagedKeysInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetRateBasedStatementManagedKeysInput(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 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 validateOpGetWebACLForResource struct {
}

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

func (m *validateOpGetWebACLForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetWebACLForResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetWebACLForResourceInput(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 validateOpListAPIKeys struct {
}

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

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

type validateOpListAvailableManagedRuleGroups struct {
}

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

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

type validateOpListAvailableManagedRuleGroupVersions struct {
}

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

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

type validateOpListIPSets struct {
}

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

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

type validateOpListLoggingConfigurations struct {
}

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

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

type validateOpListManagedRuleSets struct {
}

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

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

type validateOpListMobileSdkReleases struct {
}

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

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

type validateOpListRegexPatternSets struct {
}

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

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

type validateOpListResourcesForWebACL struct {
}

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

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

type validateOpListRuleGroups struct {
}

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

func (m *validateOpListRuleGroups) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListRuleGroupsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListRuleGroupsInput(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 validateOpListWebACLs struct {
}

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

func (m *validateOpListWebACLs) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListWebACLsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListWebACLsInput(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 validateOpPutManagedRuleSetVersions struct {
}

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

func (m *validateOpPutManagedRuleSetVersions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutManagedRuleSetVersionsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutManagedRuleSetVersionsInput(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 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 validateOpUpdateManagedRuleSetVersionExpiryDate struct {
}

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

func (m *validateOpUpdateManagedRuleSetVersionExpiryDate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateManagedRuleSetVersionExpiryDateInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateManagedRuleSetVersionExpiryDateInput(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 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)
}

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

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

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

func addOpCreateIPSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateIPSet{}, 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 addOpCreateWebACLValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateWebACL{}, middleware.After)
}

func addOpDeleteFirewallManagerRuleGroupsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteFirewallManagerRuleGroups{}, 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 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 addOpDeleteWebACLValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteWebACL{}, middleware.After)
}

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

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

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

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

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

func addOpGetDecryptedAPIKeyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetDecryptedAPIKey{}, 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 addOpGetManagedRuleSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetManagedRuleSet{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpPutManagedRuleSetVersionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutManagedRuleSetVersions{}, 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 addOpUpdateIPSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateIPSet{}, middleware.After)
}

func addOpUpdateManagedRuleSetVersionExpiryDateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateManagedRuleSetVersionExpiryDate{}, 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 addOpUpdateWebACLValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateWebACL{}, middleware.After)
}

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

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

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

func validateAllowAction(v *types.AllowAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AllowAction"}
	if v.CustomRequestHandling != nil {
		if err := validateCustomRequestHandling(v.CustomRequestHandling); err != nil {
			invalidParams.AddNested("CustomRequestHandling", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAndStatement(v *types.AndStatement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AndStatement"}
	if v.Statements == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Statements"))
	} else if v.Statements != nil {
		if err := validateStatements(v.Statements); err != nil {
			invalidParams.AddNested("Statements", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAssociationConfig(v *types.AssociationConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociationConfig"}
	if v.RequestBody != nil {
		if err := validateRequestBody(v.RequestBody); err != nil {
			invalidParams.AddNested("RequestBody", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAWSManagedRulesACFPRuleSet(v *types.AWSManagedRulesACFPRuleSet) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AWSManagedRulesACFPRuleSet"}
	if v.CreationPath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CreationPath"))
	}
	if v.RegistrationPagePath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RegistrationPagePath"))
	}
	if v.RequestInspection == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequestInspection"))
	} else if v.RequestInspection != nil {
		if err := validateRequestInspectionACFP(v.RequestInspection); err != nil {
			invalidParams.AddNested("RequestInspection", err.(smithy.InvalidParamsError))
		}
	}
	if v.ResponseInspection != nil {
		if err := validateResponseInspection(v.ResponseInspection); err != nil {
			invalidParams.AddNested("ResponseInspection", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAWSManagedRulesATPRuleSet(v *types.AWSManagedRulesATPRuleSet) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AWSManagedRulesATPRuleSet"}
	if v.LoginPath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LoginPath"))
	}
	if v.RequestInspection != nil {
		if err := validateRequestInspection(v.RequestInspection); err != nil {
			invalidParams.AddNested("RequestInspection", err.(smithy.InvalidParamsError))
		}
	}
	if v.ResponseInspection != nil {
		if err := validateResponseInspection(v.ResponseInspection); err != nil {
			invalidParams.AddNested("ResponseInspection", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateBlockAction(v *types.BlockAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BlockAction"}
	if v.CustomResponse != nil {
		if err := validateCustomResponse(v.CustomResponse); err != nil {
			invalidParams.AddNested("CustomResponse", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateByteMatchStatement(v *types.ByteMatchStatement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ByteMatchStatement"}
	if v.SearchString == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SearchString"))
	}
	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.TextTransformations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextTransformations"))
	} else if v.TextTransformations != nil {
		if err := validateTextTransformations(v.TextTransformations); err != nil {
			invalidParams.AddNested("TextTransformations", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.PositionalConstraint) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PositionalConstraint"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCaptchaAction(v *types.CaptchaAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CaptchaAction"}
	if v.CustomRequestHandling != nil {
		if err := validateCustomRequestHandling(v.CustomRequestHandling); err != nil {
			invalidParams.AddNested("CustomRequestHandling", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCaptchaConfig(v *types.CaptchaConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CaptchaConfig"}
	if v.ImmunityTimeProperty != nil {
		if err := validateImmunityTimeProperty(v.ImmunityTimeProperty); err != nil {
			invalidParams.AddNested("ImmunityTimeProperty", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateChallengeAction(v *types.ChallengeAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChallengeAction"}
	if v.CustomRequestHandling != nil {
		if err := validateCustomRequestHandling(v.CustomRequestHandling); err != nil {
			invalidParams.AddNested("CustomRequestHandling", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateChallengeConfig(v *types.ChallengeConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChallengeConfig"}
	if v.ImmunityTimeProperty != nil {
		if err := validateImmunityTimeProperty(v.ImmunityTimeProperty); err != nil {
			invalidParams.AddNested("ImmunityTimeProperty", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCondition(v *types.Condition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Condition"}
	if v.ActionCondition != nil {
		if err := validateActionCondition(v.ActionCondition); err != nil {
			invalidParams.AddNested("ActionCondition", err.(smithy.InvalidParamsError))
		}
	}
	if v.LabelNameCondition != nil {
		if err := validateLabelNameCondition(v.LabelNameCondition); err != nil {
			invalidParams.AddNested("LabelNameCondition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCookies(v *types.Cookies) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Cookies"}
	if v.MatchPattern == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MatchPattern"))
	}
	if len(v.MatchScope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MatchScope"))
	}
	if len(v.OversizeHandling) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("OversizeHandling"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCountAction(v *types.CountAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CountAction"}
	if v.CustomRequestHandling != nil {
		if err := validateCustomRequestHandling(v.CustomRequestHandling); err != nil {
			invalidParams.AddNested("CustomRequestHandling", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateCustomRequestHandling(v *types.CustomRequestHandling) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomRequestHandling"}
	if v.InsertHeaders == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InsertHeaders"))
	} else if v.InsertHeaders != nil {
		if err := validateCustomHTTPHeaders(v.InsertHeaders); err != nil {
			invalidParams.AddNested("InsertHeaders", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomResponse(v *types.CustomResponse) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomResponse"}
	if v.ResponseCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResponseCode"))
	}
	if v.ResponseHeaders != nil {
		if err := validateCustomHTTPHeaders(v.ResponseHeaders); err != nil {
			invalidParams.AddNested("ResponseHeaders", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomResponseBodies(v map[string]types.CustomResponseBody) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomResponseBodies"}
	for key := range v {
		value := v[key]
		if err := validateCustomResponseBody(&value); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomResponseBody(v *types.CustomResponseBody) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomResponseBody"}
	if len(v.ContentType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ContentType"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDefaultAction(v *types.DefaultAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DefaultAction"}
	if v.Block != nil {
		if err := validateBlockAction(v.Block); err != nil {
			invalidParams.AddNested("Block", err.(smithy.InvalidParamsError))
		}
	}
	if v.Allow != nil {
		if err := validateAllowAction(v.Allow); err != nil {
			invalidParams.AddNested("Allow", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEmailField(v *types.EmailField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EmailField"}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	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.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	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 v.SingleHeader != nil {
		if err := validateSingleHeader(v.SingleHeader); err != nil {
			invalidParams.AddNested("SingleHeader", err.(smithy.InvalidParamsError))
		}
	}
	if v.SingleQueryArgument != nil {
		if err := validateSingleQueryArgument(v.SingleQueryArgument); err != nil {
			invalidParams.AddNested("SingleQueryArgument", err.(smithy.InvalidParamsError))
		}
	}
	if v.JsonBody != nil {
		if err := validateJsonBody(v.JsonBody); err != nil {
			invalidParams.AddNested("JsonBody", err.(smithy.InvalidParamsError))
		}
	}
	if v.Headers != nil {
		if err := validateHeaders(v.Headers); err != nil {
			invalidParams.AddNested("Headers", err.(smithy.InvalidParamsError))
		}
	}
	if v.Cookies != nil {
		if err := validateCookies(v.Cookies); err != nil {
			invalidParams.AddNested("Cookies", err.(smithy.InvalidParamsError))
		}
	}
	if v.HeaderOrder != nil {
		if err := validateHeaderOrder(v.HeaderOrder); err != nil {
			invalidParams.AddNested("HeaderOrder", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFilter(v *types.Filter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Filter"}
	if len(v.Behavior) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Behavior"))
	}
	if len(v.Requirement) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Requirement"))
	}
	if v.Conditions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Conditions"))
	} else if v.Conditions != nil {
		if err := validateConditions(v.Conditions); err != nil {
			invalidParams.AddNested("Conditions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateForwardedIPConfig(v *types.ForwardedIPConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ForwardedIPConfig"}
	if v.HeaderName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HeaderName"))
	}
	if len(v.FallbackBehavior) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("FallbackBehavior"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGeoMatchStatement(v *types.GeoMatchStatement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GeoMatchStatement"}
	if v.ForwardedIPConfig != nil {
		if err := validateForwardedIPConfig(v.ForwardedIPConfig); err != nil {
			invalidParams.AddNested("ForwardedIPConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateHeaders(v *types.Headers) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Headers"}
	if v.MatchPattern == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MatchPattern"))
	}
	if len(v.MatchScope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MatchScope"))
	}
	if len(v.OversizeHandling) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("OversizeHandling"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateIPSetForwardedIPConfig(v *types.IPSetForwardedIPConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IPSetForwardedIPConfig"}
	if v.HeaderName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HeaderName"))
	}
	if len(v.FallbackBehavior) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("FallbackBehavior"))
	}
	if len(v.Position) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Position"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateIPSetReferenceStatement(v *types.IPSetReferenceStatement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IPSetReferenceStatement"}
	if v.ARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ARN"))
	}
	if v.IPSetForwardedIPConfig != nil {
		if err := validateIPSetForwardedIPConfig(v.IPSetForwardedIPConfig); err != nil {
			invalidParams.AddNested("IPSetForwardedIPConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateJsonBody(v *types.JsonBody) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "JsonBody"}
	if v.MatchPattern == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MatchPattern"))
	}
	if len(v.MatchScope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MatchScope"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateLabelMatchStatement(v *types.LabelMatchStatement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LabelMatchStatement"}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.Key == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Key"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateLabels(v []types.Label) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Labels"}
	for i := range v {
		if err := validateLabel(&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 v.LoggingFilter != nil {
		if err := validateLoggingFilter(v.LoggingFilter); err != nil {
			invalidParams.AddNested("LoggingFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLoggingFilter(v *types.LoggingFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LoggingFilter"}
	if v.Filters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
	} else if v.Filters != nil {
		if err := validateFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.DefaultBehavior) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultBehavior"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateManagedRuleGroupConfig(v *types.ManagedRuleGroupConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ManagedRuleGroupConfig"}
	if v.UsernameField != nil {
		if err := validateUsernameField(v.UsernameField); err != nil {
			invalidParams.AddNested("UsernameField", err.(smithy.InvalidParamsError))
		}
	}
	if v.PasswordField != nil {
		if err := validatePasswordField(v.PasswordField); err != nil {
			invalidParams.AddNested("PasswordField", err.(smithy.InvalidParamsError))
		}
	}
	if v.AWSManagedRulesBotControlRuleSet != nil {
		if err := validateAWSManagedRulesBotControlRuleSet(v.AWSManagedRulesBotControlRuleSet); err != nil {
			invalidParams.AddNested("AWSManagedRulesBotControlRuleSet", err.(smithy.InvalidParamsError))
		}
	}
	if v.AWSManagedRulesATPRuleSet != nil {
		if err := validateAWSManagedRulesATPRuleSet(v.AWSManagedRulesATPRuleSet); err != nil {
			invalidParams.AddNested("AWSManagedRulesATPRuleSet", err.(smithy.InvalidParamsError))
		}
	}
	if v.AWSManagedRulesACFPRuleSet != nil {
		if err := validateAWSManagedRulesACFPRuleSet(v.AWSManagedRulesACFPRuleSet); err != nil {
			invalidParams.AddNested("AWSManagedRulesACFPRuleSet", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateManagedRuleGroupStatement(v *types.ManagedRuleGroupStatement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ManagedRuleGroupStatement"}
	if v.VendorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VendorName"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ExcludedRules != nil {
		if err := validateExcludedRules(v.ExcludedRules); err != nil {
			invalidParams.AddNested("ExcludedRules", err.(smithy.InvalidParamsError))
		}
	}
	if v.ScopeDownStatement != nil {
		if err := validateStatement(v.ScopeDownStatement); err != nil {
			invalidParams.AddNested("ScopeDownStatement", err.(smithy.InvalidParamsError))
		}
	}
	if v.ManagedRuleGroupConfigs != nil {
		if err := validateManagedRuleGroupConfigs(v.ManagedRuleGroupConfigs); err != nil {
			invalidParams.AddNested("ManagedRuleGroupConfigs", err.(smithy.InvalidParamsError))
		}
	}
	if v.RuleActionOverrides != nil {
		if err := validateRuleActionOverrides(v.RuleActionOverrides); err != nil {
			invalidParams.AddNested("RuleActionOverrides", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNotStatement(v *types.NotStatement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NotStatement"}
	if v.Statement == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Statement"))
	} else if v.Statement != nil {
		if err := validateStatement(v.Statement); err != nil {
			invalidParams.AddNested("Statement", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOrStatement(v *types.OrStatement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OrStatement"}
	if v.Statements == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Statements"))
	} else if v.Statements != nil {
		if err := validateStatements(v.Statements); err != nil {
			invalidParams.AddNested("Statements", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOverrideAction(v *types.OverrideAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OverrideAction"}
	if v.Count != nil {
		if err := validateCountAction(v.Count); err != nil {
			invalidParams.AddNested("Count", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateRateBasedStatement(v *types.RateBasedStatement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RateBasedStatement"}
	if len(v.AggregateKeyType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AggregateKeyType"))
	}
	if v.ScopeDownStatement != nil {
		if err := validateStatement(v.ScopeDownStatement); err != nil {
			invalidParams.AddNested("ScopeDownStatement", err.(smithy.InvalidParamsError))
		}
	}
	if v.ForwardedIPConfig != nil {
		if err := validateForwardedIPConfig(v.ForwardedIPConfig); err != nil {
			invalidParams.AddNested("ForwardedIPConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomKeys != nil {
		if err := validateRateBasedStatementCustomKeys(v.CustomKeys); err != nil {
			invalidParams.AddNested("CustomKeys", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRateBasedStatementCustomKey(v *types.RateBasedStatementCustomKey) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RateBasedStatementCustomKey"}
	if v.Header != nil {
		if err := validateRateLimitHeader(v.Header); err != nil {
			invalidParams.AddNested("Header", err.(smithy.InvalidParamsError))
		}
	}
	if v.Cookie != nil {
		if err := validateRateLimitCookie(v.Cookie); err != nil {
			invalidParams.AddNested("Cookie", err.(smithy.InvalidParamsError))
		}
	}
	if v.QueryArgument != nil {
		if err := validateRateLimitQueryArgument(v.QueryArgument); err != nil {
			invalidParams.AddNested("QueryArgument", err.(smithy.InvalidParamsError))
		}
	}
	if v.QueryString != nil {
		if err := validateRateLimitQueryString(v.QueryString); err != nil {
			invalidParams.AddNested("QueryString", err.(smithy.InvalidParamsError))
		}
	}
	if v.LabelNamespace != nil {
		if err := validateRateLimitLabelNamespace(v.LabelNamespace); err != nil {
			invalidParams.AddNested("LabelNamespace", err.(smithy.InvalidParamsError))
		}
	}
	if v.UriPath != nil {
		if err := validateRateLimitUriPath(v.UriPath); err != nil {
			invalidParams.AddNested("UriPath", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRateLimitCookie(v *types.RateLimitCookie) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RateLimitCookie"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.TextTransformations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextTransformations"))
	} else if v.TextTransformations != nil {
		if err := validateTextTransformations(v.TextTransformations); err != nil {
			invalidParams.AddNested("TextTransformations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRateLimitHeader(v *types.RateLimitHeader) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RateLimitHeader"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.TextTransformations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextTransformations"))
	} else if v.TextTransformations != nil {
		if err := validateTextTransformations(v.TextTransformations); err != nil {
			invalidParams.AddNested("TextTransformations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRateLimitQueryArgument(v *types.RateLimitQueryArgument) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RateLimitQueryArgument"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.TextTransformations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextTransformations"))
	} else if v.TextTransformations != nil {
		if err := validateTextTransformations(v.TextTransformations); err != nil {
			invalidParams.AddNested("TextTransformations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRateLimitQueryString(v *types.RateLimitQueryString) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RateLimitQueryString"}
	if v.TextTransformations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextTransformations"))
	} else if v.TextTransformations != nil {
		if err := validateTextTransformations(v.TextTransformations); err != nil {
			invalidParams.AddNested("TextTransformations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRateLimitUriPath(v *types.RateLimitUriPath) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RateLimitUriPath"}
	if v.TextTransformations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextTransformations"))
	} else if v.TextTransformations != nil {
		if err := validateTextTransformations(v.TextTransformations); err != nil {
			invalidParams.AddNested("TextTransformations", err.(smithy.InvalidParamsError))
		}
	}
	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 validateRegexMatchStatement(v *types.RegexMatchStatement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegexMatchStatement"}
	if v.RegexString == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RegexString"))
	}
	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.TextTransformations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextTransformations"))
	} else if v.TextTransformations != nil {
		if err := validateTextTransformations(v.TextTransformations); err != nil {
			invalidParams.AddNested("TextTransformations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRegexPatternSetReferenceStatement(v *types.RegexPatternSetReferenceStatement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegexPatternSetReferenceStatement"}
	if v.ARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ARN"))
	}
	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.TextTransformations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextTransformations"))
	} else if v.TextTransformations != nil {
		if err := validateTextTransformations(v.TextTransformations); err != nil {
			invalidParams.AddNested("TextTransformations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRequestBody(v map[string]types.RequestBodyAssociatedResourceTypeConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RequestBody"}
	for key := range v {
		value := v[key]
		if err := validateRequestBodyAssociatedResourceTypeConfig(&value); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRequestInspection(v *types.RequestInspection) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RequestInspection"}
	if len(v.PayloadType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PayloadType"))
	}
	if v.UsernameField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsernameField"))
	} else if v.UsernameField != nil {
		if err := validateUsernameField(v.UsernameField); err != nil {
			invalidParams.AddNested("UsernameField", err.(smithy.InvalidParamsError))
		}
	}
	if v.PasswordField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PasswordField"))
	} else if v.PasswordField != nil {
		if err := validatePasswordField(v.PasswordField); err != nil {
			invalidParams.AddNested("PasswordField", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRequestInspectionACFP(v *types.RequestInspectionACFP) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RequestInspectionACFP"}
	if len(v.PayloadType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PayloadType"))
	}
	if v.UsernameField != nil {
		if err := validateUsernameField(v.UsernameField); err != nil {
			invalidParams.AddNested("UsernameField", err.(smithy.InvalidParamsError))
		}
	}
	if v.PasswordField != nil {
		if err := validatePasswordField(v.PasswordField); err != nil {
			invalidParams.AddNested("PasswordField", err.(smithy.InvalidParamsError))
		}
	}
	if v.EmailField != nil {
		if err := validateEmailField(v.EmailField); err != nil {
			invalidParams.AddNested("EmailField", err.(smithy.InvalidParamsError))
		}
	}
	if v.PhoneNumberFields != nil {
		if err := validatePhoneNumberFields(v.PhoneNumberFields); err != nil {
			invalidParams.AddNested("PhoneNumberFields", err.(smithy.InvalidParamsError))
		}
	}
	if v.AddressFields != nil {
		if err := validateAddressFields(v.AddressFields); err != nil {
			invalidParams.AddNested("AddressFields", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseInspection(v *types.ResponseInspection) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseInspection"}
	if v.StatusCode != nil {
		if err := validateResponseInspectionStatusCode(v.StatusCode); err != nil {
			invalidParams.AddNested("StatusCode", err.(smithy.InvalidParamsError))
		}
	}
	if v.Header != nil {
		if err := validateResponseInspectionHeader(v.Header); err != nil {
			invalidParams.AddNested("Header", err.(smithy.InvalidParamsError))
		}
	}
	if v.BodyContains != nil {
		if err := validateResponseInspectionBodyContains(v.BodyContains); err != nil {
			invalidParams.AddNested("BodyContains", err.(smithy.InvalidParamsError))
		}
	}
	if v.Json != nil {
		if err := validateResponseInspectionJson(v.Json); err != nil {
			invalidParams.AddNested("Json", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseInspectionBodyContains(v *types.ResponseInspectionBodyContains) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseInspectionBodyContains"}
	if v.SuccessStrings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SuccessStrings"))
	}
	if v.FailureStrings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FailureStrings"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseInspectionHeader(v *types.ResponseInspectionHeader) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseInspectionHeader"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.SuccessValues == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SuccessValues"))
	}
	if v.FailureValues == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FailureValues"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseInspectionJson(v *types.ResponseInspectionJson) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseInspectionJson"}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.SuccessValues == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SuccessValues"))
	}
	if v.FailureValues == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FailureValues"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseInspectionStatusCode(v *types.ResponseInspectionStatusCode) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseInspectionStatusCode"}
	if v.SuccessCodes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SuccessCodes"))
	}
	if v.FailureCodes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FailureCodes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRule(v *types.Rule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Rule"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Statement == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Statement"))
	} else if v.Statement != nil {
		if err := validateStatement(v.Statement); err != nil {
			invalidParams.AddNested("Statement", err.(smithy.InvalidParamsError))
		}
	}
	if v.Action != nil {
		if err := validateRuleAction(v.Action); err != nil {
			invalidParams.AddNested("Action", err.(smithy.InvalidParamsError))
		}
	}
	if v.OverrideAction != nil {
		if err := validateOverrideAction(v.OverrideAction); err != nil {
			invalidParams.AddNested("OverrideAction", err.(smithy.InvalidParamsError))
		}
	}
	if v.RuleLabels != nil {
		if err := validateLabels(v.RuleLabels); err != nil {
			invalidParams.AddNested("RuleLabels", err.(smithy.InvalidParamsError))
		}
	}
	if v.VisibilityConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisibilityConfig"))
	} else if v.VisibilityConfig != nil {
		if err := validateVisibilityConfig(v.VisibilityConfig); err != nil {
			invalidParams.AddNested("VisibilityConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.CaptchaConfig != nil {
		if err := validateCaptchaConfig(v.CaptchaConfig); err != nil {
			invalidParams.AddNested("CaptchaConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ChallengeConfig != nil {
		if err := validateChallengeConfig(v.ChallengeConfig); err != nil {
			invalidParams.AddNested("ChallengeConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRuleAction(v *types.RuleAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RuleAction"}
	if v.Block != nil {
		if err := validateBlockAction(v.Block); err != nil {
			invalidParams.AddNested("Block", err.(smithy.InvalidParamsError))
		}
	}
	if v.Allow != nil {
		if err := validateAllowAction(v.Allow); err != nil {
			invalidParams.AddNested("Allow", err.(smithy.InvalidParamsError))
		}
	}
	if v.Count != nil {
		if err := validateCountAction(v.Count); err != nil {
			invalidParams.AddNested("Count", err.(smithy.InvalidParamsError))
		}
	}
	if v.Captcha != nil {
		if err := validateCaptchaAction(v.Captcha); err != nil {
			invalidParams.AddNested("Captcha", err.(smithy.InvalidParamsError))
		}
	}
	if v.Challenge != nil {
		if err := validateChallengeAction(v.Challenge); err != nil {
			invalidParams.AddNested("Challenge", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRuleActionOverride(v *types.RuleActionOverride) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RuleActionOverride"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ActionToUse == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActionToUse"))
	} else if v.ActionToUse != nil {
		if err := validateRuleAction(v.ActionToUse); err != nil {
			invalidParams.AddNested("ActionToUse", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRuleGroupReferenceStatement(v *types.RuleGroupReferenceStatement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RuleGroupReferenceStatement"}
	if v.ARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ARN"))
	}
	if v.ExcludedRules != nil {
		if err := validateExcludedRules(v.ExcludedRules); err != nil {
			invalidParams.AddNested("ExcludedRules", err.(smithy.InvalidParamsError))
		}
	}
	if v.RuleActionOverrides != nil {
		if err := validateRuleActionOverrides(v.RuleActionOverrides); err != nil {
			invalidParams.AddNested("RuleActionOverrides", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateSizeConstraintStatement(v *types.SizeConstraintStatement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SizeConstraintStatement"}
	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.ComparisonOperator) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ComparisonOperator"))
	}
	if v.TextTransformations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextTransformations"))
	} else if v.TextTransformations != nil {
		if err := validateTextTransformations(v.TextTransformations); err != nil {
			invalidParams.AddNested("TextTransformations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSqliMatchStatement(v *types.SqliMatchStatement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SqliMatchStatement"}
	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.TextTransformations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextTransformations"))
	} else if v.TextTransformations != nil {
		if err := validateTextTransformations(v.TextTransformations); err != nil {
			invalidParams.AddNested("TextTransformations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateStatement(v *types.Statement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Statement"}
	if v.ByteMatchStatement != nil {
		if err := validateByteMatchStatement(v.ByteMatchStatement); err != nil {
			invalidParams.AddNested("ByteMatchStatement", err.(smithy.InvalidParamsError))
		}
	}
	if v.SqliMatchStatement != nil {
		if err := validateSqliMatchStatement(v.SqliMatchStatement); err != nil {
			invalidParams.AddNested("SqliMatchStatement", err.(smithy.InvalidParamsError))
		}
	}
	if v.XssMatchStatement != nil {
		if err := validateXssMatchStatement(v.XssMatchStatement); err != nil {
			invalidParams.AddNested("XssMatchStatement", err.(smithy.InvalidParamsError))
		}
	}
	if v.SizeConstraintStatement != nil {
		if err := validateSizeConstraintStatement(v.SizeConstraintStatement); err != nil {
			invalidParams.AddNested("SizeConstraintStatement", err.(smithy.InvalidParamsError))
		}
	}
	if v.GeoMatchStatement != nil {
		if err := validateGeoMatchStatement(v.GeoMatchStatement); err != nil {
			invalidParams.AddNested("GeoMatchStatement", err.(smithy.InvalidParamsError))
		}
	}
	if v.RuleGroupReferenceStatement != nil {
		if err := validateRuleGroupReferenceStatement(v.RuleGroupReferenceStatement); err != nil {
			invalidParams.AddNested("RuleGroupReferenceStatement", err.(smithy.InvalidParamsError))
		}
	}
	if v.IPSetReferenceStatement != nil {
		if err := validateIPSetReferenceStatement(v.IPSetReferenceStatement); err != nil {
			invalidParams.AddNested("IPSetReferenceStatement", err.(smithy.InvalidParamsError))
		}
	}
	if v.RegexPatternSetReferenceStatement != nil {
		if err := validateRegexPatternSetReferenceStatement(v.RegexPatternSetReferenceStatement); err != nil {
			invalidParams.AddNested("RegexPatternSetReferenceStatement", err.(smithy.InvalidParamsError))
		}
	}
	if v.RateBasedStatement != nil {
		if err := validateRateBasedStatement(v.RateBasedStatement); err != nil {
			invalidParams.AddNested("RateBasedStatement", err.(smithy.InvalidParamsError))
		}
	}
	if v.AndStatement != nil {
		if err := validateAndStatement(v.AndStatement); err != nil {
			invalidParams.AddNested("AndStatement", err.(smithy.InvalidParamsError))
		}
	}
	if v.OrStatement != nil {
		if err := validateOrStatement(v.OrStatement); err != nil {
			invalidParams.AddNested("OrStatement", err.(smithy.InvalidParamsError))
		}
	}
	if v.NotStatement != nil {
		if err := validateNotStatement(v.NotStatement); err != nil {
			invalidParams.AddNested("NotStatement", err.(smithy.InvalidParamsError))
		}
	}
	if v.ManagedRuleGroupStatement != nil {
		if err := validateManagedRuleGroupStatement(v.ManagedRuleGroupStatement); err != nil {
			invalidParams.AddNested("ManagedRuleGroupStatement", err.(smithy.InvalidParamsError))
		}
	}
	if v.LabelMatchStatement != nil {
		if err := validateLabelMatchStatement(v.LabelMatchStatement); err != nil {
			invalidParams.AddNested("LabelMatchStatement", err.(smithy.InvalidParamsError))
		}
	}
	if v.RegexMatchStatement != nil {
		if err := validateRegexMatchStatement(v.RegexMatchStatement); err != nil {
			invalidParams.AddNested("RegexMatchStatement", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateStatements(v []types.Statement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Statements"}
	for i := range v {
		if err := validateStatement(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	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 validateTextTransformation(v *types.TextTransformation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TextTransformation"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTextTransformations(v []types.TextTransformation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TextTransformations"}
	for i := range v {
		if err := validateTextTransformation(&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 validateUsernameField(v *types.UsernameField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UsernameField"}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateXssMatchStatement(v *types.XssMatchStatement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "XssMatchStatement"}
	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.TextTransformations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextTransformations"))
	} else if v.TextTransformations != nil {
		if err := validateTextTransformations(v.TextTransformations); err != nil {
			invalidParams.AddNested("TextTransformations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCheckCapacityInput(v *CheckCapacityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CheckCapacityInput"}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.Rules == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Rules"))
	} else if v.Rules != nil {
		if err := validateRules(v.Rules); err != nil {
			invalidParams.AddNested("Rules", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAPIKeyInput(v *CreateAPIKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAPIKeyInput"}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.TokenDomains == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TokenDomains"))
	}
	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 len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if len(v.IPAddressVersion) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("IPAddressVersion"))
	}
	if v.Addresses == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Addresses"))
	}
	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 validateOpCreateRegexPatternSetInput(v *CreateRegexPatternSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRegexPatternSetInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.RegularExpressionList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RegularExpressionList"))
	}
	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 validateOpCreateRuleGroupInput(v *CreateRuleGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRuleGroupInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.Rules != nil {
		if err := validateRules(v.Rules); err != nil {
			invalidParams.AddNested("Rules", err.(smithy.InvalidParamsError))
		}
	}
	if v.VisibilityConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisibilityConfig"))
	} else if v.VisibilityConfig != nil {
		if err := validateVisibilityConfig(v.VisibilityConfig); err != nil {
			invalidParams.AddNested("VisibilityConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomResponseBodies != nil {
		if err := validateCustomResponseBodies(v.CustomResponseBodies); err != nil {
			invalidParams.AddNested("CustomResponseBodies", err.(smithy.InvalidParamsError))
		}
	}
	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 len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.DefaultAction == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultAction"))
	} else if v.DefaultAction != nil {
		if err := validateDefaultAction(v.DefaultAction); err != nil {
			invalidParams.AddNested("DefaultAction", err.(smithy.InvalidParamsError))
		}
	}
	if v.Rules != nil {
		if err := validateRules(v.Rules); err != nil {
			invalidParams.AddNested("Rules", err.(smithy.InvalidParamsError))
		}
	}
	if v.VisibilityConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisibilityConfig"))
	} else if v.VisibilityConfig != nil {
		if err := validateVisibilityConfig(v.VisibilityConfig); err != nil {
			invalidParams.AddNested("VisibilityConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomResponseBodies != nil {
		if err := validateCustomResponseBodies(v.CustomResponseBodies); err != nil {
			invalidParams.AddNested("CustomResponseBodies", err.(smithy.InvalidParamsError))
		}
	}
	if v.CaptchaConfig != nil {
		if err := validateCaptchaConfig(v.CaptchaConfig); err != nil {
			invalidParams.AddNested("CaptchaConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ChallengeConfig != nil {
		if err := validateChallengeConfig(v.ChallengeConfig); err != nil {
			invalidParams.AddNested("ChallengeConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.AssociationConfig != nil {
		if err := validateAssociationConfig(v.AssociationConfig); err != nil {
			invalidParams.AddNested("AssociationConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteFirewallManagerRuleGroupsInput(v *DeleteFirewallManagerRuleGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteFirewallManagerRuleGroupsInput"}
	if v.WebACLArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WebACLArn"))
	}
	if v.WebACLLockToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WebACLLockToken"))
	}
	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.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.LockToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LockToken"))
	}
	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 validateOpDeleteRegexPatternSetInput(v *DeleteRegexPatternSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRegexPatternSetInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.LockToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LockToken"))
	}
	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.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.LockToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LockToken"))
	}
	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.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.LockToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LockToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeAllManagedProductsInput(v *DescribeAllManagedProductsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeAllManagedProductsInput"}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeManagedProductsByVendorInput(v *DescribeManagedProductsByVendorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeManagedProductsByVendorInput"}
	if v.VendorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VendorName"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeManagedRuleGroupInput(v *DescribeManagedRuleGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeManagedRuleGroupInput"}
	if v.VendorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VendorName"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGenerateMobileSdkReleaseUrlInput(v *GenerateMobileSdkReleaseUrlInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GenerateMobileSdkReleaseUrlInput"}
	if len(v.Platform) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Platform"))
	}
	if v.ReleaseVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReleaseVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDecryptedAPIKeyInput(v *GetDecryptedAPIKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDecryptedAPIKeyInput"}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.APIKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("APIKey"))
	}
	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.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	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 validateOpGetManagedRuleSetInput(v *GetManagedRuleSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetManagedRuleSetInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetMobileSdkReleaseInput(v *GetMobileSdkReleaseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMobileSdkReleaseInput"}
	if len(v.Platform) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Platform"))
	}
	if v.ReleaseVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReleaseVersion"))
	}
	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 validateOpGetRateBasedStatementManagedKeysInput(v *GetRateBasedStatementManagedKeysInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRateBasedStatementManagedKeysInput"}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.WebACLName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WebACLName"))
	}
	if v.WebACLId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WebACLId"))
	}
	if v.RuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleName"))
	}
	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.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	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.WebAclArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WebAclArn"))
	}
	if v.RuleMetricName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleMetricName"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	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 validateOpGetWebACLForResourceInput(v *GetWebACLForResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetWebACLForResourceInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	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.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListAPIKeysInput(v *ListAPIKeysInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAPIKeysInput"}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListAvailableManagedRuleGroupsInput(v *ListAvailableManagedRuleGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAvailableManagedRuleGroupsInput"}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListAvailableManagedRuleGroupVersionsInput(v *ListAvailableManagedRuleGroupVersionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAvailableManagedRuleGroupVersionsInput"}
	if v.VendorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VendorName"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListIPSetsInput(v *ListIPSetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListIPSetsInput"}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListLoggingConfigurationsInput(v *ListLoggingConfigurationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListLoggingConfigurationsInput"}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListManagedRuleSetsInput(v *ListManagedRuleSetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListManagedRuleSetsInput"}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListMobileSdkReleasesInput(v *ListMobileSdkReleasesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListMobileSdkReleasesInput"}
	if len(v.Platform) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Platform"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListRegexPatternSetsInput(v *ListRegexPatternSetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListRegexPatternSetsInput"}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListRuleGroupsInput(v *ListRuleGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListRuleGroupsInput"}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	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 validateOpListWebACLsInput(v *ListWebACLsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListWebACLsInput"}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	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 validateOpPutManagedRuleSetVersionsInput(v *PutManagedRuleSetVersionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutManagedRuleSetVersionsInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.LockToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LockToken"))
	}
	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 validateOpUpdateIPSetInput(v *UpdateIPSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateIPSetInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.Addresses == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Addresses"))
	}
	if v.LockToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LockToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateManagedRuleSetVersionExpiryDateInput(v *UpdateManagedRuleSetVersionExpiryDateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateManagedRuleSetVersionExpiryDateInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.LockToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LockToken"))
	}
	if v.VersionToExpire == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VersionToExpire"))
	}
	if v.ExpiryTimestamp == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExpiryTimestamp"))
	}
	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.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.RegularExpressionList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RegularExpressionList"))
	}
	if v.LockToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LockToken"))
	}
	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.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.Rules != nil {
		if err := validateRules(v.Rules); err != nil {
			invalidParams.AddNested("Rules", err.(smithy.InvalidParamsError))
		}
	}
	if v.VisibilityConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisibilityConfig"))
	} else if v.VisibilityConfig != nil {
		if err := validateVisibilityConfig(v.VisibilityConfig); err != nil {
			invalidParams.AddNested("VisibilityConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.LockToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LockToken"))
	}
	if v.CustomResponseBodies != nil {
		if err := validateCustomResponseBodies(v.CustomResponseBodies); err != nil {
			invalidParams.AddNested("CustomResponseBodies", 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.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.DefaultAction == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultAction"))
	} else if v.DefaultAction != nil {
		if err := validateDefaultAction(v.DefaultAction); err != nil {
			invalidParams.AddNested("DefaultAction", err.(smithy.InvalidParamsError))
		}
	}
	if v.Rules != nil {
		if err := validateRules(v.Rules); err != nil {
			invalidParams.AddNested("Rules", err.(smithy.InvalidParamsError))
		}
	}
	if v.VisibilityConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisibilityConfig"))
	} else if v.VisibilityConfig != nil {
		if err := validateVisibilityConfig(v.VisibilityConfig); err != nil {
			invalidParams.AddNested("VisibilityConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.LockToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LockToken"))
	}
	if v.CustomResponseBodies != nil {
		if err := validateCustomResponseBodies(v.CustomResponseBodies); err != nil {
			invalidParams.AddNested("CustomResponseBodies", err.(smithy.InvalidParamsError))
		}
	}
	if v.CaptchaConfig != nil {
		if err := validateCaptchaConfig(v.CaptchaConfig); err != nil {
			invalidParams.AddNested("CaptchaConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ChallengeConfig != nil {
		if err := validateChallengeConfig(v.ChallengeConfig); err != nil {
			invalidParams.AddNested("ChallengeConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.AssociationConfig != nil {
		if err := validateAssociationConfig(v.AssociationConfig); err != nil {
			invalidParams.AddNested("AssociationConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}