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

package directconnect

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

type validateOpAcceptDirectConnectGatewayAssociationProposal struct {
}

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

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

type validateOpAllocateConnectionOnInterconnect struct {
}

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

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

type validateOpAllocateHostedConnection struct {
}

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

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

type validateOpAllocatePrivateVirtualInterface struct {
}

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

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

type validateOpAllocatePublicVirtualInterface struct {
}

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

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

type validateOpAllocateTransitVirtualInterface struct {
}

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

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

type validateOpAssociateConnectionWithLag struct {
}

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

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

type validateOpAssociateHostedConnection struct {
}

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

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

type validateOpAssociateMacSecKey struct {
}

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

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

type validateOpAssociateVirtualInterface struct {
}

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

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

type validateOpConfirmConnection struct {
}

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

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

type validateOpConfirmPrivateVirtualInterface struct {
}

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

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

type validateOpConfirmPublicVirtualInterface struct {
}

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

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

type validateOpConfirmTransitVirtualInterface struct {
}

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

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

type validateOpCreateConnection struct {
}

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

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

type validateOpCreateDirectConnectGatewayAssociation struct {
}

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

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

type validateOpCreateDirectConnectGatewayAssociationProposal struct {
}

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

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

type validateOpCreateDirectConnectGateway struct {
}

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

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

type validateOpCreateInterconnect struct {
}

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

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

type validateOpCreateLag struct {
}

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

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

type validateOpCreatePrivateVirtualInterface struct {
}

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

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

type validateOpCreatePublicVirtualInterface struct {
}

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

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

type validateOpCreateTransitVirtualInterface struct {
}

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

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

type validateOpDeleteConnection struct {
}

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

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

type validateOpDeleteDirectConnectGatewayAssociationProposal struct {
}

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

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

type validateOpDeleteDirectConnectGateway struct {
}

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

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

type validateOpDeleteInterconnect struct {
}

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

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

type validateOpDeleteLag struct {
}

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

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

type validateOpDeleteVirtualInterface struct {
}

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

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

type validateOpDescribeConnectionLoa struct {
}

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

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

type validateOpDescribeConnectionsOnInterconnect struct {
}

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

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

type validateOpDescribeHostedConnections struct {
}

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

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

type validateOpDescribeInterconnectLoa struct {
}

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

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

type validateOpDescribeLoa struct {
}

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

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

type validateOpDescribeRouterConfiguration struct {
}

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

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

type validateOpDescribeTags struct {
}

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

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

type validateOpDisassociateConnectionFromLag struct {
}

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

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

type validateOpDisassociateMacSecKey struct {
}

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

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

type validateOpStartBgpFailoverTest struct {
}

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

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

type validateOpStopBgpFailoverTest struct {
}

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

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

type validateOpTagResource struct {
}

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

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

type validateOpUntagResource struct {
}

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

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

type validateOpUpdateConnection struct {
}

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

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

type validateOpUpdateDirectConnectGateway struct {
}

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

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

type validateOpUpdateLag struct {
}

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

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

