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

package ec2

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

type validateOpAcceptAddressTransfer struct {
}

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

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

type validateOpAcceptCapacityReservationBillingOwnership struct {
}

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

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

type validateOpAcceptReservedInstancesExchangeQuote struct {
}

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

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

type validateOpAcceptTransitGatewayPeeringAttachment struct {
}

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

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

type validateOpAcceptTransitGatewayVpcAttachment struct {
}

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

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

type validateOpAcceptVpcEndpointConnections struct {
}

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

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

type validateOpAcceptVpcPeeringConnection struct {
}

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

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

type validateOpAdvertiseByoipCidr struct {
}

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

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

type validateOpAllocateHosts struct {
}

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

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

type validateOpAllocateIpamPoolCidr struct {
}

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

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

type validateOpApplySecurityGroupsToClientVpnTargetNetwork struct {
}

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

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

type validateOpAssignIpv6Addresses struct {
}

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

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

type validateOpAssignPrivateIpAddresses struct {
}

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

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

type validateOpAssignPrivateNatGatewayAddress struct {
}

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

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

type validateOpAssociateCapacityReservationBillingOwner struct {
}

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

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

type validateOpAssociateClientVpnTargetNetwork struct {
}

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

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

type validateOpAssociateDhcpOptions struct {
}

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

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

type validateOpAssociateEnclaveCertificateIamRole struct {
}

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

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

type validateOpAssociateIamInstanceProfile struct {
}

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

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

type validateOpAssociateInstanceEventWindow struct {
}

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

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

type validateOpAssociateIpamByoasn struct {
}

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

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

type validateOpAssociateIpamResourceDiscovery struct {
}

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

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

type validateOpAssociateNatGatewayAddress struct {
}

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

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

type validateOpAssociateRouteTable struct {
}

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

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

type validateOpAssociateSecurityGroupVpc struct {
}

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

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

type validateOpAssociateSubnetCidrBlock struct {
}

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

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

type validateOpAssociateTransitGatewayMulticastDomain struct {
}

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

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

type validateOpAssociateTransitGatewayPolicyTable struct {
}

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

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

type validateOpAssociateTransitGatewayRouteTable struct {
}

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

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

type validateOpAssociateTrunkInterface struct {
}

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

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

type validateOpAssociateVpcCidrBlock struct {
}

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

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

type validateOpAttachClassicLinkVpc struct {
}

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

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

type validateOpAttachInternetGateway struct {
}

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

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

type validateOpAttachNetworkInterface struct {
}

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

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

type validateOpAttachVerifiedAccessTrustProvider struct {
}

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

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

type validateOpAttachVolume struct {
}

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

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

type validateOpAttachVpnGateway struct {
}

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

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

type validateOpAuthorizeClientVpnIngress struct {
}

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

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

type validateOpAuthorizeSecurityGroupEgress struct {
}

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

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

type validateOpBundleInstance struct {
}

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

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

type validateOpCancelBundleTask struct {
}

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

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

type validateOpCancelCapacityReservationFleets struct {
}

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

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

type validateOpCancelCapacityReservation struct {
}

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

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

type validateOpCancelConversionTask struct {
}

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

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

type validateOpCancelDeclarativePoliciesReport struct {
}

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

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

type validateOpCancelExportTask struct {
}

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

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

type validateOpCancelImageLaunchPermission struct {
}

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

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

type validateOpCancelReservedInstancesListing struct {
}

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

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

type validateOpCancelSpotFleetRequests struct {
}

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

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

type validateOpCancelSpotInstanceRequests struct {
}

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

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

type validateOpConfirmProductInstance struct {
}

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

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

type validateOpCopyFpgaImage struct {
}

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

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

type validateOpCopyImage struct {
}

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

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

type validateOpCopySnapshot struct {
}

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

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

type validateOpCreateCapacityReservationBySplitting struct {
}

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

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

type validateOpCreateCapacityReservationFleet struct {
}

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

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

type validateOpCreateCapacityReservation struct {
}

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

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

type validateOpCreateCarrierGateway struct {
}

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

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

type validateOpCreateClientVpnEndpoint struct {
}

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

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

type validateOpCreateClientVpnRoute struct {
}

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

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

type validateOpCreateCoipCidr struct {
}

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

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

type validateOpCreateCoipPool struct {
}

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

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

type validateOpCreateCustomerGateway struct {
}

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

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

type validateOpCreateDefaultSubnet struct {
}

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

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

type validateOpCreateDhcpOptions struct {
}

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

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

type validateOpCreateEgressOnlyInternetGateway struct {
}

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

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

type validateOpCreateFleet struct {
}

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

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

type validateOpCreateFlowLogs struct {
}

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

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

type validateOpCreateFpgaImage struct {
}

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

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

type validateOpCreateImage struct {
}

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

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

type validateOpCreateInstanceConnectEndpoint struct {
}

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

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

type validateOpCreateInstanceExportTask struct {
}

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

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

type validateOpCreateIpamExternalResourceVerificationToken struct {
}

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

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

type validateOpCreateIpamPool struct {
}

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

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

type validateOpCreateIpamScope struct {
}

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

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

type validateOpCreateKeyPair struct {
}

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

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

type validateOpCreateLaunchTemplate struct {
}

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

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

type validateOpCreateLaunchTemplateVersion struct {
}

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

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

type validateOpCreateLocalGatewayRoute struct {
}

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

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

type validateOpCreateLocalGatewayRouteTable struct {
}

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

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

type validateOpCreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation struct {
}

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

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

type validateOpCreateLocalGatewayRouteTableVpcAssociation struct {
}

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

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

type validateOpCreateManagedPrefixList struct {
}

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

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

type validateOpCreateNatGateway struct {
}

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

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

type validateOpCreateNetworkAclEntry struct {
}

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

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

type validateOpCreateNetworkAcl struct {
}

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

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

type validateOpCreateNetworkInsightsAccessScope struct {
}

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

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

type validateOpCreateNetworkInsightsPath struct {
}

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

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

type validateOpCreateNetworkInterface struct {
}

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

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

type validateOpCreateNetworkInterfacePermission struct {
}

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

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

type validateOpCreateReplaceRootVolumeTask struct {
}

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

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

type validateOpCreateReservedInstancesListing struct {
}

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

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

type validateOpCreateRestoreImageTask struct {
}

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

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

type validateOpCreateRoute struct {
}

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

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

type validateOpCreateRouteTable struct {
}

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

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

type validateOpCreateSecurityGroup struct {
}

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

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

type validateOpCreateSnapshot struct {
}

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

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

type validateOpCreateSnapshots struct {
}

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

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

type validateOpCreateSpotDatafeedSubscription struct {
}

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

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

type validateOpCreateStoreImageTask struct {
}

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

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

type validateOpCreateSubnetCidrReservation struct {
}

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

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

type validateOpCreateSubnet struct {
}

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

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

type validateOpCreateTags struct {
}

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

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

type validateOpCreateTrafficMirrorFilterRule struct {
}

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

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

type validateOpCreateTrafficMirrorSession struct {
}

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

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

type validateOpCreateTransitGatewayConnect struct {
}

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

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

type validateOpCreateTransitGatewayConnectPeer struct {
}

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

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

type validateOpCreateTransitGatewayMulticastDomain struct {
}

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

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

type validateOpCreateTransitGatewayPeeringAttachment struct {
}

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

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

type validateOpCreateTransitGatewayPolicyTable struct {
}

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

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

type validateOpCreateTransitGatewayPrefixListReference struct {
}

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

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

type validateOpCreateTransitGatewayRoute struct {
}

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

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

type validateOpCreateTransitGatewayRouteTableAnnouncement struct {
}

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

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

type validateOpCreateTransitGatewayRouteTable struct {
}

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

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

type validateOpCreateTransitGatewayVpcAttachment struct {
}

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

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

type validateOpCreateVerifiedAccessEndpoint struct {
}

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

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

type validateOpCreateVerifiedAccessGroup struct {
}

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

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

type validateOpCreateVerifiedAccessTrustProvider struct {
}

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

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

type validateOpCreateVolume struct {
}

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

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

type validateOpCreateVpcBlockPublicAccessExclusion struct {
}

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

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

type validateOpCreateVpcEndpointConnectionNotification struct {
}

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

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

type validateOpCreateVpcEndpoint struct {
}

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

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

type validateOpCreateVpcPeeringConnection struct {
}

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

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

type validateOpCreateVpnConnection struct {
}

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

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

type validateOpCreateVpnConnectionRoute struct {
}

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

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

type validateOpCreateVpnGateway struct {
}

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

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

type validateOpDeleteCarrierGateway struct {
}

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

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

type validateOpDeleteClientVpnEndpoint struct {
}

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

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

type validateOpDeleteClientVpnRoute struct {
}

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

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

type validateOpDeleteCoipCidr struct {
}

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

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

type validateOpDeleteCoipPool struct {
}

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

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

type validateOpDeleteCustomerGateway struct {
}

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

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

type validateOpDeleteDhcpOptions struct {
}

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

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

type validateOpDeleteEgressOnlyInternetGateway struct {
}

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

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

type validateOpDeleteFleets struct {
}

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

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

type validateOpDeleteFlowLogs struct {
}

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

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

type validateOpDeleteFpgaImage struct {
}

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

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

type validateOpDeleteInstanceConnectEndpoint struct {
}

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

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

type validateOpDeleteInstanceEventWindow struct {
}

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

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

type validateOpDeleteInternetGateway struct {
}

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

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

type validateOpDeleteIpamExternalResourceVerificationToken struct {
}

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

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

type validateOpDeleteIpam struct {
}

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

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

type validateOpDeleteIpamPool struct {
}

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

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

type validateOpDeleteIpamResourceDiscovery struct {
}

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

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

type validateOpDeleteIpamScope struct {
}

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

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

type validateOpDeleteLaunchTemplateVersions struct {
}

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

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

type validateOpDeleteLocalGatewayRoute struct {
}

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

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

type validateOpDeleteLocalGatewayRouteTable struct {
}

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

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

type validateOpDeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation struct {
}

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

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

type validateOpDeleteLocalGatewayRouteTableVpcAssociation struct {
}

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

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

type validateOpDeleteManagedPrefixList struct {
}

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

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

type validateOpDeleteNatGateway struct {
}

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

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

type validateOpDeleteNetworkAclEntry struct {
}

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

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

type validateOpDeleteNetworkAcl struct {
}

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

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

type validateOpDeleteNetworkInsightsAccessScopeAnalysis struct {
}

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

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

type validateOpDeleteNetworkInsightsAccessScope struct {
}

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

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

type validateOpDeleteNetworkInsightsAnalysis struct {
}

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

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

type validateOpDeleteNetworkInsightsPath struct {
}

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

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

type validateOpDeleteNetworkInterface struct {
}

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

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

type validateOpDeleteNetworkInterfacePermission struct {
}

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

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

type validateOpDeletePlacementGroup struct {
}

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

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

type validateOpDeletePublicIpv4Pool struct {
}

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

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

type validateOpDeleteQueuedReservedInstances struct {
}

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

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

type validateOpDeleteRoute struct {
}

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

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

type validateOpDeleteRouteTable struct {
}

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

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

type validateOpDeleteSnapshot struct {
}

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

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

type validateOpDeleteSubnetCidrReservation struct {
}

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

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

type validateOpDeleteSubnet struct {
}

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

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

type validateOpDeleteTags struct {
}

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

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

type validateOpDeleteTrafficMirrorFilter struct {
}

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

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

type validateOpDeleteTrafficMirrorFilterRule struct {
}

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

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

type validateOpDeleteTrafficMirrorSession struct {
}

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

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

type validateOpDeleteTrafficMirrorTarget struct {
}

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

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

type validateOpDeleteTransitGatewayConnect struct {
}

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

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

type validateOpDeleteTransitGatewayConnectPeer struct {
}

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

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

type validateOpDeleteTransitGateway struct {
}

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

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

type validateOpDeleteTransitGatewayMulticastDomain struct {
}

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

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

type validateOpDeleteTransitGatewayPeeringAttachment struct {
}

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

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

type validateOpDeleteTransitGatewayPolicyTable struct {
}

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

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

type validateOpDeleteTransitGatewayPrefixListReference struct {
}

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

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

type validateOpDeleteTransitGatewayRoute struct {
}

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

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

type validateOpDeleteTransitGatewayRouteTableAnnouncement struct {
}

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

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

type validateOpDeleteTransitGatewayRouteTable struct {
}

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

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

type validateOpDeleteTransitGatewayVpcAttachment struct {
}

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

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

type validateOpDeleteVerifiedAccessEndpoint struct {
}

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

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

type validateOpDeleteVerifiedAccessGroup struct {
}

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

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

type validateOpDeleteVerifiedAccessInstance struct {
}

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

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

type validateOpDeleteVerifiedAccessTrustProvider struct {
}

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

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

type validateOpDeleteVolume struct {
}

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

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

type validateOpDeleteVpcBlockPublicAccessExclusion struct {
}

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

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

type validateOpDeleteVpcEndpointConnectionNotifications struct {
}

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

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

type validateOpDeleteVpcEndpointServiceConfigurations struct {
}

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

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

type validateOpDeleteVpcEndpoints struct {
}

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

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

type validateOpDeleteVpc struct {
}

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

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

type validateOpDeleteVpcPeeringConnection struct {
}

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

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

type validateOpDeleteVpnConnection struct {
}

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

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

type validateOpDeleteVpnConnectionRoute struct {
}

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

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

type validateOpDeleteVpnGateway struct {
}

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

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

type validateOpDeprovisionByoipCidr struct {
}

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

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

type validateOpDeprovisionIpamByoasn struct {
}

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

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

type validateOpDeprovisionIpamPoolCidr struct {
}

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

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

type validateOpDeprovisionPublicIpv4PoolCidr struct {
}

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

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

type validateOpDeregisterImage struct {
}

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

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

type validateOpDeregisterInstanceEventNotificationAttributes struct {
}

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

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

type validateOpDescribeByoipCidrs struct {
}

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

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

type validateOpDescribeCapacityBlockExtensionOfferings struct {
}

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

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

type validateOpDescribeCapacityBlockOfferings struct {
}

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

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

type validateOpDescribeCapacityReservationBillingRequests struct {
}

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

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

type validateOpDescribeClientVpnAuthorizationRules struct {
}

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

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

type validateOpDescribeClientVpnConnections struct {
}

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

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

type validateOpDescribeClientVpnRoutes struct {
}

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

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

type validateOpDescribeClientVpnTargetNetworks struct {
}

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

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

type validateOpDescribeFleetHistory struct {
}

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

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

type validateOpDescribeFleetInstances struct {
}

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

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

type validateOpDescribeFpgaImageAttribute struct {
}

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

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

type validateOpDescribeIdentityIdFormat struct {
}

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

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

type validateOpDescribeImageAttribute struct {
}

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

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

type validateOpDescribeInstanceAttribute struct {
}

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

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

type validateOpDescribeNetworkInterfaceAttribute struct {
}

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

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

type validateOpDescribeScheduledInstanceAvailability struct {
}

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

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

type validateOpDescribeSecurityGroupReferences struct {
}

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

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

type validateOpDescribeSnapshotAttribute struct {
}

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

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

type validateOpDescribeSpotFleetInstances struct {
}

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

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

type validateOpDescribeSpotFleetRequestHistory struct {
}

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

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

type validateOpDescribeStaleSecurityGroups struct {
}

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

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

type validateOpDescribeVolumeAttribute struct {
}

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

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

type validateOpDescribeVpcAttribute struct {
}

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

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

type validateOpDescribeVpcEndpointServicePermissions struct {
}

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

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

type validateOpDetachClassicLinkVpc struct {
}

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

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

type validateOpDetachInternetGateway struct {
}

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

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

type validateOpDetachNetworkInterface struct {
}

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

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

type validateOpDetachVerifiedAccessTrustProvider struct {
}

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

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

type validateOpDetachVolume struct {
}

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

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

type validateOpDetachVpnGateway struct {
}

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

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

type validateOpDisableAddressTransfer struct {
}

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

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

type validateOpDisableFastLaunch struct {
}

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

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

type validateOpDisableFastSnapshotRestores struct {
}

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

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

type validateOpDisableImageDeprecation struct {
}

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

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

type validateOpDisableImageDeregistrationProtection struct {
}

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

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

type validateOpDisableImage struct {
}

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

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

type validateOpDisableIpamOrganizationAdminAccount struct {
}

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

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

type validateOpDisableTransitGatewayRouteTablePropagation struct {
}

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

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

type validateOpDisableVgwRoutePropagation struct {
}

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

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

type validateOpDisableVpcClassicLink struct {
}

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

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

type validateOpDisassociateCapacityReservationBillingOwner struct {
}

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

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

type validateOpDisassociateClientVpnTargetNetwork struct {
}

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

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

type validateOpDisassociateEnclaveCertificateIamRole struct {
}

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

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

type validateOpDisassociateIamInstanceProfile struct {
}

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

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

type validateOpDisassociateInstanceEventWindow struct {
}

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

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

type validateOpDisassociateIpamByoasn struct {
}

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

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

type validateOpDisassociateIpamResourceDiscovery struct {
}

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

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

type validateOpDisassociateNatGatewayAddress struct {
}

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

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

type validateOpDisassociateRouteTable struct {
}

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

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

type validateOpDisassociateSecurityGroupVpc struct {
}

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

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

type validateOpDisassociateSubnetCidrBlock struct {
}

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

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

type validateOpDisassociateTransitGatewayMulticastDomain struct {
}

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

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

type validateOpDisassociateTransitGatewayPolicyTable struct {
}

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

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

type validateOpDisassociateTransitGatewayRouteTable struct {
}

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

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

type validateOpDisassociateTrunkInterface struct {
}

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

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

type validateOpDisassociateVpcCidrBlock struct {
}

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

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

type validateOpEnableAddressTransfer struct {
}

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

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

type validateOpEnableAllowedImagesSettings struct {
}

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

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

type validateOpEnableFastLaunch struct {
}

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

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

type validateOpEnableFastSnapshotRestores struct {
}

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

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

type validateOpEnableImageBlockPublicAccess struct {
}

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

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

type validateOpEnableImageDeprecation struct {
}

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

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

type validateOpEnableImageDeregistrationProtection struct {
}

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

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

type validateOpEnableImage struct {
}

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

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

type validateOpEnableIpamOrganizationAdminAccount struct {
}

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

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

type validateOpEnableSnapshotBlockPublicAccess struct {
}

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

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

type validateOpEnableTransitGatewayRouteTablePropagation struct {
}

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

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

type validateOpEnableVgwRoutePropagation struct {
}

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

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

type validateOpEnableVolumeIO struct {
}

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

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

type validateOpEnableVpcClassicLink struct {
}

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

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

type validateOpExportClientVpnClientCertificateRevocationList struct {
}

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

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

type validateOpExportClientVpnClientConfiguration struct {
}

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

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

type validateOpExportImage struct {
}

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

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

type validateOpExportTransitGatewayRoutes struct {
}

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

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

type validateOpExportVerifiedAccessInstanceClientConfiguration struct {
}

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

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

type validateOpGetAssociatedEnclaveCertificateIamRoles struct {
}

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

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

type validateOpGetAssociatedIpv6PoolCidrs struct {
}

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

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

type validateOpGetCapacityReservationUsage struct {
}

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

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

type validateOpGetCoipPoolUsage struct {
}

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

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

type validateOpGetConsoleOutput struct {
}

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

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

type validateOpGetConsoleScreenshot struct {
}

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

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

type validateOpGetDeclarativePoliciesReportSummary struct {
}

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

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

type validateOpGetDefaultCreditSpecification struct {
}

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

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

type validateOpGetFlowLogsIntegrationTemplate struct {
}

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

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

type validateOpGetGroupsForCapacityReservation struct {
}

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

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

type validateOpGetHostReservationPurchasePreview struct {
}

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

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

type validateOpGetInstanceTpmEkPub struct {
}

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

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

type validateOpGetInstanceTypesFromInstanceRequirements struct {
}

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

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

type validateOpGetInstanceUefiData struct {
}

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

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

type validateOpGetIpamAddressHistory struct {
}

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

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

type validateOpGetIpamDiscoveredAccounts struct {
}

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

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

type validateOpGetIpamDiscoveredPublicAddresses struct {
}

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

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

type validateOpGetIpamDiscoveredResourceCidrs struct {
}

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

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

type validateOpGetIpamPoolAllocations struct {
}

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

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

type validateOpGetIpamPoolCidrs struct {
}

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

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

type validateOpGetIpamResourceCidrs struct {
}

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

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

type validateOpGetLaunchTemplateData struct {
}

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

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

type validateOpGetManagedPrefixListAssociations struct {
}

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

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

type validateOpGetManagedPrefixListEntries struct {
}

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

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

type validateOpGetNetworkInsightsAccessScopeAnalysisFindings struct {
}

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

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

type validateOpGetNetworkInsightsAccessScopeContent struct {
}

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

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

type validateOpGetPasswordData struct {
}

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

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

type validateOpGetReservedInstancesExchangeQuote struct {
}

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

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

type validateOpGetSecurityGroupsForVpc struct {
}

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

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

type validateOpGetSpotPlacementScores struct {
}

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

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

type validateOpGetSubnetCidrReservations struct {
}

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

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

type validateOpGetTransitGatewayAttachmentPropagations struct {
}

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

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

type validateOpGetTransitGatewayMulticastDomainAssociations struct {
}

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

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

type validateOpGetTransitGatewayPolicyTableAssociations struct {
}

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

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

type validateOpGetTransitGatewayPolicyTableEntries struct {
}

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

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

type validateOpGetTransitGatewayPrefixListReferences struct {
}

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

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

type validateOpGetTransitGatewayRouteTableAssociations struct {
}

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

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

type validateOpGetTransitGatewayRouteTablePropagations struct {
}

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

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

type validateOpGetVerifiedAccessEndpointPolicy struct {
}

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

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

type validateOpGetVerifiedAccessEndpointTargets struct {
}

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

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

type validateOpGetVerifiedAccessGroupPolicy struct {
}

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

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

type validateOpGetVpnConnectionDeviceSampleConfiguration struct {
}

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

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

type validateOpGetVpnTunnelReplacementStatus struct {
}

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

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

type validateOpImportClientVpnClientCertificateRevocationList struct {
}

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

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

type validateOpImportInstance struct {
}

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

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

type validateOpImportKeyPair struct {
}

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

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

type validateOpImportVolume struct {
}

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

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

type validateOpLockSnapshot struct {
}

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

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

type validateOpModifyAddressAttribute struct {
}

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

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

type validateOpModifyAvailabilityZoneGroup struct {
}

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

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

type validateOpModifyCapacityReservationFleet struct {
}

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

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

type validateOpModifyCapacityReservation struct {
}

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

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

type validateOpModifyClientVpnEndpoint struct {
}

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

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

type validateOpModifyDefaultCreditSpecification struct {
}

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

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

type validateOpModifyEbsDefaultKmsKeyId struct {
}

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

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

type validateOpModifyFleet struct {
}

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

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

type validateOpModifyFpgaImageAttribute struct {
}

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

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

type validateOpModifyHosts struct {
}

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

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

type validateOpModifyIdentityIdFormat struct {
}

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

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

type validateOpModifyIdFormat struct {
}

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

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

type validateOpModifyImageAttribute struct {
}

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

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

type validateOpModifyInstanceAttribute struct {
}

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

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

type validateOpModifyInstanceCapacityReservationAttributes struct {
}

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

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

type validateOpModifyInstanceCpuOptions struct {
}

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

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

type validateOpModifyInstanceCreditSpecification struct {
}

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

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

type validateOpModifyInstanceEventStartTime struct {
}

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

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

