xref: /dports/net-p2p/go-ethereum/aws-sdk-go-v2-credentials-v1.1.1/service/ec2/validators.go

// 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 validateOpCreateVpc struct {
}

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

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

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

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

type validateOpUpdateSecurityGroupRuleDescriptionsIngress struct {
}

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

func (m *validateOpUpdateSecurityGroupRuleDescriptionsIngress) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateSecurityGroupRuleDescriptionsIngressInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateSecurityGroupRuleDescriptionsIngressInput(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 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 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 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 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 addOpAssociateIamInstanceProfileValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateIamInstanceProfile{}, middleware.After)
}

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

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

func addOpAssociateTransitGatewayRouteTableValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociateTransitGatewayRouteTable{}, 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 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 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 addOpCancelExportTaskValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCancelExportTask{}, 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 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 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 addOpCreateInstanceExportTaskValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateInstanceExportTask{}, 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 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 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 addOpCreateReservedInstancesListingValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateReservedInstancesListing{}, 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 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 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 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 addOpCreateVolumeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateVolume{}, 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 addOpCreateVpcValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateVpc{}, 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 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 addOpDeleteInternetGatewayValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteInternetGateway{}, 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 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 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 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 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 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 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 addOpDeleteVolumeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteVolume{}, 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 addOpDeregisterImageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeregisterImage{}, middleware.After)
}

func addOpDescribeByoipCidrsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeByoipCidrs{}, 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 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 addOpDisableFastSnapshotRestoresValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisableFastSnapshotRestores{}, 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 addOpDisassociateClientVpnTargetNetworkValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateClientVpnTargetNetwork{}, middleware.After)
}

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

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

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

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

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

func addOpEnableFastSnapshotRestoresValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpEnableFastSnapshotRestores{}, 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 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 addOpGetDefaultCreditSpecificationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetDefaultCreditSpecification{}, 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 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 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 addOpGetTransitGatewayAttachmentPropagationsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetTransitGatewayAttachmentPropagations{}, 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 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 addOpModifyAvailabilityZoneGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyAvailabilityZoneGroup{}, 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 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 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 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 addOpModifyReservedInstancesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyReservedInstances{}, middleware.After)
}

func addOpModifySnapshotAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifySnapshotAttribute{}, 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 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 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 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 addOpProvisionByoipCidrValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpProvisionByoipCidr{}, 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 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 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 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 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 addOpRestoreManagedPrefixListVersionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRestoreManagedPrefixListVersion{}, 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 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 addOpStartInstancesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartInstances{}, 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 addOpUnmonitorInstancesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUnmonitorInstances{}, middleware.After)
}

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

func addOpUpdateSecurityGroupRuleDescriptionsIngressValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateSecurityGroupRuleDescriptionsIngress{}, 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 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.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 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 validatePurchaseRequest(v *types.PurchaseRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PurchaseRequest"}
	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 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 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 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 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 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 validateVolumeDetail(v *types.VolumeDetail) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VolumeDetail"}
	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 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 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 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 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 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 validateOpAssociateSubnetCidrBlockInput(v *AssociateSubnetCidrBlockInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateSubnetCidrBlockInput"}
	if v.Ipv6CidrBlock == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Ipv6CidrBlock"))
	}
	if v.SubnetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetId"))
	}
	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 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.Groups == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Groups"))
	}
	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 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.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.NetworkInterfaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceId"))
	}
	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 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 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 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 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 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 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 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"))
	}
	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 len(v.TrafficType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TrafficType"))
	}
	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 validateOpCreateInstanceExportTaskInput(v *CreateInstanceExportTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateInstanceExportTaskInput"}
	if v.ExportToS3Task == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExportToS3Task"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if len(v.TargetEnvironment) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TargetEnvironment"))
	}
	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.DestinationCidrBlock == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCidrBlock"))
	}
	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.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.AllocationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AllocationId"))
	}
	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.Protocol == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
	}
	if len(v.RuleAction) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RuleAction"))
	}
	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 validateOpCreateNetworkInsightsPathInput(v *CreateNetworkInsightsPathInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateNetworkInsightsPathInput"}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	}
	if v.Destination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
	}
	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 validateOpCreateReservedInstancesListingInput(v *CreateReservedInstancesListingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateReservedInstancesListingInput"}
	if v.ClientToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
	}
	if v.PriceSchedules == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PriceSchedules"))
	}
	if v.ReservedInstancesId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReservedInstancesId"))
	}
	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"))
	}
	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 validateOpCreateSubnetInput(v *CreateSubnetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSubnetInput"}
	if v.CidrBlock == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CidrBlock"))
	}
	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 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 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 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 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 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 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 v.ServiceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateVpcInput(v *CreateVpcInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVpcInput"}
	if v.CidrBlock == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CidrBlock"))
	}
	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 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 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 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 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.DestinationCidrBlock == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCidrBlock"))
	}
	if v.LocalGatewayRouteTableId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocalGatewayRouteTableId"))
	}
	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 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 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 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 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 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 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 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 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 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 validateOpDescribeByoipCidrsInput(v *DescribeByoipCidrsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeByoipCidrsInput"}
	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 len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	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 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 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 validateOpDisableTransitGatewayRouteTablePropagationInput(v *DisableTransitGatewayRouteTablePropagationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisableTransitGatewayRouteTablePropagationInput"}
	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 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 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 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 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 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 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 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 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 validateOpEnableTransitGatewayRouteTablePropagationInput(v *EnableTransitGatewayRouteTablePropagationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableTransitGatewayRouteTablePropagationInput"}
	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 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 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 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 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 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 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 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 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 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 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 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.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.PrincipalArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalArn"))
	}
	if v.Resource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resource"))
	}
	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 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 validateOpModifyInstanceCreditSpecificationInput(v *ModifyInstanceCreditSpecificationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyInstanceCreditSpecificationInput"}
	if v.InstanceCreditSpecifications == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceCreditSpecifications"))
	}
	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 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 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 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 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 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 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 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 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 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 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.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 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 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.Protocol == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
	}
	if len(v.RuleAction) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RuleAction"))
	}
	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 validateOpReportInstanceStatusInput(v *ReportInstanceStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReportInstanceStatusInput"}
	if v.Instances == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Instances"))
	}
	if v.ReasonCodes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReasonCodes"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	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 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 len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	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 validateOpRestoreManagedPrefixListVersionInput(v *RestoreManagedPrefixListVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RestoreManagedPrefixListVersionInput"}
	if v.PrefixListId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrefixListId"))
	}
	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.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 v.Filters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
	}
	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 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 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.Ipv6Addresses == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Ipv6Addresses"))
	}
	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 v.PrivateIpAddresses == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrivateIpAddresses"))
	}
	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 validateOpUpdateSecurityGroupRuleDescriptionsEgressInput(v *UpdateSecurityGroupRuleDescriptionsEgressInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSecurityGroupRuleDescriptionsEgressInput"}
	if v.IpPermissions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpPermissions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateSecurityGroupRuleDescriptionsIngressInput(v *UpdateSecurityGroupRuleDescriptionsIngressInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSecurityGroupRuleDescriptionsIngressInput"}
	if v.IpPermissions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpPermissions"))
	}
	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
	}
}