type validateOpUpdateVirtualInterfaceAttributes struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateNewPrivateVirtualInterface(v *types.NewPrivateVirtualInterface) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NewPrivateVirtualInterface"}
	if v.VirtualInterfaceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VirtualInterfaceName"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNewPrivateVirtualInterfaceAllocation(v *types.NewPrivateVirtualInterfaceAllocation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NewPrivateVirtualInterfaceAllocation"}
	if v.VirtualInterfaceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VirtualInterfaceName"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNewPublicVirtualInterface(v *types.NewPublicVirtualInterface) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NewPublicVirtualInterface"}
	if v.VirtualInterfaceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VirtualInterfaceName"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNewPublicVirtualInterfaceAllocation(v *types.NewPublicVirtualInterfaceAllocation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NewPublicVirtualInterfaceAllocation"}
	if v.VirtualInterfaceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VirtualInterfaceName"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNewTransitVirtualInterface(v *types.NewTransitVirtualInterface) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NewTransitVirtualInterface"}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNewTransitVirtualInterfaceAllocation(v *types.NewTransitVirtualInterfaceAllocation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NewTransitVirtualInterfaceAllocation"}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpAcceptDirectConnectGatewayAssociationProposalInput(v *AcceptDirectConnectGatewayAssociationProposalInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AcceptDirectConnectGatewayAssociationProposalInput"}
	if v.DirectConnectGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectConnectGatewayId"))
	}
	if v.ProposalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProposalId"))
	}
	if v.AssociatedGatewayOwnerAccount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssociatedGatewayOwnerAccount"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAllocateConnectionOnInterconnectInput(v *AllocateConnectionOnInterconnectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AllocateConnectionOnInterconnectInput"}
	if v.Bandwidth == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Bandwidth"))
	}
	if v.ConnectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionName"))
	}
	if v.OwnerAccount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OwnerAccount"))
	}
	if v.InterconnectId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InterconnectId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAllocateHostedConnectionInput(v *AllocateHostedConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AllocateHostedConnectionInput"}
	if v.ConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
	}
	if v.OwnerAccount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OwnerAccount"))
	}
	if v.Bandwidth == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Bandwidth"))
	}
	if v.ConnectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionName"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAllocatePrivateVirtualInterfaceInput(v *AllocatePrivateVirtualInterfaceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AllocatePrivateVirtualInterfaceInput"}
	if v.ConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
	}
	if v.OwnerAccount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OwnerAccount"))
	}
	if v.NewPrivateVirtualInterfaceAllocation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NewPrivateVirtualInterfaceAllocation"))
	} else if v.NewPrivateVirtualInterfaceAllocation != nil {
		if err := validateNewPrivateVirtualInterfaceAllocation(v.NewPrivateVirtualInterfaceAllocation); err != nil {
			invalidParams.AddNested("NewPrivateVirtualInterfaceAllocation", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAllocatePublicVirtualInterfaceInput(v *AllocatePublicVirtualInterfaceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AllocatePublicVirtualInterfaceInput"}
	if v.ConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
	}
	if v.OwnerAccount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OwnerAccount"))
	}
	if v.NewPublicVirtualInterfaceAllocation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NewPublicVirtualInterfaceAllocation"))
	} else if v.NewPublicVirtualInterfaceAllocation != nil {
		if err := validateNewPublicVirtualInterfaceAllocation(v.NewPublicVirtualInterfaceAllocation); err != nil {
			invalidParams.AddNested("NewPublicVirtualInterfaceAllocation", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAllocateTransitVirtualInterfaceInput(v *AllocateTransitVirtualInterfaceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AllocateTransitVirtualInterfaceInput"}
	if v.ConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
	}
	if v.OwnerAccount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OwnerAccount"))
	}
	if v.NewTransitVirtualInterfaceAllocation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NewTransitVirtualInterfaceAllocation"))
	} else if v.NewTransitVirtualInterfaceAllocation != nil {
		if err := validateNewTransitVirtualInterfaceAllocation(v.NewTransitVirtualInterfaceAllocation); err != nil {
			invalidParams.AddNested("NewTransitVirtualInterfaceAllocation", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateConnectionWithLagInput(v *AssociateConnectionWithLagInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateConnectionWithLagInput"}
	if v.ConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
	}
	if v.LagId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LagId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateHostedConnectionInput(v *AssociateHostedConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateHostedConnectionInput"}
	if v.ConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
	}
	if v.ParentConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParentConnectionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpAssociateVirtualInterfaceInput(v *AssociateVirtualInterfaceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateVirtualInterfaceInput"}
	if v.VirtualInterfaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VirtualInterfaceId"))
	}
	if v.ConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpConfirmTransitVirtualInterfaceInput(v *ConfirmTransitVirtualInterfaceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConfirmTransitVirtualInterfaceInput"}
	if v.VirtualInterfaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VirtualInterfaceId"))
	}
	if v.DirectConnectGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectConnectGatewayId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateConnectionInput(v *CreateConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionInput"}
	if v.Location == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Location"))
	}
	if v.Bandwidth == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Bandwidth"))
	}
	if v.ConnectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionName"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateDirectConnectGatewayAssociationProposalInput(v *CreateDirectConnectGatewayAssociationProposalInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDirectConnectGatewayAssociationProposalInput"}
	if v.DirectConnectGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectConnectGatewayId"))
	}
	if v.DirectConnectGatewayOwnerAccount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectConnectGatewayOwnerAccount"))
	}
	if v.GatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateInterconnectInput(v *CreateInterconnectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateInterconnectInput"}
	if v.InterconnectName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InterconnectName"))
	}
	if v.Bandwidth == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Bandwidth"))
	}
	if v.Location == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Location"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLagInput(v *CreateLagInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLagInput"}
	if v.Location == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Location"))
	}
	if v.ConnectionsBandwidth == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionsBandwidth"))
	}
	if v.LagName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LagName"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.ChildConnectionTags != nil {
		if err := validateTagList(v.ChildConnectionTags); err != nil {
			invalidParams.AddNested("ChildConnectionTags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePrivateVirtualInterfaceInput(v *CreatePrivateVirtualInterfaceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePrivateVirtualInterfaceInput"}
	if v.ConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
	}
	if v.NewPrivateVirtualInterface == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NewPrivateVirtualInterface"))
	} else if v.NewPrivateVirtualInterface != nil {
		if err := validateNewPrivateVirtualInterface(v.NewPrivateVirtualInterface); err != nil {
			invalidParams.AddNested("NewPrivateVirtualInterface", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePublicVirtualInterfaceInput(v *CreatePublicVirtualInterfaceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePublicVirtualInterfaceInput"}
	if v.ConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
	}
	if v.NewPublicVirtualInterface == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NewPublicVirtualInterface"))
	} else if v.NewPublicVirtualInterface != nil {
		if err := validateNewPublicVirtualInterface(v.NewPublicVirtualInterface); err != nil {
			invalidParams.AddNested("NewPublicVirtualInterface", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTransitVirtualInterfaceInput(v *CreateTransitVirtualInterfaceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTransitVirtualInterfaceInput"}
	if v.ConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
	}
	if v.NewTransitVirtualInterface == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NewTransitVirtualInterface"))
	} else if v.NewTransitVirtualInterface != nil {
		if err := validateNewTransitVirtualInterface(v.NewTransitVirtualInterface); err != nil {
			invalidParams.AddNested("NewTransitVirtualInterface", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpDisassociateConnectionFromLagInput(v *DisassociateConnectionFromLagInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateConnectionFromLagInput"}
	if v.ConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
	}
	if v.LagId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LagId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateMacSecKeyInput(v *DisassociateMacSecKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateMacSecKeyInput"}
	if v.ConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionId"))
	}
	if v.SecretARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecretARN"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpTagResourceInput(v *TagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	} else if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpUpdateDirectConnectGatewayInput(v *UpdateDirectConnectGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDirectConnectGatewayInput"}
	if v.DirectConnectGatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectConnectGatewayId"))
	}
	if v.NewDirectConnectGatewayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NewDirectConnectGatewayName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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