type validateOpModifyInstanceEventWindow struct {
}

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

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

type validateOpModifyInstanceMaintenanceOptions struct {
}

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

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

type validateOpModifyInstanceMetadataOptions struct {
}

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

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

type validateOpModifyInstancePlacement struct {
}

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

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

type validateOpModifyIpam struct {
}

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

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

type validateOpModifyIpamPool struct {
}

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

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

type validateOpModifyIpamResourceCidr struct {
}

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

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

type validateOpModifyIpamResourceDiscovery struct {
}

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

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

type validateOpModifyIpamScope struct {
}

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

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

type validateOpModifyLocalGatewayRoute struct {
}

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

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

type validateOpModifyManagedPrefixList struct {
}

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

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

type validateOpModifyNetworkInterfaceAttribute struct {
}

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

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

type validateOpModifyPrivateDnsNameOptions struct {
}

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

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

type validateOpModifyReservedInstances struct {
}

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

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

type validateOpModifySecurityGroupRules struct {
}

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

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

type validateOpModifySnapshotAttribute struct {
}

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

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

type validateOpModifySnapshotTier struct {
}

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

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

type validateOpModifySpotFleetRequest struct {
}

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

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

type validateOpModifySubnetAttribute struct {
}

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

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

type validateOpModifyTrafficMirrorFilterNetworkServices struct {
}

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

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

type validateOpModifyTrafficMirrorFilterRule struct {
}

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

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

type validateOpModifyTrafficMirrorSession struct {
}

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

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

type validateOpModifyTransitGateway struct {
}

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

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

type validateOpModifyTransitGatewayPrefixListReference struct {
}

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

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

type validateOpModifyTransitGatewayVpcAttachment struct {
}

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

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

type validateOpModifyVerifiedAccessEndpoint struct {
}

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

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

type validateOpModifyVerifiedAccessEndpointPolicy struct {
}

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

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

type validateOpModifyVerifiedAccessGroup struct {
}

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

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

type validateOpModifyVerifiedAccessGroupPolicy struct {
}

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

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

type validateOpModifyVerifiedAccessInstance struct {
}

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

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

type validateOpModifyVerifiedAccessInstanceLoggingConfiguration struct {
}

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

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

type validateOpModifyVerifiedAccessTrustProvider struct {
}

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

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

type validateOpModifyVolumeAttribute struct {
}

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

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

type validateOpModifyVolume struct {
}

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

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

type validateOpModifyVpcAttribute struct {
}

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

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

type validateOpModifyVpcBlockPublicAccessExclusion struct {
}

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

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

type validateOpModifyVpcBlockPublicAccessOptions struct {
}

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

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

type validateOpModifyVpcEndpointConnectionNotification struct {
}

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

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

type validateOpModifyVpcEndpoint struct {
}

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

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

type validateOpModifyVpcEndpointServiceConfiguration struct {
}

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

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

type validateOpModifyVpcEndpointServicePayerResponsibility struct {
}

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

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

type validateOpModifyVpcEndpointServicePermissions struct {
}

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

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

type validateOpModifyVpcPeeringConnectionOptions struct {
}

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

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

type validateOpModifyVpcTenancy struct {
}

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

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

type validateOpModifyVpnConnection struct {
}

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

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

type validateOpModifyVpnConnectionOptions struct {
}

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

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

type validateOpModifyVpnTunnelCertificate struct {
}

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

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

type validateOpModifyVpnTunnelOptions struct {
}

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

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

type validateOpMonitorInstances struct {
}

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

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

type validateOpMoveAddressToVpc struct {
}

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

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

type validateOpMoveByoipCidrToIpam struct {
}

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

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

type validateOpMoveCapacityReservationInstances struct {
}

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

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

type validateOpProvisionByoipCidr struct {
}

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

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

type validateOpProvisionIpamByoasn struct {
}

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

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

type validateOpProvisionIpamPoolCidr struct {
}

func (*validateOpProvisionIpamPoolCidr) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpProvisionIpamPoolCidr) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ProvisionIpamPoolCidrInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpProvisionIpamPoolCidrInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpProvisionPublicIpv4PoolCidr struct {
}

func (*validateOpProvisionPublicIpv4PoolCidr) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpProvisionPublicIpv4PoolCidr) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ProvisionPublicIpv4PoolCidrInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpProvisionPublicIpv4PoolCidrInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPurchaseCapacityBlockExtension struct {
}

func (*validateOpPurchaseCapacityBlockExtension) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPurchaseCapacityBlockExtension) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PurchaseCapacityBlockExtensionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPurchaseCapacityBlockExtensionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPurchaseCapacityBlock struct {
}

func (*validateOpPurchaseCapacityBlock) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPurchaseCapacityBlock) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PurchaseCapacityBlockInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPurchaseCapacityBlockInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPurchaseHostReservation struct {
}

func (*validateOpPurchaseHostReservation) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPurchaseHostReservation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PurchaseHostReservationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPurchaseHostReservationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPurchaseReservedInstancesOffering struct {
}

func (*validateOpPurchaseReservedInstancesOffering) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPurchaseReservedInstancesOffering) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PurchaseReservedInstancesOfferingInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPurchaseReservedInstancesOfferingInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPurchaseScheduledInstances struct {
}

func (*validateOpPurchaseScheduledInstances) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPurchaseScheduledInstances) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PurchaseScheduledInstancesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPurchaseScheduledInstancesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRebootInstances struct {
}

func (*validateOpRebootInstances) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRebootInstances) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RebootInstancesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRebootInstancesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRegisterImage struct {
}

func (*validateOpRegisterImage) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRegisterImage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RegisterImageInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRegisterImageInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRegisterInstanceEventNotificationAttributes struct {
}

func (*validateOpRegisterInstanceEventNotificationAttributes) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRegisterInstanceEventNotificationAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RegisterInstanceEventNotificationAttributesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRegisterInstanceEventNotificationAttributesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRegisterTransitGatewayMulticastGroupMembers struct {
}

func (*validateOpRegisterTransitGatewayMulticastGroupMembers) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRegisterTransitGatewayMulticastGroupMembers) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RegisterTransitGatewayMulticastGroupMembersInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRegisterTransitGatewayMulticastGroupMembersInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRegisterTransitGatewayMulticastGroupSources struct {
}

func (*validateOpRegisterTransitGatewayMulticastGroupSources) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRegisterTransitGatewayMulticastGroupSources) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RegisterTransitGatewayMulticastGroupSourcesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRegisterTransitGatewayMulticastGroupSourcesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRejectCapacityReservationBillingOwnership struct {
}

func (*validateOpRejectCapacityReservationBillingOwnership) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRejectCapacityReservationBillingOwnership) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RejectCapacityReservationBillingOwnershipInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRejectCapacityReservationBillingOwnershipInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRejectTransitGatewayPeeringAttachment struct {
}

func (*validateOpRejectTransitGatewayPeeringAttachment) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRejectTransitGatewayPeeringAttachment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RejectTransitGatewayPeeringAttachmentInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRejectTransitGatewayPeeringAttachmentInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRejectTransitGatewayVpcAttachment struct {
}

func (*validateOpRejectTransitGatewayVpcAttachment) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRejectTransitGatewayVpcAttachment) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RejectTransitGatewayVpcAttachmentInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRejectTransitGatewayVpcAttachmentInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRejectVpcEndpointConnections struct {
}

func (*validateOpRejectVpcEndpointConnections) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRejectVpcEndpointConnections) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RejectVpcEndpointConnectionsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRejectVpcEndpointConnectionsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRejectVpcPeeringConnection struct {
}

func (*validateOpRejectVpcPeeringConnection) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRejectVpcPeeringConnection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RejectVpcPeeringConnectionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRejectVpcPeeringConnectionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpReleaseHosts struct {
}

func (*validateOpReleaseHosts) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpReleaseHosts) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ReleaseHostsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpReleaseHostsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpReleaseIpamPoolAllocation struct {
}

func (*validateOpReleaseIpamPoolAllocation) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpReleaseIpamPoolAllocation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ReleaseIpamPoolAllocationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpReleaseIpamPoolAllocationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpReplaceIamInstanceProfileAssociation struct {
}

func (*validateOpReplaceIamInstanceProfileAssociation) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpReplaceIamInstanceProfileAssociation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ReplaceIamInstanceProfileAssociationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpReplaceIamInstanceProfileAssociationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpReplaceNetworkAclAssociation struct {
}

func (*validateOpReplaceNetworkAclAssociation) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpReplaceNetworkAclAssociation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ReplaceNetworkAclAssociationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpReplaceNetworkAclAssociationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpReplaceNetworkAclEntry struct {
}

func (*validateOpReplaceNetworkAclEntry) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpReplaceNetworkAclEntry) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ReplaceNetworkAclEntryInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpReplaceNetworkAclEntryInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpReplaceRoute struct {
}

func (*validateOpReplaceRoute) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpReplaceRoute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ReplaceRouteInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpReplaceRouteInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpReplaceRouteTableAssociation struct {
}

func (*validateOpReplaceRouteTableAssociation) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpReplaceRouteTableAssociation) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ReplaceRouteTableAssociationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpReplaceRouteTableAssociationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpReplaceTransitGatewayRoute struct {
}

func (*validateOpReplaceTransitGatewayRoute) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpReplaceTransitGatewayRoute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ReplaceTransitGatewayRouteInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpReplaceTransitGatewayRouteInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpReplaceVpnTunnel struct {
}

func (*validateOpReplaceVpnTunnel) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpReplaceVpnTunnel) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ReplaceVpnTunnelInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpReplaceVpnTunnelInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpReportInstanceStatus struct {
}

func (*validateOpReportInstanceStatus) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpReportInstanceStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ReportInstanceStatusInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpReportInstanceStatusInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRequestSpotFleet struct {
}

func (*validateOpRequestSpotFleet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRequestSpotFleet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RequestSpotFleetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRequestSpotFleetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRequestSpotInstances struct {
}

func (*validateOpRequestSpotInstances) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRequestSpotInstances) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RequestSpotInstancesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRequestSpotInstancesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpResetAddressAttribute struct {
}

func (*validateOpResetAddressAttribute) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpResetAddressAttribute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ResetAddressAttributeInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpResetAddressAttributeInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpResetFpgaImageAttribute struct {
}

func (*validateOpResetFpgaImageAttribute) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpResetFpgaImageAttribute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ResetFpgaImageAttributeInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpResetFpgaImageAttributeInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpResetImageAttribute struct {
}

func (*validateOpResetImageAttribute) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpResetImageAttribute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ResetImageAttributeInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpResetImageAttributeInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpResetInstanceAttribute struct {
}

func (*validateOpResetInstanceAttribute) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpResetInstanceAttribute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ResetInstanceAttributeInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpResetInstanceAttributeInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpResetNetworkInterfaceAttribute struct {
}

func (*validateOpResetNetworkInterfaceAttribute) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpResetNetworkInterfaceAttribute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ResetNetworkInterfaceAttributeInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpResetNetworkInterfaceAttributeInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpResetSnapshotAttribute struct {
}

func (*validateOpResetSnapshotAttribute) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpResetSnapshotAttribute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ResetSnapshotAttributeInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpResetSnapshotAttributeInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRestoreAddressToClassic struct {
}

func (*validateOpRestoreAddressToClassic) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRestoreAddressToClassic) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RestoreAddressToClassicInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRestoreAddressToClassicInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRestoreImageFromRecycleBin struct {
}

func (*validateOpRestoreImageFromRecycleBin) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRestoreImageFromRecycleBin) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RestoreImageFromRecycleBinInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRestoreImageFromRecycleBinInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRestoreManagedPrefixListVersion struct {
}

func (*validateOpRestoreManagedPrefixListVersion) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRestoreManagedPrefixListVersion) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RestoreManagedPrefixListVersionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRestoreManagedPrefixListVersionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRestoreSnapshotFromRecycleBin struct {
}

func (*validateOpRestoreSnapshotFromRecycleBin) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRestoreSnapshotFromRecycleBin) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RestoreSnapshotFromRecycleBinInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRestoreSnapshotFromRecycleBinInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRestoreSnapshotTier struct {
}

func (*validateOpRestoreSnapshotTier) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRestoreSnapshotTier) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RestoreSnapshotTierInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRestoreSnapshotTierInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRevokeClientVpnIngress struct {
}

func (*validateOpRevokeClientVpnIngress) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRevokeClientVpnIngress) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RevokeClientVpnIngressInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRevokeClientVpnIngressInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRevokeSecurityGroupEgress struct {
}

func (*validateOpRevokeSecurityGroupEgress) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRevokeSecurityGroupEgress) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RevokeSecurityGroupEgressInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRevokeSecurityGroupEgressInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRunInstances struct {
}

func (*validateOpRunInstances) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRunInstances) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RunInstancesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRunInstancesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRunScheduledInstances struct {
}

func (*validateOpRunScheduledInstances) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRunScheduledInstances) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RunScheduledInstancesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRunScheduledInstancesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSearchLocalGatewayRoutes struct {
}

func (*validateOpSearchLocalGatewayRoutes) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSearchLocalGatewayRoutes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SearchLocalGatewayRoutesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSearchLocalGatewayRoutesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSearchTransitGatewayMulticastGroups struct {
}

func (*validateOpSearchTransitGatewayMulticastGroups) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSearchTransitGatewayMulticastGroups) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SearchTransitGatewayMulticastGroupsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSearchTransitGatewayMulticastGroupsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSearchTransitGatewayRoutes struct {
}

func (*validateOpSearchTransitGatewayRoutes) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSearchTransitGatewayRoutes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SearchTransitGatewayRoutesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSearchTransitGatewayRoutesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSendDiagnosticInterrupt struct {
}

func (*validateOpSendDiagnosticInterrupt) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSendDiagnosticInterrupt) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SendDiagnosticInterruptInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSendDiagnosticInterruptInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpStartDeclarativePoliciesReport struct {
}

func (*validateOpStartDeclarativePoliciesReport) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpStartDeclarativePoliciesReport) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*StartDeclarativePoliciesReportInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpStartDeclarativePoliciesReportInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpStartInstances struct {
}

func (*validateOpStartInstances) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpStartInstances) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*StartInstancesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpStartInstancesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpStartNetworkInsightsAccessScopeAnalysis struct {
}

func (*validateOpStartNetworkInsightsAccessScopeAnalysis) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpStartNetworkInsightsAccessScopeAnalysis) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*StartNetworkInsightsAccessScopeAnalysisInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpStartNetworkInsightsAccessScopeAnalysisInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpStartNetworkInsightsAnalysis struct {
}

func (*validateOpStartNetworkInsightsAnalysis) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpStartNetworkInsightsAnalysis) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*StartNetworkInsightsAnalysisInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpStartNetworkInsightsAnalysisInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpStartVpcEndpointServicePrivateDnsVerification struct {
}

func (*validateOpStartVpcEndpointServicePrivateDnsVerification) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpStartVpcEndpointServicePrivateDnsVerification) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*StartVpcEndpointServicePrivateDnsVerificationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpStartVpcEndpointServicePrivateDnsVerificationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpStopInstances struct {
}

func (*validateOpStopInstances) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpStopInstances) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*StopInstancesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpStopInstancesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpTerminateClientVpnConnections struct {
}

func (*validateOpTerminateClientVpnConnections) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpTerminateClientVpnConnections) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*TerminateClientVpnConnectionsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpTerminateClientVpnConnectionsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpTerminateInstances struct {
}

func (*validateOpTerminateInstances) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpTerminateInstances) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*TerminateInstancesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpTerminateInstancesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUnassignIpv6Addresses struct {
}

func (*validateOpUnassignIpv6Addresses) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUnassignIpv6Addresses) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UnassignIpv6AddressesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUnassignIpv6AddressesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUnassignPrivateIpAddresses struct {
}

func (*validateOpUnassignPrivateIpAddresses) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUnassignPrivateIpAddresses) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UnassignPrivateIpAddressesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUnassignPrivateIpAddressesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUnassignPrivateNatGatewayAddress struct {
}

func (*validateOpUnassignPrivateNatGatewayAddress) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUnassignPrivateNatGatewayAddress) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UnassignPrivateNatGatewayAddressInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUnassignPrivateNatGatewayAddressInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUnlockSnapshot struct {
}

func (*validateOpUnlockSnapshot) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUnlockSnapshot) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UnlockSnapshotInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUnlockSnapshotInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUnmonitorInstances struct {
}

func (*validateOpUnmonitorInstances) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUnmonitorInstances) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UnmonitorInstancesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUnmonitorInstancesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpWithdrawByoipCidr struct {
}

func (*validateOpWithdrawByoipCidr) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpWithdrawByoipCidr) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*WithdrawByoipCidrInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpWithdrawByoipCidrInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

func addOpAcceptAddressTransferValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAcceptAddressTransfer{}, middleware.After)
}

func addOpAcceptCapacityReservationBillingOwnershipValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAcceptCapacityReservationBillingOwnership{}, middleware.After)
}

func addOpAcceptReservedInstancesExchangeQuoteValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAcceptReservedInstancesExchangeQuote{}, middleware.After)
}

func addOpAcceptTransitGatewayPeeringAttachmentValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAcceptTransitGatewayPeeringAttachment{}, middleware.After)
}

func addOpAcceptTransitGatewayVpcAttachmentValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAcceptTransitGatewayVpcAttachment{}, middleware.After)
}

func addOpAcceptVpcEndpointConnectionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAcceptVpcEndpointConnections{}, middleware.After)
}

func addOpAcceptVpcPeeringConnectionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAcceptVpcPeeringConnection{}, middleware.After)
}

func addOpAdvertiseByoipCidrValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdvertiseByoipCidr{}, middleware.After)
}

func addOpAllocateHostsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAllocateHosts{}, middleware.After)
}

func addOpAllocateIpamPoolCidrValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAllocateIpamPoolCidr{}, middleware.After)
}

func addOpApplySecurityGroupsToClientVpnTargetNetworkValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpApplySecurityGroupsToClientVpnTargetNetwork{}, middleware.After)
}

func addOpAssignIpv6AddressesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssignIpv6Addresses{}, middleware.After)
}

func addOpAssignPrivateIpAddressesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssignPrivateIpAddresses{}, middleware.After)
}

func addOpAssignPrivateNatGatewayAddressValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssignPrivateNatGatewayAddress{}, middleware.After)
}

func addOpAssociateCapacityReservationBillingOwnerValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateCapacityReservationBillingOwner{}, middleware.After)
}

func addOpAssociateClientVpnTargetNetworkValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateClientVpnTargetNetwork{}, middleware.After)
}

func addOpAssociateDhcpOptionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateDhcpOptions{}, middleware.After)
}

func addOpAssociateEnclaveCertificateIamRoleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateEnclaveCertificateIamRole{}, middleware.After)
}

func addOpAssociateIamInstanceProfileValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateIamInstanceProfile{}, middleware.After)
}

func addOpAssociateInstanceEventWindowValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateInstanceEventWindow{}, middleware.After)
}

func addOpAssociateIpamByoasnValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateIpamByoasn{}, middleware.After)
}

func addOpAssociateIpamResourceDiscoveryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateIpamResourceDiscovery{}, middleware.After)
}

func addOpAssociateNatGatewayAddressValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateNatGatewayAddress{}, middleware.After)
}

func addOpAssociateRouteTableValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateRouteTable{}, middleware.After)
}

func addOpAssociateSecurityGroupVpcValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateSecurityGroupVpc{}, middleware.After)
}

func addOpAssociateSubnetCidrBlockValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateSubnetCidrBlock{}, middleware.After)
}

func addOpAssociateTransitGatewayMulticastDomainValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateTransitGatewayMulticastDomain{}, middleware.After)
}

func addOpAssociateTransitGatewayPolicyTableValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateTransitGatewayPolicyTable{}, middleware.After)
}

func addOpAssociateTransitGatewayRouteTableValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateTransitGatewayRouteTable{}, middleware.After)
}

func addOpAssociateTrunkInterfaceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateTrunkInterface{}, middleware.After)
}

func addOpAssociateVpcCidrBlockValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateVpcCidrBlock{}, middleware.After)
}

func addOpAttachClassicLinkVpcValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAttachClassicLinkVpc{}, middleware.After)
}

func addOpAttachInternetGatewayValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAttachInternetGateway{}, middleware.After)
}

func addOpAttachNetworkInterfaceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAttachNetworkInterface{}, middleware.After)
}

func addOpAttachVerifiedAccessTrustProviderValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAttachVerifiedAccessTrustProvider{}, middleware.After)
}

func addOpAttachVolumeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAttachVolume{}, middleware.After)
}

func addOpAttachVpnGatewayValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAttachVpnGateway{}, middleware.After)
}

func addOpAuthorizeClientVpnIngressValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAuthorizeClientVpnIngress{}, middleware.After)
}

func addOpAuthorizeSecurityGroupEgressValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAuthorizeSecurityGroupEgress{}, middleware.After)
}

func addOpBundleInstanceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpBundleInstance{}, middleware.After)
}

func addOpCancelBundleTaskValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCancelBundleTask{}, middleware.After)
}

func addOpCancelCapacityReservationFleetsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCancelCapacityReservationFleets{}, middleware.After)
}

func addOpCancelCapacityReservationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCancelCapacityReservation{}, middleware.After)
}

func addOpCancelConversionTaskValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCancelConversionTask{}, middleware.After)
}

func addOpCancelDeclarativePoliciesReportValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCancelDeclarativePoliciesReport{}, middleware.After)
}

func addOpCancelExportTaskValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCancelExportTask{}, middleware.After)
}

func addOpCancelImageLaunchPermissionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCancelImageLaunchPermission{}, middleware.After)
}

func addOpCancelReservedInstancesListingValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCancelReservedInstancesListing{}, middleware.After)
}

func addOpCancelSpotFleetRequestsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCancelSpotFleetRequests{}, middleware.After)
}

func addOpCancelSpotInstanceRequestsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCancelSpotInstanceRequests{}, middleware.After)
}

func addOpConfirmProductInstanceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpConfirmProductInstance{}, middleware.After)
}

func addOpCopyFpgaImageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCopyFpgaImage{}, middleware.After)
}

func addOpCopyImageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCopyImage{}, middleware.After)
}

func addOpCopySnapshotValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCopySnapshot{}, middleware.After)
}

func addOpCreateCapacityReservationBySplittingValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateCapacityReservationBySplitting{}, middleware.After)
}

func addOpCreateCapacityReservationFleetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateCapacityReservationFleet{}, middleware.After)
}

func addOpCreateCapacityReservationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateCapacityReservation{}, middleware.After)
}

func addOpCreateCarrierGatewayValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateCarrierGateway{}, middleware.After)
}

func addOpCreateClientVpnEndpointValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateClientVpnEndpoint{}, middleware.After)
}

func addOpCreateClientVpnRouteValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateClientVpnRoute{}, middleware.After)
}

func addOpCreateCoipCidrValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateCoipCidr{}, middleware.After)
}

func addOpCreateCoipPoolValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateCoipPool{}, middleware.After)
}

func addOpCreateCustomerGatewayValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateCustomerGateway{}, middleware.After)
}

func addOpCreateDefaultSubnetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateDefaultSubnet{}, middleware.After)
}

func addOpCreateDhcpOptionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateDhcpOptions{}, middleware.After)
}

func addOpCreateEgressOnlyInternetGatewayValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateEgressOnlyInternetGateway{}, middleware.After)
}

func addOpCreateFleetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateFleet{}, middleware.After)
}

func addOpCreateFlowLogsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateFlowLogs{}, middleware.After)
}

func addOpCreateFpgaImageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateFpgaImage{}, middleware.After)
}

func addOpCreateImageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateImage{}, middleware.After)
}

func addOpCreateInstanceConnectEndpointValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateInstanceConnectEndpoint{}, middleware.After)
}

func addOpCreateInstanceExportTaskValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateInstanceExportTask{}, middleware.After)
}

func addOpCreateIpamExternalResourceVerificationTokenValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateIpamExternalResourceVerificationToken{}, middleware.After)
}

func addOpCreateIpamPoolValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateIpamPool{}, middleware.After)
}

func addOpCreateIpamScopeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateIpamScope{}, middleware.After)
}

func addOpCreateKeyPairValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateKeyPair{}, middleware.After)
}

func addOpCreateLaunchTemplateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateLaunchTemplate{}, middleware.After)
}

func addOpCreateLaunchTemplateVersionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateLaunchTemplateVersion{}, middleware.After)
}

func addOpCreateLocalGatewayRouteValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateLocalGatewayRoute{}, middleware.After)
}

func addOpCreateLocalGatewayRouteTableValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateLocalGatewayRouteTable{}, middleware.After)
}

func addOpCreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation{}, middleware.After)
}

func addOpCreateLocalGatewayRouteTableVpcAssociationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateLocalGatewayRouteTableVpcAssociation{}, middleware.After)
}

func addOpCreateManagedPrefixListValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateManagedPrefixList{}, middleware.After)
}

func addOpCreateNatGatewayValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateNatGateway{}, middleware.After)
}

func addOpCreateNetworkAclEntryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateNetworkAclEntry{}, middleware.After)
}

func addOpCreateNetworkAclValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateNetworkAcl{}, middleware.After)
}

func addOpCreateNetworkInsightsAccessScopeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateNetworkInsightsAccessScope{}, middleware.After)
}

func addOpCreateNetworkInsightsPathValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateNetworkInsightsPath{}, middleware.After)
}

func addOpCreateNetworkInterfaceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateNetworkInterface{}, middleware.After)
}

func addOpCreateNetworkInterfacePermissionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateNetworkInterfacePermission{}, middleware.After)
}

func addOpCreateReplaceRootVolumeTaskValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateReplaceRootVolumeTask{}, middleware.After)
}

func addOpCreateReservedInstancesListingValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateReservedInstancesListing{}, middleware.After)
}

func addOpCreateRestoreImageTaskValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateRestoreImageTask{}, middleware.After)
}

func addOpCreateRouteValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateRoute{}, middleware.After)
}

func addOpCreateRouteTableValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateRouteTable{}, middleware.After)
}

func addOpCreateSecurityGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateSecurityGroup{}, middleware.After)
}

func addOpCreateSnapshotValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateSnapshot{}, middleware.After)
}

func addOpCreateSnapshotsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateSnapshots{}, middleware.After)
}

func addOpCreateSpotDatafeedSubscriptionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateSpotDatafeedSubscription{}, middleware.After)
}

func addOpCreateStoreImageTaskValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateStoreImageTask{}, middleware.After)
}

func addOpCreateSubnetCidrReservationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateSubnetCidrReservation{}, middleware.After)
}

func addOpCreateSubnetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateSubnet{}, middleware.After)
}

func addOpCreateTagsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateTags{}, middleware.After)
}

func addOpCreateTrafficMirrorFilterRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateTrafficMirrorFilterRule{}, middleware.After)
}

func addOpCreateTrafficMirrorSessionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateTrafficMirrorSession{}, middleware.After)
}

func addOpCreateTransitGatewayConnectValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateTransitGatewayConnect{}, middleware.After)
}

func addOpCreateTransitGatewayConnectPeerValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateTransitGatewayConnectPeer{}, middleware.After)
}

func addOpCreateTransitGatewayMulticastDomainValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateTransitGatewayMulticastDomain{}, middleware.After)
}

func addOpCreateTransitGatewayPeeringAttachmentValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateTransitGatewayPeeringAttachment{}, middleware.After)
}

func addOpCreateTransitGatewayPolicyTableValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateTransitGatewayPolicyTable{}, middleware.After)
}

func addOpCreateTransitGatewayPrefixListReferenceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateTransitGatewayPrefixListReference{}, middleware.After)
}

func addOpCreateTransitGatewayRouteValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateTransitGatewayRoute{}, middleware.After)
}

func addOpCreateTransitGatewayRouteTableAnnouncementValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateTransitGatewayRouteTableAnnouncement{}, middleware.After)
}

func addOpCreateTransitGatewayRouteTableValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateTransitGatewayRouteTable{}, middleware.After)
}

func addOpCreateTransitGatewayVpcAttachmentValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateTransitGatewayVpcAttachment{}, middleware.After)
}

func addOpCreateVerifiedAccessEndpointValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateVerifiedAccessEndpoint{}, middleware.After)
}

func addOpCreateVerifiedAccessGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateVerifiedAccessGroup{}, middleware.After)
}

func addOpCreateVerifiedAccessTrustProviderValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateVerifiedAccessTrustProvider{}, middleware.After)
}

func addOpCreateVolumeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateVolume{}, middleware.After)
}

func addOpCreateVpcBlockPublicAccessExclusionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateVpcBlockPublicAccessExclusion{}, middleware.After)
}

func addOpCreateVpcEndpointConnectionNotificationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateVpcEndpointConnectionNotification{}, middleware.After)
}

func addOpCreateVpcEndpointValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateVpcEndpoint{}, middleware.After)
}

func addOpCreateVpcPeeringConnectionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateVpcPeeringConnection{}, middleware.After)
}

func addOpCreateVpnConnectionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateVpnConnection{}, middleware.After)
}

func addOpCreateVpnConnectionRouteValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateVpnConnectionRoute{}, middleware.After)
}

func addOpCreateVpnGatewayValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateVpnGateway{}, middleware.After)
}

func addOpDeleteCarrierGatewayValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteCarrierGateway{}, middleware.After)
}

func addOpDeleteClientVpnEndpointValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteClientVpnEndpoint{}, middleware.After)
}

func addOpDeleteClientVpnRouteValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteClientVpnRoute{}, middleware.After)
}

func addOpDeleteCoipCidrValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteCoipCidr{}, middleware.After)
}

func addOpDeleteCoipPoolValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteCoipPool{}, middleware.After)
}

func addOpDeleteCustomerGatewayValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteCustomerGateway{}, middleware.After)
}

func addOpDeleteDhcpOptionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteDhcpOptions{}, middleware.After)
}

func addOpDeleteEgressOnlyInternetGatewayValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteEgressOnlyInternetGateway{}, middleware.After)
}

func addOpDeleteFleetsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteFleets{}, middleware.After)
}

func addOpDeleteFlowLogsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteFlowLogs{}, middleware.After)
}

func addOpDeleteFpgaImageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteFpgaImage{}, middleware.After)
}

func addOpDeleteInstanceConnectEndpointValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteInstanceConnectEndpoint{}, middleware.After)
}

func addOpDeleteInstanceEventWindowValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteInstanceEventWindow{}, middleware.After)
}

func addOpDeleteInternetGatewayValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteInternetGateway{}, middleware.After)
}

func addOpDeleteIpamExternalResourceVerificationTokenValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteIpamExternalResourceVerificationToken{}, middleware.After)
}

func addOpDeleteIpamValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteIpam{}, middleware.After)
}

func addOpDeleteIpamPoolValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteIpamPool{}, middleware.After)
}

func addOpDeleteIpamResourceDiscoveryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteIpamResourceDiscovery{}, middleware.After)
}

func addOpDeleteIpamScopeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteIpamScope{}, middleware.After)
}

func addOpDeleteLaunchTemplateVersionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteLaunchTemplateVersions{}, middleware.After)
}

func addOpDeleteLocalGatewayRouteValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteLocalGatewayRoute{}, middleware.After)
}

func addOpDeleteLocalGatewayRouteTableValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteLocalGatewayRouteTable{}, middleware.After)
}

func addOpDeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation{}, middleware.After)
}

func addOpDeleteLocalGatewayRouteTableVpcAssociationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteLocalGatewayRouteTableVpcAssociation{}, middleware.After)
}

func addOpDeleteManagedPrefixListValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteManagedPrefixList{}, middleware.After)
}

func addOpDeleteNatGatewayValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteNatGateway{}, middleware.After)
}

func addOpDeleteNetworkAclEntryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteNetworkAclEntry{}, middleware.After)
}

func addOpDeleteNetworkAclValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteNetworkAcl{}, middleware.After)
}

func addOpDeleteNetworkInsightsAccessScopeAnalysisValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteNetworkInsightsAccessScopeAnalysis{}, middleware.After)
}

func addOpDeleteNetworkInsightsAccessScopeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteNetworkInsightsAccessScope{}, middleware.After)
}

func addOpDeleteNetworkInsightsAnalysisValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteNetworkInsightsAnalysis{}, middleware.After)
}

func addOpDeleteNetworkInsightsPathValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteNetworkInsightsPath{}, middleware.After)
}

func addOpDeleteNetworkInterfaceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteNetworkInterface{}, middleware.After)
}

func addOpDeleteNetworkInterfacePermissionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteNetworkInterfacePermission{}, middleware.After)
}

func addOpDeletePlacementGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeletePlacementGroup{}, middleware.After)
}

func addOpDeletePublicIpv4PoolValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeletePublicIpv4Pool{}, middleware.After)
}

func addOpDeleteQueuedReservedInstancesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteQueuedReservedInstances{}, middleware.After)
}

func addOpDeleteRouteValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteRoute{}, middleware.After)
}

func addOpDeleteRouteTableValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteRouteTable{}, middleware.After)
}

func addOpDeleteSnapshotValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteSnapshot{}, middleware.After)
}

func addOpDeleteSubnetCidrReservationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteSubnetCidrReservation{}, middleware.After)
}

func addOpDeleteSubnetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteSubnet{}, middleware.After)
}

func addOpDeleteTagsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteTags{}, middleware.After)
}

func addOpDeleteTrafficMirrorFilterValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteTrafficMirrorFilter{}, middleware.After)
}

func addOpDeleteTrafficMirrorFilterRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteTrafficMirrorFilterRule{}, middleware.After)
}

func addOpDeleteTrafficMirrorSessionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteTrafficMirrorSession{}, middleware.After)
}

func addOpDeleteTrafficMirrorTargetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteTrafficMirrorTarget{}, middleware.After)
}

func addOpDeleteTransitGatewayConnectValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteTransitGatewayConnect{}, middleware.After)
}

func addOpDeleteTransitGatewayConnectPeerValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteTransitGatewayConnectPeer{}, middleware.After)
}

func addOpDeleteTransitGatewayValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteTransitGateway{}, middleware.After)
}

func addOpDeleteTransitGatewayMulticastDomainValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteTransitGatewayMulticastDomain{}, middleware.After)
}

func addOpDeleteTransitGatewayPeeringAttachmentValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteTransitGatewayPeeringAttachment{}, middleware.After)
}

func addOpDeleteTransitGatewayPolicyTableValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteTransitGatewayPolicyTable{}, middleware.After)
}

func addOpDeleteTransitGatewayPrefixListReferenceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteTransitGatewayPrefixListReference{}, middleware.After)
}

func addOpDeleteTransitGatewayRouteValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteTransitGatewayRoute{}, middleware.After)
}

func addOpDeleteTransitGatewayRouteTableAnnouncementValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteTransitGatewayRouteTableAnnouncement{}, middleware.After)
}

func addOpDeleteTransitGatewayRouteTableValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteTransitGatewayRouteTable{}, middleware.After)
}

func addOpDeleteTransitGatewayVpcAttachmentValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteTransitGatewayVpcAttachment{}, middleware.After)
}

func addOpDeleteVerifiedAccessEndpointValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteVerifiedAccessEndpoint{}, middleware.After)
}

func addOpDeleteVerifiedAccessGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteVerifiedAccessGroup{}, middleware.After)
}

func addOpDeleteVerifiedAccessInstanceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteVerifiedAccessInstance{}, middleware.After)
}

func addOpDeleteVerifiedAccessTrustProviderValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteVerifiedAccessTrustProvider{}, middleware.After)
}

func addOpDeleteVolumeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteVolume{}, middleware.After)
}

func addOpDeleteVpcBlockPublicAccessExclusionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteVpcBlockPublicAccessExclusion{}, middleware.After)
}

func addOpDeleteVpcEndpointConnectionNotificationsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteVpcEndpointConnectionNotifications{}, middleware.After)
}

func addOpDeleteVpcEndpointServiceConfigurationsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteVpcEndpointServiceConfigurations{}, middleware.After)
}

func addOpDeleteVpcEndpointsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteVpcEndpoints{}, middleware.After)
}

func addOpDeleteVpcValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteVpc{}, middleware.After)
}

func addOpDeleteVpcPeeringConnectionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteVpcPeeringConnection{}, middleware.After)
}

func addOpDeleteVpnConnectionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteVpnConnection{}, middleware.After)
}

func addOpDeleteVpnConnectionRouteValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteVpnConnectionRoute{}, middleware.After)
}

func addOpDeleteVpnGatewayValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteVpnGateway{}, middleware.After)
}

func addOpDeprovisionByoipCidrValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeprovisionByoipCidr{}, middleware.After)
}

func addOpDeprovisionIpamByoasnValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeprovisionIpamByoasn{}, middleware.After)
}

func addOpDeprovisionIpamPoolCidrValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeprovisionIpamPoolCidr{}, middleware.After)
}

func addOpDeprovisionPublicIpv4PoolCidrValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeprovisionPublicIpv4PoolCidr{}, middleware.After)
}

func addOpDeregisterImageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeregisterImage{}, middleware.After)
}

func addOpDeregisterInstanceEventNotificationAttributesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeregisterInstanceEventNotificationAttributes{}, middleware.After)
}

func addOpDescribeByoipCidrsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeByoipCidrs{}, middleware.After)
}

func addOpDescribeCapacityBlockExtensionOfferingsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeCapacityBlockExtensionOfferings{}, middleware.After)
}

func addOpDescribeCapacityBlockOfferingsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeCapacityBlockOfferings{}, middleware.After)
}

func addOpDescribeCapacityReservationBillingRequestsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeCapacityReservationBillingRequests{}, middleware.After)
}

func addOpDescribeClientVpnAuthorizationRulesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeClientVpnAuthorizationRules{}, middleware.After)
}

func addOpDescribeClientVpnConnectionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeClientVpnConnections{}, middleware.After)
}

func addOpDescribeClientVpnRoutesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeClientVpnRoutes{}, middleware.After)
}

func addOpDescribeClientVpnTargetNetworksValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeClientVpnTargetNetworks{}, middleware.After)
}

func addOpDescribeFleetHistoryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeFleetHistory{}, middleware.After)
}

func addOpDescribeFleetInstancesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeFleetInstances{}, middleware.After)
}

func addOpDescribeFpgaImageAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeFpgaImageAttribute{}, middleware.After)
}

func addOpDescribeIdentityIdFormatValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeIdentityIdFormat{}, middleware.After)
}

func addOpDescribeImageAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeImageAttribute{}, middleware.After)
}

func addOpDescribeInstanceAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeInstanceAttribute{}, middleware.After)
}

func addOpDescribeNetworkInterfaceAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeNetworkInterfaceAttribute{}, middleware.After)
}

func addOpDescribeScheduledInstanceAvailabilityValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeScheduledInstanceAvailability{}, middleware.After)
}

func addOpDescribeSecurityGroupReferencesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeSecurityGroupReferences{}, middleware.After)
}

func addOpDescribeSnapshotAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeSnapshotAttribute{}, middleware.After)
}

func addOpDescribeSpotFleetInstancesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeSpotFleetInstances{}, middleware.After)
}

func addOpDescribeSpotFleetRequestHistoryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeSpotFleetRequestHistory{}, middleware.After)
}

func addOpDescribeStaleSecurityGroupsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeStaleSecurityGroups{}, middleware.After)
}

func addOpDescribeVolumeAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeVolumeAttribute{}, middleware.After)
}

func addOpDescribeVpcAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeVpcAttribute{}, middleware.After)
}

func addOpDescribeVpcEndpointServicePermissionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeVpcEndpointServicePermissions{}, middleware.After)
}

func addOpDetachClassicLinkVpcValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDetachClassicLinkVpc{}, middleware.After)
}

func addOpDetachInternetGatewayValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDetachInternetGateway{}, middleware.After)
}

func addOpDetachNetworkInterfaceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDetachNetworkInterface{}, middleware.After)
}

func addOpDetachVerifiedAccessTrustProviderValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDetachVerifiedAccessTrustProvider{}, middleware.After)
}

func addOpDetachVolumeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDetachVolume{}, middleware.After)
}

func addOpDetachVpnGatewayValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDetachVpnGateway{}, middleware.After)
}

func addOpDisableAddressTransferValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisableAddressTransfer{}, middleware.After)
}

func addOpDisableFastLaunchValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisableFastLaunch{}, middleware.After)
}

func addOpDisableFastSnapshotRestoresValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisableFastSnapshotRestores{}, middleware.After)
}

func addOpDisableImageDeprecationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisableImageDeprecation{}, middleware.After)
}

func addOpDisableImageDeregistrationProtectionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisableImageDeregistrationProtection{}, middleware.After)
}

func addOpDisableImageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisableImage{}, middleware.After)
}

func addOpDisableIpamOrganizationAdminAccountValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisableIpamOrganizationAdminAccount{}, middleware.After)
}

func addOpDisableTransitGatewayRouteTablePropagationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisableTransitGatewayRouteTablePropagation{}, middleware.After)
}

func addOpDisableVgwRoutePropagationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisableVgwRoutePropagation{}, middleware.After)
}

func addOpDisableVpcClassicLinkValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisableVpcClassicLink{}, middleware.After)
}

func addOpDisassociateCapacityReservationBillingOwnerValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateCapacityReservationBillingOwner{}, middleware.After)
}

func addOpDisassociateClientVpnTargetNetworkValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateClientVpnTargetNetwork{}, middleware.After)
}

func addOpDisassociateEnclaveCertificateIamRoleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateEnclaveCertificateIamRole{}, middleware.After)
}

func addOpDisassociateIamInstanceProfileValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateIamInstanceProfile{}, middleware.After)
}

func addOpDisassociateInstanceEventWindowValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateInstanceEventWindow{}, middleware.After)
}

func addOpDisassociateIpamByoasnValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateIpamByoasn{}, middleware.After)
}

func addOpDisassociateIpamResourceDiscoveryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateIpamResourceDiscovery{}, middleware.After)
}

func addOpDisassociateNatGatewayAddressValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateNatGatewayAddress{}, middleware.After)
}

func addOpDisassociateRouteTableValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateRouteTable{}, middleware.After)
}

func addOpDisassociateSecurityGroupVpcValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateSecurityGroupVpc{}, middleware.After)
}

func addOpDisassociateSubnetCidrBlockValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateSubnetCidrBlock{}, middleware.After)
}

func addOpDisassociateTransitGatewayMulticastDomainValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateTransitGatewayMulticastDomain{}, middleware.After)
}

func addOpDisassociateTransitGatewayPolicyTableValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateTransitGatewayPolicyTable{}, middleware.After)
}

func addOpDisassociateTransitGatewayRouteTableValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateTransitGatewayRouteTable{}, middleware.After)
}

func addOpDisassociateTrunkInterfaceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateTrunkInterface{}, middleware.After)
}

func addOpDisassociateVpcCidrBlockValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateVpcCidrBlock{}, middleware.After)
}

func addOpEnableAddressTransferValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpEnableAddressTransfer{}, middleware.After)
}

func addOpEnableAllowedImagesSettingsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpEnableAllowedImagesSettings{}, middleware.After)
}

func addOpEnableFastLaunchValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpEnableFastLaunch{}, middleware.After)
}

func addOpEnableFastSnapshotRestoresValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpEnableFastSnapshotRestores{}, middleware.After)
}

func addOpEnableImageBlockPublicAccessValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpEnableImageBlockPublicAccess{}, middleware.After)
}

func addOpEnableImageDeprecationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpEnableImageDeprecation{}, middleware.After)
}

func addOpEnableImageDeregistrationProtectionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpEnableImageDeregistrationProtection{}, middleware.After)
}

func addOpEnableImageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpEnableImage{}, middleware.After)
}

func addOpEnableIpamOrganizationAdminAccountValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpEnableIpamOrganizationAdminAccount{}, middleware.After)
}

func addOpEnableSnapshotBlockPublicAccessValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpEnableSnapshotBlockPublicAccess{}, middleware.After)
}

func addOpEnableTransitGatewayRouteTablePropagationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpEnableTransitGatewayRouteTablePropagation{}, middleware.After)
}

func addOpEnableVgwRoutePropagationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpEnableVgwRoutePropagation{}, middleware.After)
}

func addOpEnableVolumeIOValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpEnableVolumeIO{}, middleware.After)
}

func addOpEnableVpcClassicLinkValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpEnableVpcClassicLink{}, middleware.After)
}

func addOpExportClientVpnClientCertificateRevocationListValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpExportClientVpnClientCertificateRevocationList{}, middleware.After)
}

func addOpExportClientVpnClientConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpExportClientVpnClientConfiguration{}, middleware.After)
}

func addOpExportImageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpExportImage{}, middleware.After)
}

func addOpExportTransitGatewayRoutesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpExportTransitGatewayRoutes{}, middleware.After)
}

func addOpExportVerifiedAccessInstanceClientConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpExportVerifiedAccessInstanceClientConfiguration{}, middleware.After)
}

func addOpGetAssociatedEnclaveCertificateIamRolesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetAssociatedEnclaveCertificateIamRoles{}, middleware.After)
}

func addOpGetAssociatedIpv6PoolCidrsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetAssociatedIpv6PoolCidrs{}, middleware.After)
}

func addOpGetCapacityReservationUsageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetCapacityReservationUsage{}, middleware.After)
}

func addOpGetCoipPoolUsageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetCoipPoolUsage{}, middleware.After)
}

func addOpGetConsoleOutputValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetConsoleOutput{}, middleware.After)
}

func addOpGetConsoleScreenshotValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetConsoleScreenshot{}, middleware.After)
}

func addOpGetDeclarativePoliciesReportSummaryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetDeclarativePoliciesReportSummary{}, middleware.After)
}

func addOpGetDefaultCreditSpecificationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetDefaultCreditSpecification{}, middleware.After)
}

func addOpGetFlowLogsIntegrationTemplateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetFlowLogsIntegrationTemplate{}, middleware.After)
}

func addOpGetGroupsForCapacityReservationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetGroupsForCapacityReservation{}, middleware.After)
}

func addOpGetHostReservationPurchasePreviewValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetHostReservationPurchasePreview{}, middleware.After)
}

func addOpGetInstanceTpmEkPubValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetInstanceTpmEkPub{}, middleware.After)
}

func addOpGetInstanceTypesFromInstanceRequirementsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetInstanceTypesFromInstanceRequirements{}, middleware.After)
}

func addOpGetInstanceUefiDataValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetInstanceUefiData{}, middleware.After)
}

func addOpGetIpamAddressHistoryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetIpamAddressHistory{}, middleware.After)
}

func addOpGetIpamDiscoveredAccountsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetIpamDiscoveredAccounts{}, middleware.After)
}

func addOpGetIpamDiscoveredPublicAddressesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetIpamDiscoveredPublicAddresses{}, middleware.After)
}

