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

package route53

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

type validateOpActivateKeySigningKey struct {
}

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

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

type validateOpAssociateVPCWithHostedZone struct {
}

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

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

type validateOpChangeCidrCollection struct {
}

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

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

type validateOpChangeResourceRecordSets struct {
}

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

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

type validateOpChangeTagsForResource struct {
}

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

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

type validateOpCreateCidrCollection struct {
}

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

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

type validateOpCreateHealthCheck struct {
}

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

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

type validateOpCreateHostedZone struct {
}

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

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

type validateOpCreateKeySigningKey struct {
}

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

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

type validateOpCreateQueryLoggingConfig struct {
}

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

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

type validateOpCreateReusableDelegationSet struct {
}

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

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

type validateOpCreateTrafficPolicy struct {
}

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

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

type validateOpCreateTrafficPolicyInstance struct {
}

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

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

type validateOpCreateTrafficPolicyVersion struct {
}

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

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

type validateOpCreateVPCAssociationAuthorization struct {
}

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

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

type validateOpDeactivateKeySigningKey struct {
}

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

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

type validateOpDeleteCidrCollection struct {
}

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

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

type validateOpDeleteHealthCheck struct {
}

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

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

type validateOpDeleteHostedZone struct {
}

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

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

type validateOpDeleteKeySigningKey struct {
}

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

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

type validateOpDeleteQueryLoggingConfig struct {
}

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

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

type validateOpDeleteReusableDelegationSet struct {
}

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

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

type validateOpDeleteTrafficPolicy struct {
}

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

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

type validateOpDeleteTrafficPolicyInstance struct {
}

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

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

type validateOpDeleteVPCAssociationAuthorization struct {
}

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

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

type validateOpDisableHostedZoneDNSSEC struct {
}

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

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

type validateOpDisassociateVPCFromHostedZone struct {
}

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

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

type validateOpEnableHostedZoneDNSSEC struct {
}

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

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

type validateOpGetAccountLimit struct {
}

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

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

type validateOpGetChange struct {
}

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

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

type validateOpGetDNSSEC struct {
}

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

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

type validateOpGetHealthCheck struct {
}

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

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

type validateOpGetHealthCheckLastFailureReason struct {
}

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

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

type validateOpGetHealthCheckStatus struct {
}

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

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

type validateOpGetHostedZone struct {
}

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

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

type validateOpGetHostedZoneLimit struct {
}

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

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

type validateOpGetQueryLoggingConfig struct {
}

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

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

type validateOpGetReusableDelegationSet struct {
}

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

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

type validateOpGetReusableDelegationSetLimit struct {
}

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

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

type validateOpGetTrafficPolicy struct {
}

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

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

type validateOpGetTrafficPolicyInstance struct {
}

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

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

type validateOpListCidrBlocks struct {
}

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

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

type validateOpListCidrLocations struct {
}

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

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

type validateOpListHostedZonesByVPC struct {
}

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

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

type validateOpListResourceRecordSets struct {
}

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

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

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

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

type validateOpListTrafficPolicyInstancesByHostedZone struct {
}

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

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

type validateOpListTrafficPolicyInstancesByPolicy struct {
}

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

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

type validateOpListTrafficPolicyVersions struct {
}

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

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

type validateOpListVPCAssociationAuthorizations struct {
}

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

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

type validateOpTestDNSAnswer struct {
}

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

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

type validateOpUpdateHealthCheck struct {
}

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

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

type validateOpUpdateHostedZoneComment struct {
}

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

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

type validateOpUpdateHostedZoneFeatures struct {
}

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

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

type validateOpUpdateTrafficPolicyComment struct {
}

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

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

