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

package route53resolver

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

type validateOpAssociateFirewallRuleGroup struct {
}

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

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

type validateOpAssociateResolverEndpointIpAddress struct {
}

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

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

type validateOpAssociateResolverQueryLogConfig struct {
}

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

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

type validateOpAssociateResolverRule struct {
}

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

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

type validateOpCreateFirewallDomainList struct {
}

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

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

type validateOpCreateFirewallRuleGroup struct {
}

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

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

type validateOpCreateFirewallRule struct {
}

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

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

type validateOpCreateOutpostResolver struct {
}

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

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

type validateOpCreateResolverEndpoint struct {
}

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

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

type validateOpCreateResolverQueryLogConfig struct {
}

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

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

type validateOpCreateResolverRule struct {
}

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

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

type validateOpDeleteFirewallDomainList struct {
}

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

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

type validateOpDeleteFirewallRuleGroup struct {
}

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

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

type validateOpDeleteFirewallRule struct {
}

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

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

type validateOpDeleteOutpostResolver struct {
}

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

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

type validateOpDeleteResolverEndpoint struct {
}

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

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

type validateOpDeleteResolverQueryLogConfig struct {
}

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

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

type validateOpDeleteResolverRule struct {
}

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

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

type validateOpDisassociateFirewallRuleGroup struct {
}

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

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

type validateOpDisassociateResolverEndpointIpAddress struct {
}

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

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

type validateOpDisassociateResolverQueryLogConfig struct {
}

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

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

type validateOpDisassociateResolverRule struct {
}

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

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

type validateOpGetFirewallConfig struct {
}

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

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

type validateOpGetFirewallDomainList struct {
}

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

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

type validateOpGetFirewallRuleGroupAssociation struct {
}

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

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

type validateOpGetFirewallRuleGroup struct {
}

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

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

type validateOpGetFirewallRuleGroupPolicy struct {
}

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

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

type validateOpGetOutpostResolver struct {
}

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

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

type validateOpGetResolverConfig struct {
}

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

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

type validateOpGetResolverDnssecConfig struct {
}

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

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

type validateOpGetResolverEndpoint struct {
}

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

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

type validateOpGetResolverQueryLogConfigAssociation struct {
}

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

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

type validateOpGetResolverQueryLogConfig struct {
}

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

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

type validateOpGetResolverQueryLogConfigPolicy struct {
}

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

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

type validateOpGetResolverRuleAssociation struct {
}

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

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

type validateOpGetResolverRule struct {
}

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

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

type validateOpGetResolverRulePolicy struct {
}

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

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

type validateOpImportFirewallDomains struct {
}

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

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

type validateOpListFirewallDomains struct {
}

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

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

type validateOpListFirewallRules struct {
}

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

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

type validateOpListResolverEndpointIpAddresses struct {
}

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

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

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

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

type validateOpPutResolverQueryLogConfigPolicy struct {
}

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

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

type validateOpPutResolverRulePolicy struct {
}

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

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

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

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

type validateOpUpdateFirewallDomains struct {
}

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

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

type validateOpUpdateFirewallRuleGroupAssociation struct {
}

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

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

type validateOpUpdateFirewallRule struct {
}

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

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

type validateOpUpdateOutpostResolver struct {
}

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

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

type validateOpUpdateResolverConfig struct {
}

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

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

type validateOpUpdateResolverDnssecConfig struct {
}

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

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

type validateOpUpdateResolverEndpoint struct {
}

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

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