func addOpGetIpamDiscoveredResourceCidrsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetIpamDiscoveredResourceCidrs{}, middleware.After)
}

func addOpGetIpamPoolAllocationsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetIpamPoolAllocations{}, middleware.After)
}

func addOpGetIpamPoolCidrsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetIpamPoolCidrs{}, middleware.After)
}

func addOpGetIpamResourceCidrsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetIpamResourceCidrs{}, middleware.After)
}

func addOpGetLaunchTemplateDataValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetLaunchTemplateData{}, middleware.After)
}

func addOpGetManagedPrefixListAssociationsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetManagedPrefixListAssociations{}, middleware.After)
}

func addOpGetManagedPrefixListEntriesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetManagedPrefixListEntries{}, middleware.After)
}

func addOpGetNetworkInsightsAccessScopeAnalysisFindingsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetNetworkInsightsAccessScopeAnalysisFindings{}, middleware.After)
}

func addOpGetNetworkInsightsAccessScopeContentValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetNetworkInsightsAccessScopeContent{}, middleware.After)
}

func addOpGetPasswordDataValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetPasswordData{}, middleware.After)
}

func addOpGetReservedInstancesExchangeQuoteValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetReservedInstancesExchangeQuote{}, middleware.After)
}

func addOpGetSecurityGroupsForVpcValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetSecurityGroupsForVpc{}, middleware.After)
}

func addOpGetSpotPlacementScoresValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetSpotPlacementScores{}, middleware.After)
}

func addOpGetSubnetCidrReservationsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetSubnetCidrReservations{}, middleware.After)
}

func addOpGetTransitGatewayAttachmentPropagationsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetTransitGatewayAttachmentPropagations{}, middleware.After)
}

func addOpGetTransitGatewayMulticastDomainAssociationsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetTransitGatewayMulticastDomainAssociations{}, middleware.After)
}

func addOpGetTransitGatewayPolicyTableAssociationsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetTransitGatewayPolicyTableAssociations{}, middleware.After)
}

func addOpGetTransitGatewayPolicyTableEntriesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetTransitGatewayPolicyTableEntries{}, middleware.After)
}

func addOpGetTransitGatewayPrefixListReferencesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetTransitGatewayPrefixListReferences{}, middleware.After)
}

func addOpGetTransitGatewayRouteTableAssociationsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetTransitGatewayRouteTableAssociations{}, middleware.After)
}

func addOpGetTransitGatewayRouteTablePropagationsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetTransitGatewayRouteTablePropagations{}, middleware.After)
}

func addOpGetVerifiedAccessEndpointPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetVerifiedAccessEndpointPolicy{}, middleware.After)
}

func addOpGetVerifiedAccessEndpointTargetsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetVerifiedAccessEndpointTargets{}, middleware.After)
}

func addOpGetVerifiedAccessGroupPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetVerifiedAccessGroupPolicy{}, middleware.After)
}

func addOpGetVpnConnectionDeviceSampleConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetVpnConnectionDeviceSampleConfiguration{}, middleware.After)
}

func addOpGetVpnTunnelReplacementStatusValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetVpnTunnelReplacementStatus{}, middleware.After)
}

func addOpImportClientVpnClientCertificateRevocationListValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpImportClientVpnClientCertificateRevocationList{}, middleware.After)
}

func addOpImportInstanceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpImportInstance{}, middleware.After)
}

func addOpImportKeyPairValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpImportKeyPair{}, middleware.After)
}

func addOpImportVolumeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpImportVolume{}, middleware.After)
}

func addOpLockSnapshotValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpLockSnapshot{}, middleware.After)
}

func addOpModifyAddressAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyAddressAttribute{}, middleware.After)
}

func addOpModifyAvailabilityZoneGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyAvailabilityZoneGroup{}, middleware.After)
}

func addOpModifyCapacityReservationFleetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyCapacityReservationFleet{}, middleware.After)
}

func addOpModifyCapacityReservationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyCapacityReservation{}, middleware.After)
}

func addOpModifyClientVpnEndpointValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyClientVpnEndpoint{}, middleware.After)
}

func addOpModifyDefaultCreditSpecificationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyDefaultCreditSpecification{}, middleware.After)
}

func addOpModifyEbsDefaultKmsKeyIdValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyEbsDefaultKmsKeyId{}, middleware.After)
}

func addOpModifyFleetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyFleet{}, middleware.After)
}

func addOpModifyFpgaImageAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyFpgaImageAttribute{}, middleware.After)
}

func addOpModifyHostsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyHosts{}, middleware.After)
}

func addOpModifyIdentityIdFormatValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyIdentityIdFormat{}, middleware.After)
}

func addOpModifyIdFormatValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyIdFormat{}, middleware.After)
}

func addOpModifyImageAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyImageAttribute{}, middleware.After)
}

func addOpModifyInstanceAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyInstanceAttribute{}, middleware.After)
}

func addOpModifyInstanceCapacityReservationAttributesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyInstanceCapacityReservationAttributes{}, middleware.After)
}

func addOpModifyInstanceCpuOptionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyInstanceCpuOptions{}, middleware.After)
}

func addOpModifyInstanceCreditSpecificationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyInstanceCreditSpecification{}, middleware.After)
}

func addOpModifyInstanceEventStartTimeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyInstanceEventStartTime{}, middleware.After)
}

func addOpModifyInstanceEventWindowValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyInstanceEventWindow{}, middleware.After)
}

func addOpModifyInstanceMaintenanceOptionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyInstanceMaintenanceOptions{}, middleware.After)
}

func addOpModifyInstanceMetadataOptionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyInstanceMetadataOptions{}, middleware.After)
}

func addOpModifyInstancePlacementValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyInstancePlacement{}, middleware.After)
}

func addOpModifyIpamValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyIpam{}, middleware.After)
}

func addOpModifyIpamPoolValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyIpamPool{}, middleware.After)
}

func addOpModifyIpamResourceCidrValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyIpamResourceCidr{}, middleware.After)
}

func addOpModifyIpamResourceDiscoveryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyIpamResourceDiscovery{}, middleware.After)
}

func addOpModifyIpamScopeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyIpamScope{}, middleware.After)
}

func addOpModifyLocalGatewayRouteValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyLocalGatewayRoute{}, middleware.After)
}

func addOpModifyManagedPrefixListValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyManagedPrefixList{}, middleware.After)
}

func addOpModifyNetworkInterfaceAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyNetworkInterfaceAttribute{}, middleware.After)
}

func addOpModifyPrivateDnsNameOptionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyPrivateDnsNameOptions{}, middleware.After)
}

func addOpModifyReservedInstancesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyReservedInstances{}, middleware.After)
}

func addOpModifySecurityGroupRulesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifySecurityGroupRules{}, middleware.After)
}

func addOpModifySnapshotAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifySnapshotAttribute{}, middleware.After)
}

func addOpModifySnapshotTierValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifySnapshotTier{}, middleware.After)
}

func addOpModifySpotFleetRequestValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifySpotFleetRequest{}, middleware.After)
}

func addOpModifySubnetAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifySubnetAttribute{}, middleware.After)
}

func addOpModifyTrafficMirrorFilterNetworkServicesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyTrafficMirrorFilterNetworkServices{}, middleware.After)
}

func addOpModifyTrafficMirrorFilterRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyTrafficMirrorFilterRule{}, middleware.After)
}

func addOpModifyTrafficMirrorSessionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyTrafficMirrorSession{}, middleware.After)
}

func addOpModifyTransitGatewayValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyTransitGateway{}, middleware.After)
}

func addOpModifyTransitGatewayPrefixListReferenceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyTransitGatewayPrefixListReference{}, middleware.After)
}

func addOpModifyTransitGatewayVpcAttachmentValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyTransitGatewayVpcAttachment{}, middleware.After)
}

func addOpModifyVerifiedAccessEndpointValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVerifiedAccessEndpoint{}, middleware.After)
}

func addOpModifyVerifiedAccessEndpointPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVerifiedAccessEndpointPolicy{}, middleware.After)
}

func addOpModifyVerifiedAccessGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVerifiedAccessGroup{}, middleware.After)
}

func addOpModifyVerifiedAccessGroupPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVerifiedAccessGroupPolicy{}, middleware.After)
}

func addOpModifyVerifiedAccessInstanceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVerifiedAccessInstance{}, middleware.After)
}

func addOpModifyVerifiedAccessInstanceLoggingConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVerifiedAccessInstanceLoggingConfiguration{}, middleware.After)
}

func addOpModifyVerifiedAccessTrustProviderValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVerifiedAccessTrustProvider{}, middleware.After)
}

func addOpModifyVolumeAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVolumeAttribute{}, middleware.After)
}

func addOpModifyVolumeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVolume{}, middleware.After)
}

func addOpModifyVpcAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVpcAttribute{}, middleware.After)
}

func addOpModifyVpcBlockPublicAccessExclusionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVpcBlockPublicAccessExclusion{}, middleware.After)
}

func addOpModifyVpcBlockPublicAccessOptionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVpcBlockPublicAccessOptions{}, middleware.After)
}

func addOpModifyVpcEndpointConnectionNotificationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVpcEndpointConnectionNotification{}, middleware.After)
}

func addOpModifyVpcEndpointValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVpcEndpoint{}, middleware.After)
}

func addOpModifyVpcEndpointServiceConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVpcEndpointServiceConfiguration{}, middleware.After)
}

func addOpModifyVpcEndpointServicePayerResponsibilityValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVpcEndpointServicePayerResponsibility{}, middleware.After)
}

func addOpModifyVpcEndpointServicePermissionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVpcEndpointServicePermissions{}, middleware.After)
}

func addOpModifyVpcPeeringConnectionOptionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVpcPeeringConnectionOptions{}, middleware.After)
}

func addOpModifyVpcTenancyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVpcTenancy{}, middleware.After)
}

func addOpModifyVpnConnectionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVpnConnection{}, middleware.After)
}

func addOpModifyVpnConnectionOptionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVpnConnectionOptions{}, middleware.After)
}

func addOpModifyVpnTunnelCertificateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVpnTunnelCertificate{}, middleware.After)
}

func addOpModifyVpnTunnelOptionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyVpnTunnelOptions{}, middleware.After)
}

func addOpMonitorInstancesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpMonitorInstances{}, middleware.After)
}

func addOpMoveAddressToVpcValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpMoveAddressToVpc{}, middleware.After)
}

func addOpMoveByoipCidrToIpamValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpMoveByoipCidrToIpam{}, middleware.After)
}

func addOpMoveCapacityReservationInstancesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpMoveCapacityReservationInstances{}, middleware.After)
}

func addOpProvisionByoipCidrValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpProvisionByoipCidr{}, middleware.After)
}

func addOpProvisionIpamByoasnValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpProvisionIpamByoasn{}, middleware.After)
}

func addOpProvisionIpamPoolCidrValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpProvisionIpamPoolCidr{}, middleware.After)
}

func addOpProvisionPublicIpv4PoolCidrValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpProvisionPublicIpv4PoolCidr{}, middleware.After)
}

func addOpPurchaseCapacityBlockExtensionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPurchaseCapacityBlockExtension{}, middleware.After)
}

func addOpPurchaseCapacityBlockValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPurchaseCapacityBlock{}, middleware.After)
}

func addOpPurchaseHostReservationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPurchaseHostReservation{}, middleware.After)
}

func addOpPurchaseReservedInstancesOfferingValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPurchaseReservedInstancesOffering{}, middleware.After)
}

func addOpPurchaseScheduledInstancesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPurchaseScheduledInstances{}, middleware.After)
}

func addOpRebootInstancesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRebootInstances{}, middleware.After)
}

func addOpRegisterImageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRegisterImage{}, middleware.After)
}

func addOpRegisterInstanceEventNotificationAttributesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRegisterInstanceEventNotificationAttributes{}, middleware.After)
}

func addOpRegisterTransitGatewayMulticastGroupMembersValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRegisterTransitGatewayMulticastGroupMembers{}, middleware.After)
}

func addOpRegisterTransitGatewayMulticastGroupSourcesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRegisterTransitGatewayMulticastGroupSources{}, middleware.After)
}

func addOpRejectCapacityReservationBillingOwnershipValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRejectCapacityReservationBillingOwnership{}, middleware.After)
}

func addOpRejectTransitGatewayPeeringAttachmentValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRejectTransitGatewayPeeringAttachment{}, middleware.After)
}

func addOpRejectTransitGatewayVpcAttachmentValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRejectTransitGatewayVpcAttachment{}, middleware.After)
}

func addOpRejectVpcEndpointConnectionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRejectVpcEndpointConnections{}, middleware.After)
}

func addOpRejectVpcPeeringConnectionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRejectVpcPeeringConnection{}, middleware.After)
}

func addOpReleaseHostsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpReleaseHosts{}, middleware.After)
}

func addOpReleaseIpamPoolAllocationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpReleaseIpamPoolAllocation{}, middleware.After)
}

func addOpReplaceIamInstanceProfileAssociationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpReplaceIamInstanceProfileAssociation{}, middleware.After)
}

func addOpReplaceNetworkAclAssociationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpReplaceNetworkAclAssociation{}, middleware.After)
}

func addOpReplaceNetworkAclEntryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpReplaceNetworkAclEntry{}, middleware.After)
}

func addOpReplaceRouteValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpReplaceRoute{}, middleware.After)
}

func addOpReplaceRouteTableAssociationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpReplaceRouteTableAssociation{}, middleware.After)
}

func addOpReplaceTransitGatewayRouteValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpReplaceTransitGatewayRoute{}, middleware.After)
}

func addOpReplaceVpnTunnelValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpReplaceVpnTunnel{}, middleware.After)
}

func addOpReportInstanceStatusValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpReportInstanceStatus{}, middleware.After)
}

func addOpRequestSpotFleetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRequestSpotFleet{}, middleware.After)
}

func addOpRequestSpotInstancesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRequestSpotInstances{}, middleware.After)
}

func addOpResetAddressAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpResetAddressAttribute{}, middleware.After)
}

func addOpResetFpgaImageAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpResetFpgaImageAttribute{}, middleware.After)
}

func addOpResetImageAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpResetImageAttribute{}, middleware.After)
}

func addOpResetInstanceAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpResetInstanceAttribute{}, middleware.After)
}

func addOpResetNetworkInterfaceAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpResetNetworkInterfaceAttribute{}, middleware.After)
}

func addOpResetSnapshotAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpResetSnapshotAttribute{}, middleware.After)
}

func addOpRestoreAddressToClassicValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRestoreAddressToClassic{}, middleware.After)
}

func addOpRestoreImageFromRecycleBinValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRestoreImageFromRecycleBin{}, middleware.After)
}

func addOpRestoreManagedPrefixListVersionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRestoreManagedPrefixListVersion{}, middleware.After)
}

func addOpRestoreSnapshotFromRecycleBinValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRestoreSnapshotFromRecycleBin{}, middleware.After)
}

func addOpRestoreSnapshotTierValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRestoreSnapshotTier{}, middleware.After)
}

func addOpRevokeClientVpnIngressValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRevokeClientVpnIngress{}, middleware.After)
}

func addOpRevokeSecurityGroupEgressValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRevokeSecurityGroupEgress{}, middleware.After)
}

func addOpRunInstancesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRunInstances{}, middleware.After)
}

func addOpRunScheduledInstancesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRunScheduledInstances{}, middleware.After)
}

func addOpSearchLocalGatewayRoutesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSearchLocalGatewayRoutes{}, middleware.After)
}

func addOpSearchTransitGatewayMulticastGroupsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSearchTransitGatewayMulticastGroups{}, middleware.After)
}

func addOpSearchTransitGatewayRoutesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSearchTransitGatewayRoutes{}, middleware.After)
}

func addOpSendDiagnosticInterruptValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSendDiagnosticInterrupt{}, middleware.After)
}

func addOpStartDeclarativePoliciesReportValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartDeclarativePoliciesReport{}, middleware.After)
}

func addOpStartInstancesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartInstances{}, middleware.After)
}

func addOpStartNetworkInsightsAccessScopeAnalysisValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartNetworkInsightsAccessScopeAnalysis{}, middleware.After)
}

func addOpStartNetworkInsightsAnalysisValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartNetworkInsightsAnalysis{}, middleware.After)
}

func addOpStartVpcEndpointServicePrivateDnsVerificationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartVpcEndpointServicePrivateDnsVerification{}, middleware.After)
}

func addOpStopInstancesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStopInstances{}, middleware.After)
}

func addOpTerminateClientVpnConnectionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpTerminateClientVpnConnections{}, middleware.After)
}

func addOpTerminateInstancesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpTerminateInstances{}, middleware.After)
}

func addOpUnassignIpv6AddressesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUnassignIpv6Addresses{}, middleware.After)
}

func addOpUnassignPrivateIpAddressesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUnassignPrivateIpAddresses{}, middleware.After)
}

func addOpUnassignPrivateNatGatewayAddressValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUnassignPrivateNatGatewayAddress{}, middleware.After)
}

func addOpUnlockSnapshotValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUnlockSnapshot{}, middleware.After)
}

func addOpUnmonitorInstancesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUnmonitorInstances{}, middleware.After)
}

func addOpWithdrawByoipCidrValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpWithdrawByoipCidr{}, middleware.After)
}