type validateOpUpdateTrafficPolicyInstance struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateAliasTarget(v *types.AliasTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AliasTarget"}
	if v.HostedZoneId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
	}
	if v.DNSName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DNSName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateChangeBatch(v *types.ChangeBatch) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChangeBatch"}
	if v.Changes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Changes"))
	} else if v.Changes != nil {
		if err := validateChanges(v.Changes); err != nil {
			invalidParams.AddNested("Changes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateCidrRoutingConfig(v *types.CidrRoutingConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CidrRoutingConfig"}
	if v.CollectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollectionId"))
	}
	if v.LocationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocationName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCoordinates(v *types.Coordinates) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Coordinates"}
	if v.Latitude == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Latitude"))
	}
	if v.Longitude == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Longitude"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGeoProximityLocation(v *types.GeoProximityLocation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GeoProximityLocation"}
	if v.Coordinates != nil {
		if err := validateCoordinates(v.Coordinates); err != nil {
			invalidParams.AddNested("Coordinates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateHealthCheckConfig(v *types.HealthCheckConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HealthCheckConfig"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.AlarmIdentifier != nil {
		if err := validateAlarmIdentifier(v.AlarmIdentifier); err != nil {
			invalidParams.AddNested("AlarmIdentifier", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateResourceRecordSet(v *types.ResourceRecordSet) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResourceRecordSet"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.ResourceRecords != nil {
		if err := validateResourceRecords(v.ResourceRecords); err != nil {
			invalidParams.AddNested("ResourceRecords", err.(smithy.InvalidParamsError))
		}
	}
	if v.AliasTarget != nil {
		if err := validateAliasTarget(v.AliasTarget); err != nil {
			invalidParams.AddNested("AliasTarget", err.(smithy.InvalidParamsError))
		}
	}
	if v.CidrRoutingConfig != nil {
		if err := validateCidrRoutingConfig(v.CidrRoutingConfig); err != nil {
			invalidParams.AddNested("CidrRoutingConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.GeoProximityLocation != nil {
		if err := validateGeoProximityLocation(v.GeoProximityLocation); err != nil {
			invalidParams.AddNested("GeoProximityLocation", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpAssociateVPCWithHostedZoneInput(v *AssociateVPCWithHostedZoneInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateVPCWithHostedZoneInput"}
	if v.HostedZoneId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
	}
	if v.VPC == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VPC"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpChangeCidrCollectionInput(v *ChangeCidrCollectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChangeCidrCollectionInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.Changes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Changes"))
	} else if v.Changes != nil {
		if err := validateCidrCollectionChanges(v.Changes); err != nil {
			invalidParams.AddNested("Changes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpChangeResourceRecordSetsInput(v *ChangeResourceRecordSetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChangeResourceRecordSetsInput"}
	if v.HostedZoneId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
	}
	if v.ChangeBatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeBatch"))
	} else if v.ChangeBatch != nil {
		if err := validateChangeBatch(v.ChangeBatch); err != nil {
			invalidParams.AddNested("ChangeBatch", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpCreateHealthCheckInput(v *CreateHealthCheckInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateHealthCheckInput"}
	if v.CallerReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CallerReference"))
	}
	if v.HealthCheckConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HealthCheckConfig"))
	} else if v.HealthCheckConfig != nil {
		if err := validateHealthCheckConfig(v.HealthCheckConfig); err != nil {
			invalidParams.AddNested("HealthCheckConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateKeySigningKeyInput(v *CreateKeySigningKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateKeySigningKeyInput"}
	if v.CallerReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CallerReference"))
	}
	if v.HostedZoneId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
	}
	if v.KeyManagementServiceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyManagementServiceArn"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Status == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateQueryLoggingConfigInput(v *CreateQueryLoggingConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateQueryLoggingConfigInput"}
	if v.HostedZoneId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
	}
	if v.CloudWatchLogsLogGroupArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CloudWatchLogsLogGroupArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpCreateTrafficPolicyInstanceInput(v *CreateTrafficPolicyInstanceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTrafficPolicyInstanceInput"}
	if v.HostedZoneId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.TTL == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TTL"))
	}
	if v.TrafficPolicyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyId"))
	}
	if v.TrafficPolicyVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateVPCAssociationAuthorizationInput(v *CreateVPCAssociationAuthorizationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVPCAssociationAuthorizationInput"}
	if v.HostedZoneId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
	}
	if v.VPC == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VPC"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

func validateOpDeleteVPCAssociationAuthorizationInput(v *DeleteVPCAssociationAuthorizationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVPCAssociationAuthorizationInput"}
	if v.HostedZoneId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
	}
	if v.VPC == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VPC"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDisassociateVPCFromHostedZoneInput(v *DisassociateVPCFromHostedZoneInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateVPCFromHostedZoneInput"}
	if v.HostedZoneId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
	}
	if v.VPC == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VPC"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpListHostedZonesByVPCInput(v *ListHostedZonesByVPCInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListHostedZonesByVPCInput"}
	if v.VPCId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VPCId"))
	}
	if len(v.VPCRegion) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("VPCRegion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListResourceRecordSetsInput(v *ListResourceRecordSetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListResourceRecordSetsInput"}
	if v.HostedZoneId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
	}
	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 len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListTagsForResourcesInput(v *ListTagsForResourcesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourcesInput"}
	if len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if v.ResourceIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListTrafficPolicyInstancesByPolicyInput(v *ListTrafficPolicyInstancesByPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTrafficPolicyInstancesByPolicyInput"}
	if v.TrafficPolicyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyId"))
	}
	if v.TrafficPolicyVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpTestDNSAnswerInput(v *TestDNSAnswerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestDNSAnswerInput"}
	if v.HostedZoneId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HostedZoneId"))
	}
	if v.RecordName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecordName"))
	}
	if len(v.RecordType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RecordType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateHealthCheckInput(v *UpdateHealthCheckInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateHealthCheckInput"}
	if v.HealthCheckId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HealthCheckId"))
	}
	if v.AlarmIdentifier != nil {
		if err := validateAlarmIdentifier(v.AlarmIdentifier); err != nil {
			invalidParams.AddNested("AlarmIdentifier", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpUpdateTrafficPolicyInstanceInput(v *UpdateTrafficPolicyInstanceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTrafficPolicyInstanceInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.TTL == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TTL"))
	}
	if v.TrafficPolicyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyId"))
	}
	if v.TrafficPolicyVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrafficPolicyVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}