type validateOpUpdateResolverRule struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpPutResolverRulePolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutResolverRulePolicy{}, 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 addOpUpdateFirewallConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateFirewallConfig{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

func validateIpAddressRequest(v *types.IpAddressRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IpAddressRequest"}
	if v.SubnetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetId"))
	}
	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 validateUpdateIpAddress(v *types.UpdateIpAddress) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateIpAddress"}
	if v.IpId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpId"))
	}
	if v.Ipv6 == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Ipv6"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpAssociateFirewallRuleGroupInput(v *AssociateFirewallRuleGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateFirewallRuleGroupInput"}
	if v.CreatorRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CreatorRequestId"))
	}
	if v.FirewallRuleGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FirewallRuleGroupId"))
	}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if v.Priority == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Priority"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	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 validateOpAssociateResolverEndpointIpAddressInput(v *AssociateResolverEndpointIpAddressInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateResolverEndpointIpAddressInput"}
	if v.ResolverEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResolverEndpointId"))
	}
	if v.IpAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpAddress"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateResolverQueryLogConfigInput(v *AssociateResolverQueryLogConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateResolverQueryLogConfigInput"}
	if v.ResolverQueryLogConfigId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResolverQueryLogConfigId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateResolverRuleInput(v *AssociateResolverRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateResolverRuleInput"}
	if v.ResolverRuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResolverRuleId"))
	}
	if v.VPCId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VPCId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFirewallDomainListInput(v *CreateFirewallDomainListInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFirewallDomainListInput"}
	if v.CreatorRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CreatorRequestId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	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 validateOpCreateFirewallRuleGroupInput(v *CreateFirewallRuleGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFirewallRuleGroupInput"}
	if v.CreatorRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CreatorRequestId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	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 validateOpCreateFirewallRuleInput(v *CreateFirewallRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFirewallRuleInput"}
	if v.CreatorRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CreatorRequestId"))
	}
	if v.FirewallRuleGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FirewallRuleGroupId"))
	}
	if v.FirewallDomainListId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FirewallDomainListId"))
	}
	if v.Priority == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Priority"))
	}
	if len(v.Action) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateOutpostResolverInput(v *CreateOutpostResolverInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateOutpostResolverInput"}
	if v.CreatorRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CreatorRequestId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.PreferredInstanceType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PreferredInstanceType"))
	}
	if v.OutpostArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutpostArn"))
	}
	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 validateOpCreateResolverEndpointInput(v *CreateResolverEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateResolverEndpointInput"}
	if v.CreatorRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CreatorRequestId"))
	}
	if v.SecurityGroupIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupIds"))
	}
	if len(v.Direction) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Direction"))
	}
	if v.IpAddresses == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpAddresses"))
	} else if v.IpAddresses != nil {
		if err := validateIpAddressesRequest(v.IpAddresses); err != nil {
			invalidParams.AddNested("IpAddresses", err.(smithy.InvalidParamsError))
		}
	}
	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 validateOpCreateResolverQueryLogConfigInput(v *CreateResolverQueryLogConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateResolverQueryLogConfigInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.DestinationArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationArn"))
	}
	if v.CreatorRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CreatorRequestId"))
	}
	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 validateOpCreateResolverRuleInput(v *CreateResolverRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateResolverRuleInput"}
	if v.CreatorRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CreatorRequestId"))
	}
	if len(v.RuleType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RuleType"))
	}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	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 validateOpDeleteFirewallDomainListInput(v *DeleteFirewallDomainListInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteFirewallDomainListInput"}
	if v.FirewallDomainListId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FirewallDomainListId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteFirewallRuleInput(v *DeleteFirewallRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteFirewallRuleInput"}
	if v.FirewallRuleGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FirewallRuleGroupId"))
	}
	if v.FirewallDomainListId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FirewallDomainListId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpDisassociateResolverEndpointIpAddressInput(v *DisassociateResolverEndpointIpAddressInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateResolverEndpointIpAddressInput"}
	if v.ResolverEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResolverEndpointId"))
	}
	if v.IpAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpAddress"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateResolverQueryLogConfigInput(v *DisassociateResolverQueryLogConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateResolverQueryLogConfigInput"}
	if v.ResolverQueryLogConfigId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResolverQueryLogConfigId"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateResolverRuleInput(v *DisassociateResolverRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateResolverRuleInput"}
	if v.VPCId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VPCId"))
	}
	if v.ResolverRuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResolverRuleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpImportFirewallDomainsInput(v *ImportFirewallDomainsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportFirewallDomainsInput"}
	if v.FirewallDomainListId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FirewallDomainListId"))
	}
	if len(v.Operation) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Operation"))
	}
	if v.DomainFileUrl == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainFileUrl"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListResolverEndpointIpAddressesInput(v *ListResolverEndpointIpAddressesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListResolverEndpointIpAddressesInput"}
	if v.ResolverEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResolverEndpointId"))
	}
	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 validateOpPutFirewallRuleGroupPolicyInput(v *PutFirewallRuleGroupPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutFirewallRuleGroupPolicyInput"}
	if v.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	if v.FirewallRuleGroupPolicy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FirewallRuleGroupPolicy"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutResolverQueryLogConfigPolicyInput(v *PutResolverQueryLogConfigPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutResolverQueryLogConfigPolicyInput"}
	if v.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	if v.ResolverQueryLogConfigPolicy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResolverQueryLogConfigPolicy"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutResolverRulePolicyInput(v *PutResolverRulePolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutResolverRulePolicyInput"}
	if v.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	if v.ResolverRulePolicy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResolverRulePolicy"))
	}
	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 validateOpUpdateFirewallConfigInput(v *UpdateFirewallConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFirewallConfigInput"}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if len(v.FirewallFailOpen) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("FirewallFailOpen"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateFirewallDomainsInput(v *UpdateFirewallDomainsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFirewallDomainsInput"}
	if v.FirewallDomainListId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FirewallDomainListId"))
	}
	if len(v.Operation) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Operation"))
	}
	if v.Domains == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domains"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateFirewallRuleInput(v *UpdateFirewallRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFirewallRuleInput"}
	if v.FirewallRuleGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FirewallRuleGroupId"))
	}
	if v.FirewallDomainListId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FirewallDomainListId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateResolverConfigInput(v *UpdateResolverConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateResolverConfigInput"}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if len(v.AutodefinedReverseFlag) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AutodefinedReverseFlag"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateResolverDnssecConfigInput(v *UpdateResolverDnssecConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateResolverDnssecConfigInput"}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if len(v.Validation) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Validation"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateResolverEndpointInput(v *UpdateResolverEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateResolverEndpointInput"}
	if v.ResolverEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResolverEndpointId"))
	}
	if v.UpdateIpAddresses != nil {
		if err := validateUpdateIpAddresses(v.UpdateIpAddresses); err != nil {
			invalidParams.AddNested("UpdateIpAddresses", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateResolverRuleInput(v *UpdateResolverRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateResolverRuleInput"}
	if v.ResolverRuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResolverRuleId"))
	}
	if v.Config == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Config"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}