func validateAddPrefixListEntries(v []types.AddPrefixListEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddPrefixListEntries"}
	for i := range v {
		if err := validateAddPrefixListEntry(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAddPrefixListEntry(v *types.AddPrefixListEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddPrefixListEntry"}
	if v.Cidr == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cidr"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAsnAuthorizationContext(v *types.AsnAuthorizationContext) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AsnAuthorizationContext"}
	if v.Message == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Message"))
	}
	if v.Signature == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Signature"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAthenaIntegration(v *types.AthenaIntegration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AthenaIntegration"}
	if v.IntegrationResultS3DestinationArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationResultS3DestinationArn"))
	}
	if len(v.PartitionLoadFrequency) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PartitionLoadFrequency"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAthenaIntegrationsSet(v []types.AthenaIntegration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AthenaIntegrationsSet"}
	for i := range v {
		if err := validateAthenaIntegration(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCidrAuthorizationContext(v *types.CidrAuthorizationContext) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CidrAuthorizationContext"}
	if v.Message == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Message"))
	}
	if v.Signature == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Signature"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCreateTransitGatewayConnectRequestOptions(v *types.CreateTransitGatewayConnectRequestOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTransitGatewayConnectRequestOptions"}
	if len(v.Protocol) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCreditSpecificationRequest(v *types.CreditSpecificationRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreditSpecificationRequest"}
	if v.CpuCredits == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CpuCredits"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDiskImage(v *types.DiskImage) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DiskImage"}
	if v.Image != nil {
		if err := validateDiskImageDetail(v.Image); err != nil {
			invalidParams.AddNested("Image", err.(smithy.InvalidParamsError))
		}
	}
	if v.Volume != nil {
		if err := validateVolumeDetail(v.Volume); err != nil {
			invalidParams.AddNested("Volume", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDiskImageDetail(v *types.DiskImageDetail) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DiskImageDetail"}
	if len(v.Format) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Format"))
	}
	if v.Bytes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Bytes"))
	}
	if v.ImportManifestUrl == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImportManifestUrl"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDiskImageList(v []types.DiskImage) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DiskImageList"}
	for i := range v {
		if err := validateDiskImage(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateElasticGpuSpecification(v *types.ElasticGpuSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ElasticGpuSpecification"}
	if v.Type == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateElasticGpuSpecificationList(v []types.ElasticGpuSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ElasticGpuSpecificationList"}
	for i := range v {
		if err := validateElasticGpuSpecification(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateElasticGpuSpecifications(v []types.ElasticGpuSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ElasticGpuSpecifications"}
	for i := range v {
		if err := validateElasticGpuSpecification(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateElasticInferenceAccelerator(v *types.ElasticInferenceAccelerator) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ElasticInferenceAccelerator"}
	if v.Type == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateElasticInferenceAccelerators(v []types.ElasticInferenceAccelerator) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ElasticInferenceAccelerators"}
	for i := range v {
		if err := validateElasticInferenceAccelerator(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateExportTaskS3LocationRequest(v *types.ExportTaskS3LocationRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExportTaskS3LocationRequest"}
	if v.S3Bucket == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3Bucket"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFastLaunchLaunchTemplateSpecificationRequest(v *types.FastLaunchLaunchTemplateSpecificationRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FastLaunchLaunchTemplateSpecificationRequest"}
	if v.Version == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Version"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFleetLaunchTemplateConfigListRequest(v []types.FleetLaunchTemplateConfigRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FleetLaunchTemplateConfigListRequest"}
	for i := range v {
		if err := validateFleetLaunchTemplateConfigRequest(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFleetLaunchTemplateConfigRequest(v *types.FleetLaunchTemplateConfigRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FleetLaunchTemplateConfigRequest"}
	if v.Overrides != nil {
		if err := validateFleetLaunchTemplateOverridesListRequest(v.Overrides); err != nil {
			invalidParams.AddNested("Overrides", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFleetLaunchTemplateOverridesListRequest(v []types.FleetLaunchTemplateOverridesRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FleetLaunchTemplateOverridesListRequest"}
	for i := range v {
		if err := validateFleetLaunchTemplateOverridesRequest(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFleetLaunchTemplateOverridesRequest(v *types.FleetLaunchTemplateOverridesRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FleetLaunchTemplateOverridesRequest"}
	if v.InstanceRequirements != nil {
		if err := validateInstanceRequirementsRequest(v.InstanceRequirements); err != nil {
			invalidParams.AddNested("InstanceRequirements", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInstanceCreditSpecificationListRequest(v []types.InstanceCreditSpecificationRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InstanceCreditSpecificationListRequest"}
	for i := range v {
		if err := validateInstanceCreditSpecificationRequest(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInstanceCreditSpecificationRequest(v *types.InstanceCreditSpecificationRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InstanceCreditSpecificationRequest"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInstanceRequirementsRequest(v *types.InstanceRequirementsRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InstanceRequirementsRequest"}
	if v.VCpuCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VCpuCount"))
	} else if v.VCpuCount != nil {
		if err := validateVCpuCountRangeRequest(v.VCpuCount); err != nil {
			invalidParams.AddNested("VCpuCount", err.(smithy.InvalidParamsError))
		}
	}
	if v.MemoryMiB == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryMiB"))
	} else if v.MemoryMiB != nil {
		if err := validateMemoryMiBRequest(v.MemoryMiB); err != nil {
			invalidParams.AddNested("MemoryMiB", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInstanceRequirementsWithMetadataRequest(v *types.InstanceRequirementsWithMetadataRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InstanceRequirementsWithMetadataRequest"}
	if v.InstanceRequirements != nil {
		if err := validateInstanceRequirementsRequest(v.InstanceRequirements); err != nil {
			invalidParams.AddNested("InstanceRequirements", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInstanceSpecification(v *types.InstanceSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InstanceSpecification"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateIntegrateServices(v *types.IntegrateServices) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IntegrateServices"}
	if v.AthenaIntegrations != nil {
		if err := validateAthenaIntegrationsSet(v.AthenaIntegrations); err != nil {
			invalidParams.AddNested("AthenaIntegrations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLaunchTemplateElasticInferenceAccelerator(v *types.LaunchTemplateElasticInferenceAccelerator) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LaunchTemplateElasticInferenceAccelerator"}
	if v.Type == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLaunchTemplateElasticInferenceAcceleratorList(v []types.LaunchTemplateElasticInferenceAccelerator) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LaunchTemplateElasticInferenceAcceleratorList"}
	for i := range v {
		if err := validateLaunchTemplateElasticInferenceAccelerator(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMemoryMiBRequest(v *types.MemoryMiBRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MemoryMiBRequest"}
	if v.Min == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Min"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePurchaseRequest(v *types.PurchaseRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PurchaseRequest"}
	if v.InstanceCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceCount"))
	}
	if v.PurchaseToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PurchaseToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePurchaseRequestSet(v []types.PurchaseRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PurchaseRequestSet"}
	for i := range v {
		if err := validatePurchaseRequest(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRemovePrefixListEntries(v []types.RemovePrefixListEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemovePrefixListEntries"}
	for i := range v {
		if err := validateRemovePrefixListEntry(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRemovePrefixListEntry(v *types.RemovePrefixListEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemovePrefixListEntry"}
	if v.Cidr == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cidr"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRequestLaunchTemplateData(v *types.RequestLaunchTemplateData) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RequestLaunchTemplateData"}
	if v.ElasticGpuSpecifications != nil {
		if err := validateElasticGpuSpecificationList(v.ElasticGpuSpecifications); err != nil {
			invalidParams.AddNested("ElasticGpuSpecifications", err.(smithy.InvalidParamsError))
		}
	}
	if v.ElasticInferenceAccelerators != nil {
		if err := validateLaunchTemplateElasticInferenceAcceleratorList(v.ElasticInferenceAccelerators); err != nil {
			invalidParams.AddNested("ElasticInferenceAccelerators", err.(smithy.InvalidParamsError))
		}
	}
	if v.CreditSpecification != nil {
		if err := validateCreditSpecificationRequest(v.CreditSpecification); err != nil {
			invalidParams.AddNested("CreditSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.InstanceRequirements != nil {
		if err := validateInstanceRequirementsRequest(v.InstanceRequirements); err != nil {
			invalidParams.AddNested("InstanceRequirements", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRequestSpotLaunchSpecification(v *types.RequestSpotLaunchSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RequestSpotLaunchSpecification"}
	if v.Monitoring != nil {
		if err := validateRunInstancesMonitoringEnabled(v.Monitoring); err != nil {
			invalidParams.AddNested("Monitoring", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRunInstancesMonitoringEnabled(v *types.RunInstancesMonitoringEnabled) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RunInstancesMonitoringEnabled"}
	if v.Enabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateScheduledInstancesLaunchSpecification(v *types.ScheduledInstancesLaunchSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ScheduledInstancesLaunchSpecification"}
	if v.ImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSecurityGroupRuleUpdate(v *types.SecurityGroupRuleUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SecurityGroupRuleUpdate"}
	if v.SecurityGroupRuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupRuleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSecurityGroupRuleUpdateList(v []types.SecurityGroupRuleUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SecurityGroupRuleUpdateList"}
	for i := range v {
		if err := validateSecurityGroupRuleUpdate(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSlotDateTimeRangeRequest(v *types.SlotDateTimeRangeRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SlotDateTimeRangeRequest"}
	if v.EarliestTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EarliestTime"))
	}
	if v.LatestTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LatestTime"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSpotFleetRequestConfigData(v *types.SpotFleetRequestConfigData) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SpotFleetRequestConfigData"}
	if v.IamFleetRole == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IamFleetRole"))
	}
	if v.TargetCapacity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetCapacity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTargetCapacitySpecificationRequest(v *types.TargetCapacitySpecificationRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TargetCapacitySpecificationRequest"}
	if v.TotalTargetCapacity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TotalTargetCapacity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTargetConfigurationRequest(v *types.TargetConfigurationRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TargetConfigurationRequest"}
	if v.OfferingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OfferingId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTargetConfigurationRequestSet(v []types.TargetConfigurationRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TargetConfigurationRequestSet"}
	for i := range v {
		if err := validateTargetConfigurationRequest(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateVCpuCountRangeRequest(v *types.VCpuCountRangeRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VCpuCountRangeRequest"}
	if v.Min == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Min"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateVerifiedAccessLogCloudWatchLogsDestinationOptions(v *types.VerifiedAccessLogCloudWatchLogsDestinationOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VerifiedAccessLogCloudWatchLogsDestinationOptions"}
	if v.Enabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateVerifiedAccessLogKinesisDataFirehoseDestinationOptions(v *types.VerifiedAccessLogKinesisDataFirehoseDestinationOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VerifiedAccessLogKinesisDataFirehoseDestinationOptions"}
	if v.Enabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateVerifiedAccessLogOptions(v *types.VerifiedAccessLogOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VerifiedAccessLogOptions"}
	if v.S3 != nil {
		if err := validateVerifiedAccessLogS3DestinationOptions(v.S3); err != nil {
			invalidParams.AddNested("S3", err.(smithy.InvalidParamsError))
		}
	}
	if v.CloudWatchLogs != nil {
		if err := validateVerifiedAccessLogCloudWatchLogsDestinationOptions(v.CloudWatchLogs); err != nil {
			invalidParams.AddNested("CloudWatchLogs", err.(smithy.InvalidParamsError))
		}
	}
	if v.KinesisDataFirehose != nil {
		if err := validateVerifiedAccessLogKinesisDataFirehoseDestinationOptions(v.KinesisDataFirehose); err != nil {
			invalidParams.AddNested("KinesisDataFirehose", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateVerifiedAccessLogS3DestinationOptions(v *types.VerifiedAccessLogS3DestinationOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VerifiedAccessLogS3DestinationOptions"}
	if v.Enabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateVolumeDetail(v *types.VolumeDetail) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VolumeDetail"}
	if v.Size == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Size"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAcceptAddressTransferInput(v *AcceptAddressTransferInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AcceptAddressTransferInput"}
	if v.Address == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Address"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAcceptCapacityReservationBillingOwnershipInput(v *AcceptCapacityReservationBillingOwnershipInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AcceptCapacityReservationBillingOwnershipInput"}
	if v.CapacityReservationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapacityReservationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAcceptReservedInstancesExchangeQuoteInput(v *AcceptReservedInstancesExchangeQuoteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AcceptReservedInstancesExchangeQuoteInput"}
	if v.ReservedInstanceIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReservedInstanceIds"))
	}
	if v.TargetConfigurations != nil {
		if err := validateTargetConfigurationRequestSet(v.TargetConfigurations); err != nil {
			invalidParams.AddNested("TargetConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAcceptTransitGatewayPeeringAttachmentInput(v *AcceptTransitGatewayPeeringAttachmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AcceptTransitGatewayPeeringAttachmentInput"}
	if v.TransitGatewayAttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayAttachmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAcceptTransitGatewayVpcAttachmentInput(v *AcceptTransitGatewayVpcAttachmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AcceptTransitGatewayVpcAttachmentInput"}
	if v.TransitGatewayAttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayAttachmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAcceptVpcEndpointConnectionsInput(v *AcceptVpcEndpointConnectionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AcceptVpcEndpointConnectionsInput"}
	if v.ServiceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceId"))
	}
	if v.VpcEndpointIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcEndpointIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAcceptVpcPeeringConnectionInput(v *AcceptVpcPeeringConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AcceptVpcPeeringConnectionInput"}
	if v.VpcPeeringConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcPeeringConnectionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdvertiseByoipCidrInput(v *AdvertiseByoipCidrInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdvertiseByoipCidrInput"}
	if v.Cidr == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cidr"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAllocateHostsInput(v *AllocateHostsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AllocateHostsInput"}
	if v.AvailabilityZone == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZone"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAllocateIpamPoolCidrInput(v *AllocateIpamPoolCidrInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AllocateIpamPoolCidrInput"}
	if v.IpamPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpApplySecurityGroupsToClientVpnTargetNetworkInput(v *ApplySecurityGroupsToClientVpnTargetNetworkInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ApplySecurityGroupsToClientVpnTargetNetworkInput"}
	if v.ClientVpnEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientVpnEndpointId"))
	}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if v.SecurityGroupIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssignIpv6AddressesInput(v *AssignIpv6AddressesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssignIpv6AddressesInput"}
	if v.NetworkInterfaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssignPrivateIpAddressesInput(v *AssignPrivateIpAddressesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssignPrivateIpAddressesInput"}
	if v.NetworkInterfaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssignPrivateNatGatewayAddressInput(v *AssignPrivateNatGatewayAddressInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssignPrivateNatGatewayAddressInput"}
	if v.NatGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NatGatewayId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateCapacityReservationBillingOwnerInput(v *AssociateCapacityReservationBillingOwnerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateCapacityReservationBillingOwnerInput"}
	if v.CapacityReservationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapacityReservationId"))
	}
	if v.UnusedReservationBillingOwnerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UnusedReservationBillingOwnerId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateClientVpnTargetNetworkInput(v *AssociateClientVpnTargetNetworkInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateClientVpnTargetNetworkInput"}
	if v.ClientVpnEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientVpnEndpointId"))
	}
	if v.SubnetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateDhcpOptionsInput(v *AssociateDhcpOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateDhcpOptionsInput"}
	if v.DhcpOptionsId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DhcpOptionsId"))
	}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateEnclaveCertificateIamRoleInput(v *AssociateEnclaveCertificateIamRoleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateEnclaveCertificateIamRoleInput"}
	if v.CertificateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CertificateArn"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateIamInstanceProfileInput(v *AssociateIamInstanceProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateIamInstanceProfileInput"}
	if v.IamInstanceProfile == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IamInstanceProfile"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateInstanceEventWindowInput(v *AssociateInstanceEventWindowInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateInstanceEventWindowInput"}
	if v.InstanceEventWindowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceEventWindowId"))
	}
	if v.AssociationTarget == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssociationTarget"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateIpamByoasnInput(v *AssociateIpamByoasnInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateIpamByoasnInput"}
	if v.Asn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Asn"))
	}
	if v.Cidr == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cidr"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateIpamResourceDiscoveryInput(v *AssociateIpamResourceDiscoveryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateIpamResourceDiscoveryInput"}
	if v.IpamId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamId"))
	}
	if v.IpamResourceDiscoveryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamResourceDiscoveryId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateNatGatewayAddressInput(v *AssociateNatGatewayAddressInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateNatGatewayAddressInput"}
	if v.NatGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NatGatewayId"))
	}
	if v.AllocationIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AllocationIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateRouteTableInput(v *AssociateRouteTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateRouteTableInput"}
	if v.RouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateSecurityGroupVpcInput(v *AssociateSecurityGroupVpcInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateSecurityGroupVpcInput"}
	if v.GroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
	}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateSubnetCidrBlockInput(v *AssociateSubnetCidrBlockInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateSubnetCidrBlockInput"}
	if v.SubnetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateTransitGatewayMulticastDomainInput(v *AssociateTransitGatewayMulticastDomainInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateTransitGatewayMulticastDomainInput"}
	if v.TransitGatewayMulticastDomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayMulticastDomainId"))
	}
	if v.TransitGatewayAttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayAttachmentId"))
	}
	if v.SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateTransitGatewayPolicyTableInput(v *AssociateTransitGatewayPolicyTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateTransitGatewayPolicyTableInput"}
	if v.TransitGatewayPolicyTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayPolicyTableId"))
	}
	if v.TransitGatewayAttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayAttachmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateTransitGatewayRouteTableInput(v *AssociateTransitGatewayRouteTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateTransitGatewayRouteTableInput"}
	if v.TransitGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayRouteTableId"))
	}
	if v.TransitGatewayAttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayAttachmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateTrunkInterfaceInput(v *AssociateTrunkInterfaceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateTrunkInterfaceInput"}
	if v.BranchInterfaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BranchInterfaceId"))
	}
	if v.TrunkInterfaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrunkInterfaceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateVpcCidrBlockInput(v *AssociateVpcCidrBlockInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateVpcCidrBlockInput"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAttachClassicLinkVpcInput(v *AttachClassicLinkVpcInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachClassicLinkVpcInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if v.Groups == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Groups"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAttachInternetGatewayInput(v *AttachInternetGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachInternetGatewayInput"}
	if v.InternetGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InternetGatewayId"))
	}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAttachNetworkInterfaceInput(v *AttachNetworkInterfaceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachNetworkInterfaceInput"}
	if v.NetworkInterfaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceId"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.DeviceIndex == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceIndex"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAttachVerifiedAccessTrustProviderInput(v *AttachVerifiedAccessTrustProviderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachVerifiedAccessTrustProviderInput"}
	if v.VerifiedAccessInstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessInstanceId"))
	}
	if v.VerifiedAccessTrustProviderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessTrustProviderId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAttachVolumeInput(v *AttachVolumeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachVolumeInput"}
	if v.Device == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Device"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.VolumeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VolumeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAttachVpnGatewayInput(v *AttachVpnGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachVpnGatewayInput"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if v.VpnGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpnGatewayId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAuthorizeClientVpnIngressInput(v *AuthorizeClientVpnIngressInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AuthorizeClientVpnIngressInput"}
	if v.ClientVpnEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientVpnEndpointId"))
	}
	if v.TargetNetworkCidr == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetNetworkCidr"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAuthorizeSecurityGroupEgressInput(v *AuthorizeSecurityGroupEgressInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AuthorizeSecurityGroupEgressInput"}
	if v.GroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBundleInstanceInput(v *BundleInstanceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BundleInstanceInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Storage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Storage"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCancelBundleTaskInput(v *CancelBundleTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelBundleTaskInput"}
	if v.BundleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BundleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCancelCapacityReservationFleetsInput(v *CancelCapacityReservationFleetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelCapacityReservationFleetsInput"}
	if v.CapacityReservationFleetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapacityReservationFleetIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCancelCapacityReservationInput(v *CancelCapacityReservationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelCapacityReservationInput"}
	if v.CapacityReservationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapacityReservationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCancelConversionTaskInput(v *CancelConversionTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelConversionTaskInput"}
	if v.ConversionTaskId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConversionTaskId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCancelDeclarativePoliciesReportInput(v *CancelDeclarativePoliciesReportInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelDeclarativePoliciesReportInput"}
	if v.ReportId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReportId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCancelExportTaskInput(v *CancelExportTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelExportTaskInput"}
	if v.ExportTaskId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExportTaskId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCancelImageLaunchPermissionInput(v *CancelImageLaunchPermissionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelImageLaunchPermissionInput"}
	if v.ImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCancelReservedInstancesListingInput(v *CancelReservedInstancesListingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelReservedInstancesListingInput"}
	if v.ReservedInstancesListingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReservedInstancesListingId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCancelSpotFleetRequestsInput(v *CancelSpotFleetRequestsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelSpotFleetRequestsInput"}
	if v.SpotFleetRequestIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SpotFleetRequestIds"))
	}
	if v.TerminateInstances == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TerminateInstances"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCancelSpotInstanceRequestsInput(v *CancelSpotInstanceRequestsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelSpotInstanceRequestsInput"}
	if v.SpotInstanceRequestIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SpotInstanceRequestIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpConfirmProductInstanceInput(v *ConfirmProductInstanceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConfirmProductInstanceInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ProductCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProductCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCopyFpgaImageInput(v *CopyFpgaImageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CopyFpgaImageInput"}
	if v.SourceFpgaImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceFpgaImageId"))
	}
	if v.SourceRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceRegion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCopyImageInput(v *CopyImageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CopyImageInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.SourceImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceImageId"))
	}
	if v.SourceRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceRegion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCopySnapshotInput(v *CopySnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CopySnapshotInput"}
	if v.SourceRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceRegion"))
	}
	if v.SourceSnapshotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceSnapshotId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCapacityReservationBySplittingInput(v *CreateCapacityReservationBySplittingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCapacityReservationBySplittingInput"}
	if v.SourceCapacityReservationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceCapacityReservationId"))
	}
	if v.InstanceCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceCount"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCapacityReservationFleetInput(v *CreateCapacityReservationFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCapacityReservationFleetInput"}
	if v.InstanceTypeSpecifications == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceTypeSpecifications"))
	}
	if v.TotalTargetCapacity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TotalTargetCapacity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCapacityReservationInput(v *CreateCapacityReservationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCapacityReservationInput"}
	if v.InstanceType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceType"))
	}
	if len(v.InstancePlatform) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InstancePlatform"))
	}
	if v.InstanceCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceCount"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCarrierGatewayInput(v *CreateCarrierGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCarrierGatewayInput"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateClientVpnEndpointInput(v *CreateClientVpnEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateClientVpnEndpointInput"}
	if v.ClientCidrBlock == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientCidrBlock"))
	}
	if v.ServerCertificateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServerCertificateArn"))
	}
	if v.AuthenticationOptions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthenticationOptions"))
	}
	if v.ConnectionLogOptions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionLogOptions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateClientVpnRouteInput(v *CreateClientVpnRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateClientVpnRouteInput"}
	if v.ClientVpnEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientVpnEndpointId"))
	}
	if v.DestinationCidrBlock == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCidrBlock"))
	}
	if v.TargetVpcSubnetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetVpcSubnetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCoipCidrInput(v *CreateCoipCidrInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCoipCidrInput"}
	if v.Cidr == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cidr"))
	}
	if v.CoipPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CoipPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCoipPoolInput(v *CreateCoipPoolInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCoipPoolInput"}
	if v.LocalGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocalGatewayRouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCustomerGatewayInput(v *CreateCustomerGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCustomerGatewayInput"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDefaultSubnetInput(v *CreateDefaultSubnetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDefaultSubnetInput"}
	if v.AvailabilityZone == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZone"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDhcpOptionsInput(v *CreateDhcpOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDhcpOptionsInput"}
	if v.DhcpConfigurations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DhcpConfigurations"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateEgressOnlyInternetGatewayInput(v *CreateEgressOnlyInternetGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateEgressOnlyInternetGatewayInput"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFleetInput(v *CreateFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFleetInput"}
	if v.LaunchTemplateConfigs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchTemplateConfigs"))
	} else if v.LaunchTemplateConfigs != nil {
		if err := validateFleetLaunchTemplateConfigListRequest(v.LaunchTemplateConfigs); err != nil {
			invalidParams.AddNested("LaunchTemplateConfigs", err.(smithy.InvalidParamsError))
		}
	}
	if v.TargetCapacitySpecification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetCapacitySpecification"))
	} else if v.TargetCapacitySpecification != nil {
		if err := validateTargetCapacitySpecificationRequest(v.TargetCapacitySpecification); err != nil {
			invalidParams.AddNested("TargetCapacitySpecification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFlowLogsInput(v *CreateFlowLogsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFlowLogsInput"}
	if v.ResourceIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceIds"))
	}
	if len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFpgaImageInput(v *CreateFpgaImageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFpgaImageInput"}
	if v.InputStorageLocation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputStorageLocation"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateImageInput(v *CreateImageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateImageInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateInstanceConnectEndpointInput(v *CreateInstanceConnectEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateInstanceConnectEndpointInput"}
	if v.SubnetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateInstanceExportTaskInput(v *CreateInstanceExportTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateInstanceExportTaskInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if len(v.TargetEnvironment) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TargetEnvironment"))
	}
	if v.ExportToS3Task == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExportToS3Task"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateIpamExternalResourceVerificationTokenInput(v *CreateIpamExternalResourceVerificationTokenInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateIpamExternalResourceVerificationTokenInput"}
	if v.IpamId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateIpamPoolInput(v *CreateIpamPoolInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateIpamPoolInput"}
	if v.IpamScopeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamScopeId"))
	}
	if len(v.AddressFamily) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AddressFamily"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateIpamScopeInput(v *CreateIpamScopeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateIpamScopeInput"}
	if v.IpamId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateKeyPairInput(v *CreateKeyPairInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateKeyPairInput"}
	if v.KeyName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLaunchTemplateInput(v *CreateLaunchTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLaunchTemplateInput"}
	if v.LaunchTemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchTemplateName"))
	}
	if v.LaunchTemplateData == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchTemplateData"))
	} else if v.LaunchTemplateData != nil {
		if err := validateRequestLaunchTemplateData(v.LaunchTemplateData); err != nil {
			invalidParams.AddNested("LaunchTemplateData", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLaunchTemplateVersionInput(v *CreateLaunchTemplateVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLaunchTemplateVersionInput"}
	if v.LaunchTemplateData == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchTemplateData"))
	} else if v.LaunchTemplateData != nil {
		if err := validateRequestLaunchTemplateData(v.LaunchTemplateData); err != nil {
			invalidParams.AddNested("LaunchTemplateData", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLocalGatewayRouteInput(v *CreateLocalGatewayRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLocalGatewayRouteInput"}
	if v.LocalGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocalGatewayRouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLocalGatewayRouteTableInput(v *CreateLocalGatewayRouteTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLocalGatewayRouteTableInput"}
	if v.LocalGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocalGatewayId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput(v *CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput"}
	if v.LocalGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocalGatewayRouteTableId"))
	}
	if v.LocalGatewayVirtualInterfaceGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocalGatewayVirtualInterfaceGroupId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLocalGatewayRouteTableVpcAssociationInput(v *CreateLocalGatewayRouteTableVpcAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLocalGatewayRouteTableVpcAssociationInput"}
	if v.LocalGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocalGatewayRouteTableId"))
	}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateManagedPrefixListInput(v *CreateManagedPrefixListInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateManagedPrefixListInput"}
	if v.PrefixListName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrefixListName"))
	}
	if v.Entries != nil {
		if err := validateAddPrefixListEntries(v.Entries); err != nil {
			invalidParams.AddNested("Entries", err.(smithy.InvalidParamsError))
		}
	}
	if v.MaxEntries == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxEntries"))
	}
	if v.AddressFamily == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AddressFamily"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateNatGatewayInput(v *CreateNatGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateNatGatewayInput"}
	if v.SubnetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateNetworkAclEntryInput(v *CreateNetworkAclEntryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateNetworkAclEntryInput"}
	if v.NetworkAclId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkAclId"))
	}
	if v.RuleNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleNumber"))
	}
	if v.Protocol == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
	}
	if len(v.RuleAction) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RuleAction"))
	}
	if v.Egress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Egress"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateNetworkAclInput(v *CreateNetworkAclInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateNetworkAclInput"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateNetworkInsightsAccessScopeInput(v *CreateNetworkInsightsAccessScopeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateNetworkInsightsAccessScopeInput"}
	if v.ClientToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateNetworkInsightsPathInput(v *CreateNetworkInsightsPathInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateNetworkInsightsPathInput"}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	}
	if len(v.Protocol) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
	}
	if v.ClientToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateNetworkInterfaceInput(v *CreateNetworkInterfaceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateNetworkInterfaceInput"}
	if v.SubnetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateNetworkInterfacePermissionInput(v *CreateNetworkInterfacePermissionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateNetworkInterfacePermissionInput"}
	if v.NetworkInterfaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceId"))
	}
	if len(v.Permission) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Permission"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateReplaceRootVolumeTaskInput(v *CreateReplaceRootVolumeTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateReplaceRootVolumeTaskInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateReservedInstancesListingInput(v *CreateReservedInstancesListingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateReservedInstancesListingInput"}
	if v.ReservedInstancesId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReservedInstancesId"))
	}
	if v.InstanceCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceCount"))
	}
	if v.PriceSchedules == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PriceSchedules"))
	}
	if v.ClientToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRestoreImageTaskInput(v *CreateRestoreImageTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRestoreImageTaskInput"}
	if v.Bucket == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Bucket"))
	}
	if v.ObjectKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectKey"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRouteInput(v *CreateRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRouteInput"}
	if v.RouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRouteTableInput(v *CreateRouteTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRouteTableInput"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSecurityGroupInput(v *CreateSecurityGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSecurityGroupInput"}
	if v.Description == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Description"))
	}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSnapshotInput(v *CreateSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSnapshotInput"}
	if v.VolumeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VolumeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSnapshotsInput(v *CreateSnapshotsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSnapshotsInput"}
	if v.InstanceSpecification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceSpecification"))
	} else if v.InstanceSpecification != nil {
		if err := validateInstanceSpecification(v.InstanceSpecification); err != nil {
			invalidParams.AddNested("InstanceSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSpotDatafeedSubscriptionInput(v *CreateSpotDatafeedSubscriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSpotDatafeedSubscriptionInput"}
	if v.Bucket == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Bucket"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateStoreImageTaskInput(v *CreateStoreImageTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateStoreImageTaskInput"}
	if v.ImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
	}
	if v.Bucket == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Bucket"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSubnetCidrReservationInput(v *CreateSubnetCidrReservationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSubnetCidrReservationInput"}
	if v.SubnetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetId"))
	}
	if v.Cidr == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cidr"))
	}
	if len(v.ReservationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ReservationType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSubnetInput(v *CreateSubnetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSubnetInput"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTagsInput(v *CreateTagsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTagsInput"}
	if v.Resources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resources"))
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTrafficMirrorFilterRuleInput(v *CreateTrafficMirrorFilterRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTrafficMirrorFilterRuleInput"}
	if v.TrafficMirrorFilterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrafficMirrorFilterId"))
	}
	if len(v.TrafficDirection) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TrafficDirection"))
	}
	if v.RuleNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleNumber"))
	}
	if len(v.RuleAction) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RuleAction"))
	}
	if v.DestinationCidrBlock == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCidrBlock"))
	}
	if v.SourceCidrBlock == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceCidrBlock"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTrafficMirrorSessionInput(v *CreateTrafficMirrorSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTrafficMirrorSessionInput"}
	if v.NetworkInterfaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceId"))
	}
	if v.TrafficMirrorTargetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrafficMirrorTargetId"))
	}
	if v.TrafficMirrorFilterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrafficMirrorFilterId"))
	}
	if v.SessionNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionNumber"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTransitGatewayConnectInput(v *CreateTransitGatewayConnectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTransitGatewayConnectInput"}
	if v.TransportTransitGatewayAttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransportTransitGatewayAttachmentId"))
	}
	if v.Options == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Options"))
	} else if v.Options != nil {
		if err := validateCreateTransitGatewayConnectRequestOptions(v.Options); err != nil {
			invalidParams.AddNested("Options", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTransitGatewayConnectPeerInput(v *CreateTransitGatewayConnectPeerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTransitGatewayConnectPeerInput"}
	if v.TransitGatewayAttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayAttachmentId"))
	}
	if v.PeerAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PeerAddress"))
	}
	if v.InsideCidrBlocks == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InsideCidrBlocks"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTransitGatewayMulticastDomainInput(v *CreateTransitGatewayMulticastDomainInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTransitGatewayMulticastDomainInput"}
	if v.TransitGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTransitGatewayPeeringAttachmentInput(v *CreateTransitGatewayPeeringAttachmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTransitGatewayPeeringAttachmentInput"}
	if v.TransitGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayId"))
	}
	if v.PeerTransitGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PeerTransitGatewayId"))
	}
	if v.PeerAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PeerAccountId"))
	}
	if v.PeerRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PeerRegion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTransitGatewayPolicyTableInput(v *CreateTransitGatewayPolicyTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTransitGatewayPolicyTableInput"}
	if v.TransitGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTransitGatewayPrefixListReferenceInput(v *CreateTransitGatewayPrefixListReferenceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTransitGatewayPrefixListReferenceInput"}
	if v.TransitGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayRouteTableId"))
	}
	if v.PrefixListId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrefixListId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTransitGatewayRouteInput(v *CreateTransitGatewayRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTransitGatewayRouteInput"}
	if v.DestinationCidrBlock == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCidrBlock"))
	}
	if v.TransitGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayRouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTransitGatewayRouteTableAnnouncementInput(v *CreateTransitGatewayRouteTableAnnouncementInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTransitGatewayRouteTableAnnouncementInput"}
	if v.TransitGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayRouteTableId"))
	}
	if v.PeeringAttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PeeringAttachmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTransitGatewayRouteTableInput(v *CreateTransitGatewayRouteTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTransitGatewayRouteTableInput"}
	if v.TransitGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTransitGatewayVpcAttachmentInput(v *CreateTransitGatewayVpcAttachmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTransitGatewayVpcAttachmentInput"}
	if v.TransitGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayId"))
	}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if v.SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateVerifiedAccessEndpointInput(v *CreateVerifiedAccessEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVerifiedAccessEndpointInput"}
	if v.VerifiedAccessGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessGroupId"))
	}
	if len(v.EndpointType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointType"))
	}
	if len(v.AttachmentType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AttachmentType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateVerifiedAccessGroupInput(v *CreateVerifiedAccessGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVerifiedAccessGroupInput"}
	if v.VerifiedAccessInstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessInstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateVerifiedAccessTrustProviderInput(v *CreateVerifiedAccessTrustProviderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVerifiedAccessTrustProviderInput"}
	if len(v.TrustProviderType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TrustProviderType"))
	}
	if v.PolicyReferenceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyReferenceName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateVolumeInput(v *CreateVolumeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVolumeInput"}
	if v.AvailabilityZone == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZone"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateVpcBlockPublicAccessExclusionInput(v *CreateVpcBlockPublicAccessExclusionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVpcBlockPublicAccessExclusionInput"}
	if len(v.InternetGatewayExclusionMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InternetGatewayExclusionMode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateVpcEndpointConnectionNotificationInput(v *CreateVpcEndpointConnectionNotificationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVpcEndpointConnectionNotificationInput"}
	if v.ConnectionNotificationArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionNotificationArn"))
	}
	if v.ConnectionEvents == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionEvents"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateVpcEndpointInput(v *CreateVpcEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVpcEndpointInput"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateVpcPeeringConnectionInput(v *CreateVpcPeeringConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVpcPeeringConnectionInput"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateVpnConnectionInput(v *CreateVpnConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVpnConnectionInput"}
	if v.CustomerGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CustomerGatewayId"))
	}
	if v.Type == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateVpnConnectionRouteInput(v *CreateVpnConnectionRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVpnConnectionRouteInput"}
	if v.DestinationCidrBlock == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCidrBlock"))
	}
	if v.VpnConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpnConnectionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateVpnGatewayInput(v *CreateVpnGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVpnGatewayInput"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteCarrierGatewayInput(v *DeleteCarrierGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteCarrierGatewayInput"}
	if v.CarrierGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CarrierGatewayId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteClientVpnEndpointInput(v *DeleteClientVpnEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteClientVpnEndpointInput"}
	if v.ClientVpnEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientVpnEndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteClientVpnRouteInput(v *DeleteClientVpnRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteClientVpnRouteInput"}
	if v.ClientVpnEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientVpnEndpointId"))
	}
	if v.DestinationCidrBlock == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCidrBlock"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteCoipCidrInput(v *DeleteCoipCidrInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteCoipCidrInput"}
	if v.Cidr == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cidr"))
	}
	if v.CoipPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CoipPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteCoipPoolInput(v *DeleteCoipPoolInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteCoipPoolInput"}
	if v.CoipPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CoipPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteCustomerGatewayInput(v *DeleteCustomerGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteCustomerGatewayInput"}
	if v.CustomerGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CustomerGatewayId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteDhcpOptionsInput(v *DeleteDhcpOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDhcpOptionsInput"}
	if v.DhcpOptionsId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DhcpOptionsId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteEgressOnlyInternetGatewayInput(v *DeleteEgressOnlyInternetGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteEgressOnlyInternetGatewayInput"}
	if v.EgressOnlyInternetGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EgressOnlyInternetGatewayId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteFleetsInput(v *DeleteFleetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteFleetsInput"}
	if v.FleetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetIds"))
	}
	if v.TerminateInstances == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TerminateInstances"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteFlowLogsInput(v *DeleteFlowLogsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteFlowLogsInput"}
	if v.FlowLogIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowLogIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteFpgaImageInput(v *DeleteFpgaImageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteFpgaImageInput"}
	if v.FpgaImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FpgaImageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteInstanceConnectEndpointInput(v *DeleteInstanceConnectEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteInstanceConnectEndpointInput"}
	if v.InstanceConnectEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceConnectEndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteInstanceEventWindowInput(v *DeleteInstanceEventWindowInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteInstanceEventWindowInput"}
	if v.InstanceEventWindowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceEventWindowId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteInternetGatewayInput(v *DeleteInternetGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteInternetGatewayInput"}
	if v.InternetGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InternetGatewayId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteIpamExternalResourceVerificationTokenInput(v *DeleteIpamExternalResourceVerificationTokenInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIpamExternalResourceVerificationTokenInput"}
	if v.IpamExternalResourceVerificationTokenId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamExternalResourceVerificationTokenId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteIpamInput(v *DeleteIpamInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIpamInput"}
	if v.IpamId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteIpamPoolInput(v *DeleteIpamPoolInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIpamPoolInput"}
	if v.IpamPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteIpamResourceDiscoveryInput(v *DeleteIpamResourceDiscoveryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIpamResourceDiscoveryInput"}
	if v.IpamResourceDiscoveryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamResourceDiscoveryId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteIpamScopeInput(v *DeleteIpamScopeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIpamScopeInput"}
	if v.IpamScopeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamScopeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteLaunchTemplateVersionsInput(v *DeleteLaunchTemplateVersionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteLaunchTemplateVersionsInput"}
	if v.Versions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Versions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteLocalGatewayRouteInput(v *DeleteLocalGatewayRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteLocalGatewayRouteInput"}
	if v.LocalGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocalGatewayRouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteLocalGatewayRouteTableInput(v *DeleteLocalGatewayRouteTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteLocalGatewayRouteTableInput"}
	if v.LocalGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocalGatewayRouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput(v *DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput"}
	if v.LocalGatewayRouteTableVirtualInterfaceGroupAssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocalGatewayRouteTableVirtualInterfaceGroupAssociationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteLocalGatewayRouteTableVpcAssociationInput(v *DeleteLocalGatewayRouteTableVpcAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteLocalGatewayRouteTableVpcAssociationInput"}
	if v.LocalGatewayRouteTableVpcAssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocalGatewayRouteTableVpcAssociationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteManagedPrefixListInput(v *DeleteManagedPrefixListInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteManagedPrefixListInput"}
	if v.PrefixListId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrefixListId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteNatGatewayInput(v *DeleteNatGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteNatGatewayInput"}
	if v.NatGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NatGatewayId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteNetworkAclEntryInput(v *DeleteNetworkAclEntryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteNetworkAclEntryInput"}
	if v.NetworkAclId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkAclId"))
	}
	if v.RuleNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleNumber"))
	}
	if v.Egress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Egress"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteNetworkAclInput(v *DeleteNetworkAclInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteNetworkAclInput"}
	if v.NetworkAclId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkAclId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteNetworkInsightsAccessScopeAnalysisInput(v *DeleteNetworkInsightsAccessScopeAnalysisInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteNetworkInsightsAccessScopeAnalysisInput"}
	if v.NetworkInsightsAccessScopeAnalysisId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInsightsAccessScopeAnalysisId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteNetworkInsightsAccessScopeInput(v *DeleteNetworkInsightsAccessScopeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteNetworkInsightsAccessScopeInput"}
	if v.NetworkInsightsAccessScopeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInsightsAccessScopeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteNetworkInsightsAnalysisInput(v *DeleteNetworkInsightsAnalysisInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteNetworkInsightsAnalysisInput"}
	if v.NetworkInsightsAnalysisId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInsightsAnalysisId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteNetworkInsightsPathInput(v *DeleteNetworkInsightsPathInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteNetworkInsightsPathInput"}
	if v.NetworkInsightsPathId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInsightsPathId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteNetworkInterfaceInput(v *DeleteNetworkInterfaceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteNetworkInterfaceInput"}
	if v.NetworkInterfaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteNetworkInterfacePermissionInput(v *DeleteNetworkInterfacePermissionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteNetworkInterfacePermissionInput"}
	if v.NetworkInterfacePermissionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfacePermissionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeletePlacementGroupInput(v *DeletePlacementGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeletePlacementGroupInput"}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeletePublicIpv4PoolInput(v *DeletePublicIpv4PoolInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeletePublicIpv4PoolInput"}
	if v.PoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteQueuedReservedInstancesInput(v *DeleteQueuedReservedInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteQueuedReservedInstancesInput"}
	if v.ReservedInstancesIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReservedInstancesIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRouteInput(v *DeleteRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRouteInput"}
	if v.RouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRouteTableInput(v *DeleteRouteTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRouteTableInput"}
	if v.RouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteSnapshotInput(v *DeleteSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteSnapshotInput"}
	if v.SnapshotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteSubnetCidrReservationInput(v *DeleteSubnetCidrReservationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteSubnetCidrReservationInput"}
	if v.SubnetCidrReservationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetCidrReservationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteSubnetInput(v *DeleteSubnetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteSubnetInput"}
	if v.SubnetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTagsInput(v *DeleteTagsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTagsInput"}
	if v.Resources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resources"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTrafficMirrorFilterInput(v *DeleteTrafficMirrorFilterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTrafficMirrorFilterInput"}
	if v.TrafficMirrorFilterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrafficMirrorFilterId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTrafficMirrorFilterRuleInput(v *DeleteTrafficMirrorFilterRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTrafficMirrorFilterRuleInput"}
	if v.TrafficMirrorFilterRuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrafficMirrorFilterRuleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTrafficMirrorSessionInput(v *DeleteTrafficMirrorSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTrafficMirrorSessionInput"}
	if v.TrafficMirrorSessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrafficMirrorSessionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTrafficMirrorTargetInput(v *DeleteTrafficMirrorTargetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTrafficMirrorTargetInput"}
	if v.TrafficMirrorTargetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrafficMirrorTargetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTransitGatewayConnectInput(v *DeleteTransitGatewayConnectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTransitGatewayConnectInput"}
	if v.TransitGatewayAttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayAttachmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTransitGatewayConnectPeerInput(v *DeleteTransitGatewayConnectPeerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTransitGatewayConnectPeerInput"}
	if v.TransitGatewayConnectPeerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayConnectPeerId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTransitGatewayInput(v *DeleteTransitGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTransitGatewayInput"}
	if v.TransitGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTransitGatewayMulticastDomainInput(v *DeleteTransitGatewayMulticastDomainInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTransitGatewayMulticastDomainInput"}
	if v.TransitGatewayMulticastDomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayMulticastDomainId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTransitGatewayPeeringAttachmentInput(v *DeleteTransitGatewayPeeringAttachmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTransitGatewayPeeringAttachmentInput"}
	if v.TransitGatewayAttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayAttachmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTransitGatewayPolicyTableInput(v *DeleteTransitGatewayPolicyTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTransitGatewayPolicyTableInput"}
	if v.TransitGatewayPolicyTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayPolicyTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTransitGatewayPrefixListReferenceInput(v *DeleteTransitGatewayPrefixListReferenceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTransitGatewayPrefixListReferenceInput"}
	if v.TransitGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayRouteTableId"))
	}
	if v.PrefixListId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrefixListId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTransitGatewayRouteInput(v *DeleteTransitGatewayRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTransitGatewayRouteInput"}
	if v.TransitGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayRouteTableId"))
	}
	if v.DestinationCidrBlock == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCidrBlock"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTransitGatewayRouteTableAnnouncementInput(v *DeleteTransitGatewayRouteTableAnnouncementInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTransitGatewayRouteTableAnnouncementInput"}
	if v.TransitGatewayRouteTableAnnouncementId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayRouteTableAnnouncementId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTransitGatewayRouteTableInput(v *DeleteTransitGatewayRouteTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTransitGatewayRouteTableInput"}
	if v.TransitGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayRouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTransitGatewayVpcAttachmentInput(v *DeleteTransitGatewayVpcAttachmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTransitGatewayVpcAttachmentInput"}
	if v.TransitGatewayAttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayAttachmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteVerifiedAccessEndpointInput(v *DeleteVerifiedAccessEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVerifiedAccessEndpointInput"}
	if v.VerifiedAccessEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessEndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteVerifiedAccessGroupInput(v *DeleteVerifiedAccessGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVerifiedAccessGroupInput"}
	if v.VerifiedAccessGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessGroupId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteVerifiedAccessInstanceInput(v *DeleteVerifiedAccessInstanceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVerifiedAccessInstanceInput"}
	if v.VerifiedAccessInstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessInstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteVerifiedAccessTrustProviderInput(v *DeleteVerifiedAccessTrustProviderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVerifiedAccessTrustProviderInput"}
	if v.VerifiedAccessTrustProviderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessTrustProviderId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteVolumeInput(v *DeleteVolumeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVolumeInput"}
	if v.VolumeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VolumeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteVpcBlockPublicAccessExclusionInput(v *DeleteVpcBlockPublicAccessExclusionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVpcBlockPublicAccessExclusionInput"}
	if v.ExclusionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExclusionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteVpcEndpointConnectionNotificationsInput(v *DeleteVpcEndpointConnectionNotificationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVpcEndpointConnectionNotificationsInput"}
	if v.ConnectionNotificationIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionNotificationIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteVpcEndpointServiceConfigurationsInput(v *DeleteVpcEndpointServiceConfigurationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVpcEndpointServiceConfigurationsInput"}
	if v.ServiceIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteVpcEndpointsInput(v *DeleteVpcEndpointsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVpcEndpointsInput"}
	if v.VpcEndpointIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcEndpointIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteVpcInput(v *DeleteVpcInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVpcInput"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteVpcPeeringConnectionInput(v *DeleteVpcPeeringConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVpcPeeringConnectionInput"}
	if v.VpcPeeringConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcPeeringConnectionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteVpnConnectionInput(v *DeleteVpnConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVpnConnectionInput"}
	if v.VpnConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpnConnectionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteVpnConnectionRouteInput(v *DeleteVpnConnectionRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVpnConnectionRouteInput"}
	if v.DestinationCidrBlock == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCidrBlock"))
	}
	if v.VpnConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpnConnectionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteVpnGatewayInput(v *DeleteVpnGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVpnGatewayInput"}
	if v.VpnGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpnGatewayId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeprovisionByoipCidrInput(v *DeprovisionByoipCidrInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeprovisionByoipCidrInput"}
	if v.Cidr == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cidr"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeprovisionIpamByoasnInput(v *DeprovisionIpamByoasnInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeprovisionIpamByoasnInput"}
	if v.IpamId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamId"))
	}
	if v.Asn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Asn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeprovisionIpamPoolCidrInput(v *DeprovisionIpamPoolCidrInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeprovisionIpamPoolCidrInput"}
	if v.IpamPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeprovisionPublicIpv4PoolCidrInput(v *DeprovisionPublicIpv4PoolCidrInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeprovisionPublicIpv4PoolCidrInput"}
	if v.PoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PoolId"))
	}
	if v.Cidr == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cidr"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeregisterImageInput(v *DeregisterImageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeregisterImageInput"}
	if v.ImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeregisterInstanceEventNotificationAttributesInput(v *DeregisterInstanceEventNotificationAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeregisterInstanceEventNotificationAttributesInput"}
	if v.InstanceTagAttribute == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceTagAttribute"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeByoipCidrsInput(v *DescribeByoipCidrsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeByoipCidrsInput"}
	if v.MaxResults == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxResults"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeCapacityBlockExtensionOfferingsInput(v *DescribeCapacityBlockExtensionOfferingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeCapacityBlockExtensionOfferingsInput"}
	if v.CapacityBlockExtensionDurationHours == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapacityBlockExtensionDurationHours"))
	}
	if v.CapacityReservationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapacityReservationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeCapacityBlockOfferingsInput(v *DescribeCapacityBlockOfferingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeCapacityBlockOfferingsInput"}
	if v.CapacityDurationHours == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapacityDurationHours"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeCapacityReservationBillingRequestsInput(v *DescribeCapacityReservationBillingRequestsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeCapacityReservationBillingRequestsInput"}
	if len(v.Role) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Role"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeClientVpnAuthorizationRulesInput(v *DescribeClientVpnAuthorizationRulesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeClientVpnAuthorizationRulesInput"}
	if v.ClientVpnEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientVpnEndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeClientVpnConnectionsInput(v *DescribeClientVpnConnectionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeClientVpnConnectionsInput"}
	if v.ClientVpnEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientVpnEndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeClientVpnRoutesInput(v *DescribeClientVpnRoutesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeClientVpnRoutesInput"}
	if v.ClientVpnEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientVpnEndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeClientVpnTargetNetworksInput(v *DescribeClientVpnTargetNetworksInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeClientVpnTargetNetworksInput"}
	if v.ClientVpnEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientVpnEndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeFleetHistoryInput(v *DescribeFleetHistoryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeFleetHistoryInput"}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeFleetInstancesInput(v *DescribeFleetInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeFleetInstancesInput"}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeFpgaImageAttributeInput(v *DescribeFpgaImageAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeFpgaImageAttributeInput"}
	if v.FpgaImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FpgaImageId"))
	}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeIdentityIdFormatInput(v *DescribeIdentityIdFormatInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeIdentityIdFormatInput"}
	if v.PrincipalArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeImageAttributeInput(v *DescribeImageAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeImageAttributeInput"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if v.ImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeInstanceAttributeInput(v *DescribeInstanceAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeInstanceAttributeInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeNetworkInterfaceAttributeInput(v *DescribeNetworkInterfaceAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeNetworkInterfaceAttributeInput"}
	if v.NetworkInterfaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeScheduledInstanceAvailabilityInput(v *DescribeScheduledInstanceAvailabilityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeScheduledInstanceAvailabilityInput"}
	if v.FirstSlotStartTimeRange == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FirstSlotStartTimeRange"))
	} else if v.FirstSlotStartTimeRange != nil {
		if err := validateSlotDateTimeRangeRequest(v.FirstSlotStartTimeRange); err != nil {
			invalidParams.AddNested("FirstSlotStartTimeRange", err.(smithy.InvalidParamsError))
		}
	}
	if v.Recurrence == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Recurrence"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeSecurityGroupReferencesInput(v *DescribeSecurityGroupReferencesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeSecurityGroupReferencesInput"}
	if v.GroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeSnapshotAttributeInput(v *DescribeSnapshotAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeSnapshotAttributeInput"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if v.SnapshotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeSpotFleetInstancesInput(v *DescribeSpotFleetInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeSpotFleetInstancesInput"}
	if v.SpotFleetRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SpotFleetRequestId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeSpotFleetRequestHistoryInput(v *DescribeSpotFleetRequestHistoryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeSpotFleetRequestHistoryInput"}
	if v.SpotFleetRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SpotFleetRequestId"))
	}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeStaleSecurityGroupsInput(v *DescribeStaleSecurityGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeStaleSecurityGroupsInput"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeVolumeAttributeInput(v *DescribeVolumeAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeVolumeAttributeInput"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if v.VolumeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VolumeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeVpcAttributeInput(v *DescribeVpcAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeVpcAttributeInput"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeVpcEndpointServicePermissionsInput(v *DescribeVpcEndpointServicePermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeVpcEndpointServicePermissionsInput"}
	if v.ServiceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDetachClassicLinkVpcInput(v *DetachClassicLinkVpcInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DetachClassicLinkVpcInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDetachInternetGatewayInput(v *DetachInternetGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DetachInternetGatewayInput"}
	if v.InternetGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InternetGatewayId"))
	}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDetachNetworkInterfaceInput(v *DetachNetworkInterfaceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DetachNetworkInterfaceInput"}
	if v.AttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttachmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDetachVerifiedAccessTrustProviderInput(v *DetachVerifiedAccessTrustProviderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DetachVerifiedAccessTrustProviderInput"}
	if v.VerifiedAccessInstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessInstanceId"))
	}
	if v.VerifiedAccessTrustProviderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessTrustProviderId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDetachVolumeInput(v *DetachVolumeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DetachVolumeInput"}
	if v.VolumeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VolumeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDetachVpnGatewayInput(v *DetachVpnGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DetachVpnGatewayInput"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if v.VpnGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpnGatewayId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisableAddressTransferInput(v *DisableAddressTransferInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisableAddressTransferInput"}
	if v.AllocationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AllocationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisableFastLaunchInput(v *DisableFastLaunchInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisableFastLaunchInput"}
	if v.ImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisableFastSnapshotRestoresInput(v *DisableFastSnapshotRestoresInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisableFastSnapshotRestoresInput"}
	if v.AvailabilityZones == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZones"))
	}
	if v.SourceSnapshotIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceSnapshotIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisableImageDeprecationInput(v *DisableImageDeprecationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisableImageDeprecationInput"}
	if v.ImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisableImageDeregistrationProtectionInput(v *DisableImageDeregistrationProtectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisableImageDeregistrationProtectionInput"}
	if v.ImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisableImageInput(v *DisableImageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisableImageInput"}
	if v.ImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisableIpamOrganizationAdminAccountInput(v *DisableIpamOrganizationAdminAccountInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisableIpamOrganizationAdminAccountInput"}
	if v.DelegatedAdminAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DelegatedAdminAccountId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisableTransitGatewayRouteTablePropagationInput(v *DisableTransitGatewayRouteTablePropagationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisableTransitGatewayRouteTablePropagationInput"}
	if v.TransitGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayRouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisableVgwRoutePropagationInput(v *DisableVgwRoutePropagationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisableVgwRoutePropagationInput"}
	if v.GatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayId"))
	}
	if v.RouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisableVpcClassicLinkInput(v *DisableVpcClassicLinkInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisableVpcClassicLinkInput"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateCapacityReservationBillingOwnerInput(v *DisassociateCapacityReservationBillingOwnerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateCapacityReservationBillingOwnerInput"}
	if v.CapacityReservationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapacityReservationId"))
	}
	if v.UnusedReservationBillingOwnerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UnusedReservationBillingOwnerId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateClientVpnTargetNetworkInput(v *DisassociateClientVpnTargetNetworkInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateClientVpnTargetNetworkInput"}
	if v.ClientVpnEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientVpnEndpointId"))
	}
	if v.AssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateEnclaveCertificateIamRoleInput(v *DisassociateEnclaveCertificateIamRoleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateEnclaveCertificateIamRoleInput"}
	if v.CertificateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CertificateArn"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateIamInstanceProfileInput(v *DisassociateIamInstanceProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateIamInstanceProfileInput"}
	if v.AssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateInstanceEventWindowInput(v *DisassociateInstanceEventWindowInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateInstanceEventWindowInput"}
	if v.InstanceEventWindowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceEventWindowId"))
	}
	if v.AssociationTarget == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssociationTarget"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateIpamByoasnInput(v *DisassociateIpamByoasnInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateIpamByoasnInput"}
	if v.Asn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Asn"))
	}
	if v.Cidr == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cidr"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateIpamResourceDiscoveryInput(v *DisassociateIpamResourceDiscoveryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateIpamResourceDiscoveryInput"}
	if v.IpamResourceDiscoveryAssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamResourceDiscoveryAssociationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateNatGatewayAddressInput(v *DisassociateNatGatewayAddressInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateNatGatewayAddressInput"}
	if v.NatGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NatGatewayId"))
	}
	if v.AssociationIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssociationIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateRouteTableInput(v *DisassociateRouteTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateRouteTableInput"}
	if v.AssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateSecurityGroupVpcInput(v *DisassociateSecurityGroupVpcInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateSecurityGroupVpcInput"}
	if v.GroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
	}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateSubnetCidrBlockInput(v *DisassociateSubnetCidrBlockInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateSubnetCidrBlockInput"}
	if v.AssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateTransitGatewayMulticastDomainInput(v *DisassociateTransitGatewayMulticastDomainInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateTransitGatewayMulticastDomainInput"}
	if v.TransitGatewayMulticastDomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayMulticastDomainId"))
	}
	if v.TransitGatewayAttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayAttachmentId"))
	}
	if v.SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateTransitGatewayPolicyTableInput(v *DisassociateTransitGatewayPolicyTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateTransitGatewayPolicyTableInput"}
	if v.TransitGatewayPolicyTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayPolicyTableId"))
	}
	if v.TransitGatewayAttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayAttachmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateTransitGatewayRouteTableInput(v *DisassociateTransitGatewayRouteTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateTransitGatewayRouteTableInput"}
	if v.TransitGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayRouteTableId"))
	}
	if v.TransitGatewayAttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayAttachmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateTrunkInterfaceInput(v *DisassociateTrunkInterfaceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateTrunkInterfaceInput"}
	if v.AssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateVpcCidrBlockInput(v *DisassociateVpcCidrBlockInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateVpcCidrBlockInput"}
	if v.AssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpEnableAddressTransferInput(v *EnableAddressTransferInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableAddressTransferInput"}
	if v.AllocationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AllocationId"))
	}
	if v.TransferAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransferAccountId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpEnableAllowedImagesSettingsInput(v *EnableAllowedImagesSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableAllowedImagesSettingsInput"}
	if len(v.AllowedImagesSettingsState) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AllowedImagesSettingsState"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpEnableFastLaunchInput(v *EnableFastLaunchInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableFastLaunchInput"}
	if v.ImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
	}
	if v.LaunchTemplate != nil {
		if err := validateFastLaunchLaunchTemplateSpecificationRequest(v.LaunchTemplate); err != nil {
			invalidParams.AddNested("LaunchTemplate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpEnableFastSnapshotRestoresInput(v *EnableFastSnapshotRestoresInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableFastSnapshotRestoresInput"}
	if v.AvailabilityZones == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZones"))
	}
	if v.SourceSnapshotIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceSnapshotIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpEnableImageBlockPublicAccessInput(v *EnableImageBlockPublicAccessInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableImageBlockPublicAccessInput"}
	if len(v.ImageBlockPublicAccessState) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ImageBlockPublicAccessState"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpEnableImageDeprecationInput(v *EnableImageDeprecationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableImageDeprecationInput"}
	if v.ImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
	}
	if v.DeprecateAt == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeprecateAt"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpEnableImageDeregistrationProtectionInput(v *EnableImageDeregistrationProtectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableImageDeregistrationProtectionInput"}
	if v.ImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpEnableImageInput(v *EnableImageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableImageInput"}
	if v.ImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpEnableIpamOrganizationAdminAccountInput(v *EnableIpamOrganizationAdminAccountInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableIpamOrganizationAdminAccountInput"}
	if v.DelegatedAdminAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DelegatedAdminAccountId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpEnableSnapshotBlockPublicAccessInput(v *EnableSnapshotBlockPublicAccessInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableSnapshotBlockPublicAccessInput"}
	if len(v.State) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("State"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpEnableTransitGatewayRouteTablePropagationInput(v *EnableTransitGatewayRouteTablePropagationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableTransitGatewayRouteTablePropagationInput"}
	if v.TransitGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayRouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpEnableVgwRoutePropagationInput(v *EnableVgwRoutePropagationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableVgwRoutePropagationInput"}
	if v.GatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayId"))
	}
	if v.RouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpEnableVolumeIOInput(v *EnableVolumeIOInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableVolumeIOInput"}
	if v.VolumeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VolumeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpEnableVpcClassicLinkInput(v *EnableVpcClassicLinkInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableVpcClassicLinkInput"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpExportClientVpnClientCertificateRevocationListInput(v *ExportClientVpnClientCertificateRevocationListInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExportClientVpnClientCertificateRevocationListInput"}
	if v.ClientVpnEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientVpnEndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpExportClientVpnClientConfigurationInput(v *ExportClientVpnClientConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExportClientVpnClientConfigurationInput"}
	if v.ClientVpnEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientVpnEndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpExportImageInput(v *ExportImageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExportImageInput"}
	if len(v.DiskImageFormat) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DiskImageFormat"))
	}
	if v.ImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
	}
	if v.S3ExportLocation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3ExportLocation"))
	} else if v.S3ExportLocation != nil {
		if err := validateExportTaskS3LocationRequest(v.S3ExportLocation); err != nil {
			invalidParams.AddNested("S3ExportLocation", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpExportTransitGatewayRoutesInput(v *ExportTransitGatewayRoutesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExportTransitGatewayRoutesInput"}
	if v.TransitGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayRouteTableId"))
	}
	if v.S3Bucket == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3Bucket"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpExportVerifiedAccessInstanceClientConfigurationInput(v *ExportVerifiedAccessInstanceClientConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExportVerifiedAccessInstanceClientConfigurationInput"}
	if v.VerifiedAccessInstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessInstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAssociatedEnclaveCertificateIamRolesInput(v *GetAssociatedEnclaveCertificateIamRolesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAssociatedEnclaveCertificateIamRolesInput"}
	if v.CertificateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CertificateArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAssociatedIpv6PoolCidrsInput(v *GetAssociatedIpv6PoolCidrsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAssociatedIpv6PoolCidrsInput"}
	if v.PoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCapacityReservationUsageInput(v *GetCapacityReservationUsageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCapacityReservationUsageInput"}
	if v.CapacityReservationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapacityReservationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCoipPoolUsageInput(v *GetCoipPoolUsageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCoipPoolUsageInput"}
	if v.PoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetConsoleOutputInput(v *GetConsoleOutputInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetConsoleOutputInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetConsoleScreenshotInput(v *GetConsoleScreenshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetConsoleScreenshotInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDeclarativePoliciesReportSummaryInput(v *GetDeclarativePoliciesReportSummaryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDeclarativePoliciesReportSummaryInput"}
	if v.ReportId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReportId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDefaultCreditSpecificationInput(v *GetDefaultCreditSpecificationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDefaultCreditSpecificationInput"}
	if len(v.InstanceFamily) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceFamily"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetFlowLogsIntegrationTemplateInput(v *GetFlowLogsIntegrationTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetFlowLogsIntegrationTemplateInput"}
	if v.FlowLogId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowLogId"))
	}
	if v.ConfigDeliveryS3DestinationArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigDeliveryS3DestinationArn"))
	}
	if v.IntegrateServices == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrateServices"))
	} else if v.IntegrateServices != nil {
		if err := validateIntegrateServices(v.IntegrateServices); err != nil {
			invalidParams.AddNested("IntegrateServices", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetGroupsForCapacityReservationInput(v *GetGroupsForCapacityReservationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetGroupsForCapacityReservationInput"}
	if v.CapacityReservationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapacityReservationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetHostReservationPurchasePreviewInput(v *GetHostReservationPurchasePreviewInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetHostReservationPurchasePreviewInput"}
	if v.HostIdSet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HostIdSet"))
	}
	if v.OfferingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OfferingId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetInstanceTpmEkPubInput(v *GetInstanceTpmEkPubInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetInstanceTpmEkPubInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if len(v.KeyType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("KeyType"))
	}
	if len(v.KeyFormat) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("KeyFormat"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetInstanceTypesFromInstanceRequirementsInput(v *GetInstanceTypesFromInstanceRequirementsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetInstanceTypesFromInstanceRequirementsInput"}
	if v.ArchitectureTypes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ArchitectureTypes"))
	}
	if v.VirtualizationTypes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VirtualizationTypes"))
	}
	if v.InstanceRequirements == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceRequirements"))
	} else if v.InstanceRequirements != nil {
		if err := validateInstanceRequirementsRequest(v.InstanceRequirements); err != nil {
			invalidParams.AddNested("InstanceRequirements", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetInstanceUefiDataInput(v *GetInstanceUefiDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetInstanceUefiDataInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIpamAddressHistoryInput(v *GetIpamAddressHistoryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIpamAddressHistoryInput"}
	if v.Cidr == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cidr"))
	}
	if v.IpamScopeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamScopeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIpamDiscoveredAccountsInput(v *GetIpamDiscoveredAccountsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIpamDiscoveredAccountsInput"}
	if v.IpamResourceDiscoveryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamResourceDiscoveryId"))
	}
	if v.DiscoveryRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DiscoveryRegion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIpamDiscoveredPublicAddressesInput(v *GetIpamDiscoveredPublicAddressesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIpamDiscoveredPublicAddressesInput"}
	if v.IpamResourceDiscoveryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamResourceDiscoveryId"))
	}
	if v.AddressRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AddressRegion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIpamDiscoveredResourceCidrsInput(v *GetIpamDiscoveredResourceCidrsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIpamDiscoveredResourceCidrsInput"}
	if v.IpamResourceDiscoveryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamResourceDiscoveryId"))
	}
	if v.ResourceRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceRegion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIpamPoolAllocationsInput(v *GetIpamPoolAllocationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIpamPoolAllocationsInput"}
	if v.IpamPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIpamPoolCidrsInput(v *GetIpamPoolCidrsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIpamPoolCidrsInput"}
	if v.IpamPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIpamResourceCidrsInput(v *GetIpamResourceCidrsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIpamResourceCidrsInput"}
	if v.IpamScopeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamScopeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetLaunchTemplateDataInput(v *GetLaunchTemplateDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetLaunchTemplateDataInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetManagedPrefixListAssociationsInput(v *GetManagedPrefixListAssociationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetManagedPrefixListAssociationsInput"}
	if v.PrefixListId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrefixListId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetManagedPrefixListEntriesInput(v *GetManagedPrefixListEntriesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetManagedPrefixListEntriesInput"}
	if v.PrefixListId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrefixListId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetNetworkInsightsAccessScopeAnalysisFindingsInput(v *GetNetworkInsightsAccessScopeAnalysisFindingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetNetworkInsightsAccessScopeAnalysisFindingsInput"}
	if v.NetworkInsightsAccessScopeAnalysisId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInsightsAccessScopeAnalysisId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetNetworkInsightsAccessScopeContentInput(v *GetNetworkInsightsAccessScopeContentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetNetworkInsightsAccessScopeContentInput"}
	if v.NetworkInsightsAccessScopeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInsightsAccessScopeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetPasswordDataInput(v *GetPasswordDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPasswordDataInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetReservedInstancesExchangeQuoteInput(v *GetReservedInstancesExchangeQuoteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetReservedInstancesExchangeQuoteInput"}
	if v.ReservedInstanceIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReservedInstanceIds"))
	}
	if v.TargetConfigurations != nil {
		if err := validateTargetConfigurationRequestSet(v.TargetConfigurations); err != nil {
			invalidParams.AddNested("TargetConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSecurityGroupsForVpcInput(v *GetSecurityGroupsForVpcInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSecurityGroupsForVpcInput"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSpotPlacementScoresInput(v *GetSpotPlacementScoresInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSpotPlacementScoresInput"}
	if v.TargetCapacity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetCapacity"))
	}
	if v.InstanceRequirementsWithMetadata != nil {
		if err := validateInstanceRequirementsWithMetadataRequest(v.InstanceRequirementsWithMetadata); err != nil {
			invalidParams.AddNested("InstanceRequirementsWithMetadata", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSubnetCidrReservationsInput(v *GetSubnetCidrReservationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSubnetCidrReservationsInput"}
	if v.SubnetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetTransitGatewayAttachmentPropagationsInput(v *GetTransitGatewayAttachmentPropagationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTransitGatewayAttachmentPropagationsInput"}
	if v.TransitGatewayAttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayAttachmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetTransitGatewayMulticastDomainAssociationsInput(v *GetTransitGatewayMulticastDomainAssociationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTransitGatewayMulticastDomainAssociationsInput"}
	if v.TransitGatewayMulticastDomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayMulticastDomainId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetTransitGatewayPolicyTableAssociationsInput(v *GetTransitGatewayPolicyTableAssociationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTransitGatewayPolicyTableAssociationsInput"}
	if v.TransitGatewayPolicyTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayPolicyTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetTransitGatewayPolicyTableEntriesInput(v *GetTransitGatewayPolicyTableEntriesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTransitGatewayPolicyTableEntriesInput"}
	if v.TransitGatewayPolicyTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayPolicyTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetTransitGatewayPrefixListReferencesInput(v *GetTransitGatewayPrefixListReferencesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTransitGatewayPrefixListReferencesInput"}
	if v.TransitGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayRouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetTransitGatewayRouteTableAssociationsInput(v *GetTransitGatewayRouteTableAssociationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTransitGatewayRouteTableAssociationsInput"}
	if v.TransitGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayRouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetTransitGatewayRouteTablePropagationsInput(v *GetTransitGatewayRouteTablePropagationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTransitGatewayRouteTablePropagationsInput"}
	if v.TransitGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayRouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetVerifiedAccessEndpointPolicyInput(v *GetVerifiedAccessEndpointPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetVerifiedAccessEndpointPolicyInput"}
	if v.VerifiedAccessEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessEndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetVerifiedAccessEndpointTargetsInput(v *GetVerifiedAccessEndpointTargetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetVerifiedAccessEndpointTargetsInput"}
	if v.VerifiedAccessEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessEndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetVerifiedAccessGroupPolicyInput(v *GetVerifiedAccessGroupPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetVerifiedAccessGroupPolicyInput"}
	if v.VerifiedAccessGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessGroupId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetVpnConnectionDeviceSampleConfigurationInput(v *GetVpnConnectionDeviceSampleConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetVpnConnectionDeviceSampleConfigurationInput"}
	if v.VpnConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpnConnectionId"))
	}
	if v.VpnConnectionDeviceTypeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpnConnectionDeviceTypeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetVpnTunnelReplacementStatusInput(v *GetVpnTunnelReplacementStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetVpnTunnelReplacementStatusInput"}
	if v.VpnConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpnConnectionId"))
	}
	if v.VpnTunnelOutsideIpAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpnTunnelOutsideIpAddress"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpImportClientVpnClientCertificateRevocationListInput(v *ImportClientVpnClientCertificateRevocationListInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportClientVpnClientCertificateRevocationListInput"}
	if v.ClientVpnEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientVpnEndpointId"))
	}
	if v.CertificateRevocationList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CertificateRevocationList"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpImportInstanceInput(v *ImportInstanceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportInstanceInput"}
	if v.DiskImages != nil {
		if err := validateDiskImageList(v.DiskImages); err != nil {
			invalidParams.AddNested("DiskImages", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.Platform) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Platform"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpImportKeyPairInput(v *ImportKeyPairInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportKeyPairInput"}
	if v.KeyName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyName"))
	}
	if v.PublicKeyMaterial == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PublicKeyMaterial"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpImportVolumeInput(v *ImportVolumeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportVolumeInput"}
	if v.AvailabilityZone == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZone"))
	}
	if v.Image == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Image"))
	} else if v.Image != nil {
		if err := validateDiskImageDetail(v.Image); err != nil {
			invalidParams.AddNested("Image", err.(smithy.InvalidParamsError))
		}
	}
	if v.Volume == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Volume"))
	} else if v.Volume != nil {
		if err := validateVolumeDetail(v.Volume); err != nil {
			invalidParams.AddNested("Volume", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpLockSnapshotInput(v *LockSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LockSnapshotInput"}
	if v.SnapshotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotId"))
	}
	if len(v.LockMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LockMode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyAddressAttributeInput(v *ModifyAddressAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyAddressAttributeInput"}
	if v.AllocationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AllocationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyAvailabilityZoneGroupInput(v *ModifyAvailabilityZoneGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyAvailabilityZoneGroupInput"}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if len(v.OptInStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("OptInStatus"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyCapacityReservationFleetInput(v *ModifyCapacityReservationFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyCapacityReservationFleetInput"}
	if v.CapacityReservationFleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapacityReservationFleetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyCapacityReservationInput(v *ModifyCapacityReservationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyCapacityReservationInput"}
	if v.CapacityReservationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapacityReservationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyClientVpnEndpointInput(v *ModifyClientVpnEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyClientVpnEndpointInput"}
	if v.ClientVpnEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientVpnEndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyDefaultCreditSpecificationInput(v *ModifyDefaultCreditSpecificationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyDefaultCreditSpecificationInput"}
	if len(v.InstanceFamily) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceFamily"))
	}
	if v.CpuCredits == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CpuCredits"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyEbsDefaultKmsKeyIdInput(v *ModifyEbsDefaultKmsKeyIdInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyEbsDefaultKmsKeyIdInput"}
	if v.KmsKeyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KmsKeyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyFleetInput(v *ModifyFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyFleetInput"}
	if v.LaunchTemplateConfigs != nil {
		if err := validateFleetLaunchTemplateConfigListRequest(v.LaunchTemplateConfigs); err != nil {
			invalidParams.AddNested("LaunchTemplateConfigs", err.(smithy.InvalidParamsError))
		}
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if v.TargetCapacitySpecification != nil {
		if err := validateTargetCapacitySpecificationRequest(v.TargetCapacitySpecification); err != nil {
			invalidParams.AddNested("TargetCapacitySpecification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyFpgaImageAttributeInput(v *ModifyFpgaImageAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyFpgaImageAttributeInput"}
	if v.FpgaImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FpgaImageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyHostsInput(v *ModifyHostsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyHostsInput"}
	if v.HostIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HostIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyIdentityIdFormatInput(v *ModifyIdentityIdFormatInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyIdentityIdFormatInput"}
	if v.Resource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resource"))
	}
	if v.UseLongIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UseLongIds"))
	}
	if v.PrincipalArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyIdFormatInput(v *ModifyIdFormatInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyIdFormatInput"}
	if v.Resource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resource"))
	}
	if v.UseLongIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UseLongIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyImageAttributeInput(v *ModifyImageAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyImageAttributeInput"}
	if v.ImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyInstanceAttributeInput(v *ModifyInstanceAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyInstanceAttributeInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyInstanceCapacityReservationAttributesInput(v *ModifyInstanceCapacityReservationAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyInstanceCapacityReservationAttributesInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.CapacityReservationSpecification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapacityReservationSpecification"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyInstanceCpuOptionsInput(v *ModifyInstanceCpuOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyInstanceCpuOptionsInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.CoreCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CoreCount"))
	}
	if v.ThreadsPerCore == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ThreadsPerCore"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyInstanceCreditSpecificationInput(v *ModifyInstanceCreditSpecificationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyInstanceCreditSpecificationInput"}
	if v.InstanceCreditSpecifications == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceCreditSpecifications"))
	} else if v.InstanceCreditSpecifications != nil {
		if err := validateInstanceCreditSpecificationListRequest(v.InstanceCreditSpecifications); err != nil {
			invalidParams.AddNested("InstanceCreditSpecifications", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyInstanceEventStartTimeInput(v *ModifyInstanceEventStartTimeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyInstanceEventStartTimeInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.InstanceEventId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceEventId"))
	}
	if v.NotBefore == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NotBefore"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyInstanceEventWindowInput(v *ModifyInstanceEventWindowInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyInstanceEventWindowInput"}
	if v.InstanceEventWindowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceEventWindowId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyInstanceMaintenanceOptionsInput(v *ModifyInstanceMaintenanceOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyInstanceMaintenanceOptionsInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyInstanceMetadataOptionsInput(v *ModifyInstanceMetadataOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyInstanceMetadataOptionsInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyInstancePlacementInput(v *ModifyInstancePlacementInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyInstancePlacementInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyIpamInput(v *ModifyIpamInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyIpamInput"}
	if v.IpamId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyIpamPoolInput(v *ModifyIpamPoolInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyIpamPoolInput"}
	if v.IpamPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyIpamResourceCidrInput(v *ModifyIpamResourceCidrInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyIpamResourceCidrInput"}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.ResourceCidr == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceCidr"))
	}
	if v.ResourceRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceRegion"))
	}
	if v.CurrentIpamScopeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CurrentIpamScopeId"))
	}
	if v.Monitored == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Monitored"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyIpamResourceDiscoveryInput(v *ModifyIpamResourceDiscoveryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyIpamResourceDiscoveryInput"}
	if v.IpamResourceDiscoveryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamResourceDiscoveryId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyIpamScopeInput(v *ModifyIpamScopeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyIpamScopeInput"}
	if v.IpamScopeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamScopeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyLocalGatewayRouteInput(v *ModifyLocalGatewayRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyLocalGatewayRouteInput"}
	if v.LocalGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocalGatewayRouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyManagedPrefixListInput(v *ModifyManagedPrefixListInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyManagedPrefixListInput"}
	if v.PrefixListId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrefixListId"))
	}
	if v.AddEntries != nil {
		if err := validateAddPrefixListEntries(v.AddEntries); err != nil {
			invalidParams.AddNested("AddEntries", err.(smithy.InvalidParamsError))
		}
	}
	if v.RemoveEntries != nil {
		if err := validateRemovePrefixListEntries(v.RemoveEntries); err != nil {
			invalidParams.AddNested("RemoveEntries", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyNetworkInterfaceAttributeInput(v *ModifyNetworkInterfaceAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyNetworkInterfaceAttributeInput"}
	if v.NetworkInterfaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyPrivateDnsNameOptionsInput(v *ModifyPrivateDnsNameOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyPrivateDnsNameOptionsInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyReservedInstancesInput(v *ModifyReservedInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyReservedInstancesInput"}
	if v.ReservedInstancesIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReservedInstancesIds"))
	}
	if v.TargetConfigurations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetConfigurations"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifySecurityGroupRulesInput(v *ModifySecurityGroupRulesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifySecurityGroupRulesInput"}
	if v.GroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
	}
	if v.SecurityGroupRules == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupRules"))
	} else if v.SecurityGroupRules != nil {
		if err := validateSecurityGroupRuleUpdateList(v.SecurityGroupRules); err != nil {
			invalidParams.AddNested("SecurityGroupRules", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifySnapshotAttributeInput(v *ModifySnapshotAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifySnapshotAttributeInput"}
	if v.SnapshotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifySnapshotTierInput(v *ModifySnapshotTierInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifySnapshotTierInput"}
	if v.SnapshotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifySpotFleetRequestInput(v *ModifySpotFleetRequestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifySpotFleetRequestInput"}
	if v.SpotFleetRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SpotFleetRequestId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifySubnetAttributeInput(v *ModifySubnetAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifySubnetAttributeInput"}
	if v.SubnetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyTrafficMirrorFilterNetworkServicesInput(v *ModifyTrafficMirrorFilterNetworkServicesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyTrafficMirrorFilterNetworkServicesInput"}
	if v.TrafficMirrorFilterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrafficMirrorFilterId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyTrafficMirrorFilterRuleInput(v *ModifyTrafficMirrorFilterRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyTrafficMirrorFilterRuleInput"}
	if v.TrafficMirrorFilterRuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrafficMirrorFilterRuleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyTrafficMirrorSessionInput(v *ModifyTrafficMirrorSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyTrafficMirrorSessionInput"}
	if v.TrafficMirrorSessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrafficMirrorSessionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyTransitGatewayInput(v *ModifyTransitGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyTransitGatewayInput"}
	if v.TransitGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyTransitGatewayPrefixListReferenceInput(v *ModifyTransitGatewayPrefixListReferenceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyTransitGatewayPrefixListReferenceInput"}
	if v.TransitGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayRouteTableId"))
	}
	if v.PrefixListId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrefixListId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyTransitGatewayVpcAttachmentInput(v *ModifyTransitGatewayVpcAttachmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyTransitGatewayVpcAttachmentInput"}
	if v.TransitGatewayAttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayAttachmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVerifiedAccessEndpointInput(v *ModifyVerifiedAccessEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVerifiedAccessEndpointInput"}
	if v.VerifiedAccessEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessEndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVerifiedAccessEndpointPolicyInput(v *ModifyVerifiedAccessEndpointPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVerifiedAccessEndpointPolicyInput"}
	if v.VerifiedAccessEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessEndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVerifiedAccessGroupInput(v *ModifyVerifiedAccessGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVerifiedAccessGroupInput"}
	if v.VerifiedAccessGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessGroupId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVerifiedAccessGroupPolicyInput(v *ModifyVerifiedAccessGroupPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVerifiedAccessGroupPolicyInput"}
	if v.VerifiedAccessGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessGroupId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVerifiedAccessInstanceInput(v *ModifyVerifiedAccessInstanceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVerifiedAccessInstanceInput"}
	if v.VerifiedAccessInstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessInstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVerifiedAccessInstanceLoggingConfigurationInput(v *ModifyVerifiedAccessInstanceLoggingConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVerifiedAccessInstanceLoggingConfigurationInput"}
	if v.VerifiedAccessInstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessInstanceId"))
	}
	if v.AccessLogs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessLogs"))
	} else if v.AccessLogs != nil {
		if err := validateVerifiedAccessLogOptions(v.AccessLogs); err != nil {
			invalidParams.AddNested("AccessLogs", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVerifiedAccessTrustProviderInput(v *ModifyVerifiedAccessTrustProviderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVerifiedAccessTrustProviderInput"}
	if v.VerifiedAccessTrustProviderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifiedAccessTrustProviderId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVolumeAttributeInput(v *ModifyVolumeAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVolumeAttributeInput"}
	if v.VolumeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VolumeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVolumeInput(v *ModifyVolumeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVolumeInput"}
	if v.VolumeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VolumeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVpcAttributeInput(v *ModifyVpcAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVpcAttributeInput"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVpcBlockPublicAccessExclusionInput(v *ModifyVpcBlockPublicAccessExclusionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVpcBlockPublicAccessExclusionInput"}
	if v.ExclusionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExclusionId"))
	}
	if len(v.InternetGatewayExclusionMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InternetGatewayExclusionMode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVpcBlockPublicAccessOptionsInput(v *ModifyVpcBlockPublicAccessOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVpcBlockPublicAccessOptionsInput"}
	if len(v.InternetGatewayBlockMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InternetGatewayBlockMode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVpcEndpointConnectionNotificationInput(v *ModifyVpcEndpointConnectionNotificationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVpcEndpointConnectionNotificationInput"}
	if v.ConnectionNotificationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionNotificationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVpcEndpointInput(v *ModifyVpcEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVpcEndpointInput"}
	if v.VpcEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcEndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVpcEndpointServiceConfigurationInput(v *ModifyVpcEndpointServiceConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVpcEndpointServiceConfigurationInput"}
	if v.ServiceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVpcEndpointServicePayerResponsibilityInput(v *ModifyVpcEndpointServicePayerResponsibilityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVpcEndpointServicePayerResponsibilityInput"}
	if v.ServiceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceId"))
	}
	if len(v.PayerResponsibility) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PayerResponsibility"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVpcEndpointServicePermissionsInput(v *ModifyVpcEndpointServicePermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVpcEndpointServicePermissionsInput"}
	if v.ServiceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVpcPeeringConnectionOptionsInput(v *ModifyVpcPeeringConnectionOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVpcPeeringConnectionOptionsInput"}
	if v.VpcPeeringConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcPeeringConnectionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVpcTenancyInput(v *ModifyVpcTenancyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVpcTenancyInput"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if len(v.InstanceTenancy) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceTenancy"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVpnConnectionInput(v *ModifyVpnConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVpnConnectionInput"}
	if v.VpnConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpnConnectionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVpnConnectionOptionsInput(v *ModifyVpnConnectionOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVpnConnectionOptionsInput"}
	if v.VpnConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpnConnectionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVpnTunnelCertificateInput(v *ModifyVpnTunnelCertificateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVpnTunnelCertificateInput"}
	if v.VpnConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpnConnectionId"))
	}
	if v.VpnTunnelOutsideIpAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpnTunnelOutsideIpAddress"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyVpnTunnelOptionsInput(v *ModifyVpnTunnelOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyVpnTunnelOptionsInput"}
	if v.VpnConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpnConnectionId"))
	}
	if v.VpnTunnelOutsideIpAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpnTunnelOutsideIpAddress"))
	}
	if v.TunnelOptions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TunnelOptions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpMonitorInstancesInput(v *MonitorInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MonitorInstancesInput"}
	if v.InstanceIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpMoveAddressToVpcInput(v *MoveAddressToVpcInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MoveAddressToVpcInput"}
	if v.PublicIp == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PublicIp"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpMoveByoipCidrToIpamInput(v *MoveByoipCidrToIpamInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MoveByoipCidrToIpamInput"}
	if v.Cidr == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cidr"))
	}
	if v.IpamPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamPoolId"))
	}
	if v.IpamPoolOwner == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamPoolOwner"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpMoveCapacityReservationInstancesInput(v *MoveCapacityReservationInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MoveCapacityReservationInstancesInput"}
	if v.SourceCapacityReservationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceCapacityReservationId"))
	}
	if v.DestinationCapacityReservationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCapacityReservationId"))
	}
	if v.InstanceCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceCount"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpProvisionByoipCidrInput(v *ProvisionByoipCidrInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProvisionByoipCidrInput"}
	if v.Cidr == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cidr"))
	}
	if v.CidrAuthorizationContext != nil {
		if err := validateCidrAuthorizationContext(v.CidrAuthorizationContext); err != nil {
			invalidParams.AddNested("CidrAuthorizationContext", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpProvisionIpamByoasnInput(v *ProvisionIpamByoasnInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProvisionIpamByoasnInput"}
	if v.IpamId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamId"))
	}
	if v.Asn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Asn"))
	}
	if v.AsnAuthorizationContext == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AsnAuthorizationContext"))
	} else if v.AsnAuthorizationContext != nil {
		if err := validateAsnAuthorizationContext(v.AsnAuthorizationContext); err != nil {
			invalidParams.AddNested("AsnAuthorizationContext", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpProvisionIpamPoolCidrInput(v *ProvisionIpamPoolCidrInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProvisionIpamPoolCidrInput"}
	if v.IpamPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpProvisionPublicIpv4PoolCidrInput(v *ProvisionPublicIpv4PoolCidrInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProvisionPublicIpv4PoolCidrInput"}
	if v.IpamPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamPoolId"))
	}
	if v.PoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PoolId"))
	}
	if v.NetmaskLength == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetmaskLength"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPurchaseCapacityBlockExtensionInput(v *PurchaseCapacityBlockExtensionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PurchaseCapacityBlockExtensionInput"}
	if v.CapacityBlockExtensionOfferingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapacityBlockExtensionOfferingId"))
	}
	if v.CapacityReservationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapacityReservationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPurchaseCapacityBlockInput(v *PurchaseCapacityBlockInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PurchaseCapacityBlockInput"}
	if v.CapacityBlockOfferingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapacityBlockOfferingId"))
	}
	if len(v.InstancePlatform) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InstancePlatform"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPurchaseHostReservationInput(v *PurchaseHostReservationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PurchaseHostReservationInput"}
	if v.HostIdSet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HostIdSet"))
	}
	if v.OfferingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OfferingId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPurchaseReservedInstancesOfferingInput(v *PurchaseReservedInstancesOfferingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PurchaseReservedInstancesOfferingInput"}
	if v.InstanceCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceCount"))
	}
	if v.ReservedInstancesOfferingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReservedInstancesOfferingId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPurchaseScheduledInstancesInput(v *PurchaseScheduledInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PurchaseScheduledInstancesInput"}
	if v.PurchaseRequests == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PurchaseRequests"))
	} else if v.PurchaseRequests != nil {
		if err := validatePurchaseRequestSet(v.PurchaseRequests); err != nil {
			invalidParams.AddNested("PurchaseRequests", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRebootInstancesInput(v *RebootInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RebootInstancesInput"}
	if v.InstanceIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRegisterImageInput(v *RegisterImageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterImageInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRegisterInstanceEventNotificationAttributesInput(v *RegisterInstanceEventNotificationAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterInstanceEventNotificationAttributesInput"}
	if v.InstanceTagAttribute == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceTagAttribute"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRegisterTransitGatewayMulticastGroupMembersInput(v *RegisterTransitGatewayMulticastGroupMembersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterTransitGatewayMulticastGroupMembersInput"}
	if v.TransitGatewayMulticastDomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayMulticastDomainId"))
	}
	if v.NetworkInterfaceIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRegisterTransitGatewayMulticastGroupSourcesInput(v *RegisterTransitGatewayMulticastGroupSourcesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterTransitGatewayMulticastGroupSourcesInput"}
	if v.TransitGatewayMulticastDomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayMulticastDomainId"))
	}
	if v.NetworkInterfaceIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRejectCapacityReservationBillingOwnershipInput(v *RejectCapacityReservationBillingOwnershipInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RejectCapacityReservationBillingOwnershipInput"}
	if v.CapacityReservationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapacityReservationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRejectTransitGatewayPeeringAttachmentInput(v *RejectTransitGatewayPeeringAttachmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RejectTransitGatewayPeeringAttachmentInput"}
	if v.TransitGatewayAttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayAttachmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRejectTransitGatewayVpcAttachmentInput(v *RejectTransitGatewayVpcAttachmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RejectTransitGatewayVpcAttachmentInput"}
	if v.TransitGatewayAttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayAttachmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRejectVpcEndpointConnectionsInput(v *RejectVpcEndpointConnectionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RejectVpcEndpointConnectionsInput"}
	if v.ServiceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceId"))
	}
	if v.VpcEndpointIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcEndpointIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRejectVpcPeeringConnectionInput(v *RejectVpcPeeringConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RejectVpcPeeringConnectionInput"}
	if v.VpcPeeringConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcPeeringConnectionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpReleaseHostsInput(v *ReleaseHostsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReleaseHostsInput"}
	if v.HostIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HostIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpReleaseIpamPoolAllocationInput(v *ReleaseIpamPoolAllocationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReleaseIpamPoolAllocationInput"}
	if v.IpamPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamPoolId"))
	}
	if v.Cidr == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cidr"))
	}
	if v.IpamPoolAllocationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpamPoolAllocationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpReplaceIamInstanceProfileAssociationInput(v *ReplaceIamInstanceProfileAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReplaceIamInstanceProfileAssociationInput"}
	if v.IamInstanceProfile == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IamInstanceProfile"))
	}
	if v.AssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpReplaceNetworkAclAssociationInput(v *ReplaceNetworkAclAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReplaceNetworkAclAssociationInput"}
	if v.AssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
	}
	if v.NetworkAclId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkAclId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpReplaceNetworkAclEntryInput(v *ReplaceNetworkAclEntryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReplaceNetworkAclEntryInput"}
	if v.NetworkAclId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkAclId"))
	}
	if v.RuleNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleNumber"))
	}
	if v.Protocol == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
	}
	if len(v.RuleAction) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RuleAction"))
	}
	if v.Egress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Egress"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpReplaceRouteInput(v *ReplaceRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReplaceRouteInput"}
	if v.RouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpReplaceRouteTableAssociationInput(v *ReplaceRouteTableAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReplaceRouteTableAssociationInput"}
	if v.AssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
	}
	if v.RouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpReplaceTransitGatewayRouteInput(v *ReplaceTransitGatewayRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReplaceTransitGatewayRouteInput"}
	if v.DestinationCidrBlock == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCidrBlock"))
	}
	if v.TransitGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayRouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpReplaceVpnTunnelInput(v *ReplaceVpnTunnelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReplaceVpnTunnelInput"}
	if v.VpnConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpnConnectionId"))
	}
	if v.VpnTunnelOutsideIpAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpnTunnelOutsideIpAddress"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpReportInstanceStatusInput(v *ReportInstanceStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReportInstanceStatusInput"}
	if v.Instances == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Instances"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if v.ReasonCodes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReasonCodes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRequestSpotFleetInput(v *RequestSpotFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RequestSpotFleetInput"}
	if v.SpotFleetRequestConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SpotFleetRequestConfig"))
	} else if v.SpotFleetRequestConfig != nil {
		if err := validateSpotFleetRequestConfigData(v.SpotFleetRequestConfig); err != nil {
			invalidParams.AddNested("SpotFleetRequestConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRequestSpotInstancesInput(v *RequestSpotInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RequestSpotInstancesInput"}
	if v.LaunchSpecification != nil {
		if err := validateRequestSpotLaunchSpecification(v.LaunchSpecification); err != nil {
			invalidParams.AddNested("LaunchSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpResetAddressAttributeInput(v *ResetAddressAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResetAddressAttributeInput"}
	if v.AllocationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AllocationId"))
	}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpResetFpgaImageAttributeInput(v *ResetFpgaImageAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResetFpgaImageAttributeInput"}
	if v.FpgaImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FpgaImageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpResetImageAttributeInput(v *ResetImageAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResetImageAttributeInput"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if v.ImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpResetInstanceAttributeInput(v *ResetInstanceAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResetInstanceAttributeInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpResetNetworkInterfaceAttributeInput(v *ResetNetworkInterfaceAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResetNetworkInterfaceAttributeInput"}
	if v.NetworkInterfaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpResetSnapshotAttributeInput(v *ResetSnapshotAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResetSnapshotAttributeInput"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if v.SnapshotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRestoreAddressToClassicInput(v *RestoreAddressToClassicInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RestoreAddressToClassicInput"}
	if v.PublicIp == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PublicIp"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRestoreImageFromRecycleBinInput(v *RestoreImageFromRecycleBinInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RestoreImageFromRecycleBinInput"}
	if v.ImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRestoreManagedPrefixListVersionInput(v *RestoreManagedPrefixListVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RestoreManagedPrefixListVersionInput"}
	if v.PrefixListId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrefixListId"))
	}
	if v.PreviousVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PreviousVersion"))
	}
	if v.CurrentVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CurrentVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRestoreSnapshotFromRecycleBinInput(v *RestoreSnapshotFromRecycleBinInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RestoreSnapshotFromRecycleBinInput"}
	if v.SnapshotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRestoreSnapshotTierInput(v *RestoreSnapshotTierInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RestoreSnapshotTierInput"}
	if v.SnapshotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRevokeClientVpnIngressInput(v *RevokeClientVpnIngressInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RevokeClientVpnIngressInput"}
	if v.ClientVpnEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientVpnEndpointId"))
	}
	if v.TargetNetworkCidr == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetNetworkCidr"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRevokeSecurityGroupEgressInput(v *RevokeSecurityGroupEgressInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RevokeSecurityGroupEgressInput"}
	if v.GroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRunInstancesInput(v *RunInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RunInstancesInput"}
	if v.MaxCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxCount"))
	}
	if v.MinCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MinCount"))
	}
	if v.Monitoring != nil {
		if err := validateRunInstancesMonitoringEnabled(v.Monitoring); err != nil {
			invalidParams.AddNested("Monitoring", err.(smithy.InvalidParamsError))
		}
	}
	if v.ElasticGpuSpecification != nil {
		if err := validateElasticGpuSpecifications(v.ElasticGpuSpecification); err != nil {
			invalidParams.AddNested("ElasticGpuSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.ElasticInferenceAccelerators != nil {
		if err := validateElasticInferenceAccelerators(v.ElasticInferenceAccelerators); err != nil {
			invalidParams.AddNested("ElasticInferenceAccelerators", err.(smithy.InvalidParamsError))
		}
	}
	if v.CreditSpecification != nil {
		if err := validateCreditSpecificationRequest(v.CreditSpecification); err != nil {
			invalidParams.AddNested("CreditSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRunScheduledInstancesInput(v *RunScheduledInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RunScheduledInstancesInput"}
	if v.LaunchSpecification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchSpecification"))
	} else if v.LaunchSpecification != nil {
		if err := validateScheduledInstancesLaunchSpecification(v.LaunchSpecification); err != nil {
			invalidParams.AddNested("LaunchSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.ScheduledInstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScheduledInstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchLocalGatewayRoutesInput(v *SearchLocalGatewayRoutesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchLocalGatewayRoutesInput"}
	if v.LocalGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocalGatewayRouteTableId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchTransitGatewayMulticastGroupsInput(v *SearchTransitGatewayMulticastGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchTransitGatewayMulticastGroupsInput"}
	if v.TransitGatewayMulticastDomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayMulticastDomainId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchTransitGatewayRoutesInput(v *SearchTransitGatewayRoutesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchTransitGatewayRoutesInput"}
	if v.TransitGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransitGatewayRouteTableId"))
	}
	if v.Filters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSendDiagnosticInterruptInput(v *SendDiagnosticInterruptInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SendDiagnosticInterruptInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartDeclarativePoliciesReportInput(v *StartDeclarativePoliciesReportInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartDeclarativePoliciesReportInput"}
	if v.S3Bucket == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3Bucket"))
	}
	if v.TargetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartInstancesInput(v *StartInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartInstancesInput"}
	if v.InstanceIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartNetworkInsightsAccessScopeAnalysisInput(v *StartNetworkInsightsAccessScopeAnalysisInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartNetworkInsightsAccessScopeAnalysisInput"}
	if v.NetworkInsightsAccessScopeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInsightsAccessScopeId"))
	}
	if v.ClientToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartNetworkInsightsAnalysisInput(v *StartNetworkInsightsAnalysisInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartNetworkInsightsAnalysisInput"}
	if v.NetworkInsightsPathId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInsightsPathId"))
	}
	if v.ClientToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartVpcEndpointServicePrivateDnsVerificationInput(v *StartVpcEndpointServicePrivateDnsVerificationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartVpcEndpointServicePrivateDnsVerificationInput"}
	if v.ServiceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopInstancesInput(v *StopInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopInstancesInput"}
	if v.InstanceIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTerminateClientVpnConnectionsInput(v *TerminateClientVpnConnectionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TerminateClientVpnConnectionsInput"}
	if v.ClientVpnEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientVpnEndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTerminateInstancesInput(v *TerminateInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TerminateInstancesInput"}
	if v.InstanceIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUnassignIpv6AddressesInput(v *UnassignIpv6AddressesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UnassignIpv6AddressesInput"}
	if v.NetworkInterfaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUnassignPrivateIpAddressesInput(v *UnassignPrivateIpAddressesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UnassignPrivateIpAddressesInput"}
	if v.NetworkInterfaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUnassignPrivateNatGatewayAddressInput(v *UnassignPrivateNatGatewayAddressInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UnassignPrivateNatGatewayAddressInput"}
	if v.NatGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NatGatewayId"))
	}
	if v.PrivateIpAddresses == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrivateIpAddresses"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUnlockSnapshotInput(v *UnlockSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UnlockSnapshotInput"}
	if v.SnapshotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUnmonitorInstancesInput(v *UnmonitorInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UnmonitorInstancesInput"}
	if v.InstanceIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpWithdrawByoipCidrInput(v *WithdrawByoipCidrInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WithdrawByoipCidrInput"}
	if v.Cidr == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cidr"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}
