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

package mediaconnect

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

type validateOpAddBridgeOutputs struct {
}

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

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

type validateOpAddBridgeSources struct {
}

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

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

type validateOpAddFlowMediaStreams struct {
}

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

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

type validateOpAddFlowOutputs struct {
}

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

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

type validateOpAddFlowSources struct {
}

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

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

type validateOpAddFlowVpcInterfaces struct {
}

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

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

type validateOpCreateBridge struct {
}

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

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

type validateOpCreateFlow struct {
}

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

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

type validateOpCreateGateway struct {
}

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

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

type validateOpDeleteBridge struct {
}

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

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

type validateOpDeleteFlow struct {
}

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

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

type validateOpDeleteGateway struct {
}

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

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

type validateOpDeregisterGatewayInstance struct {
}

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

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

type validateOpDescribeBridge struct {
}

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

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

type validateOpDescribeFlow struct {
}

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

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

type validateOpDescribeGateway struct {
}

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

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

type validateOpDescribeGatewayInstance struct {
}

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

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

type validateOpDescribeOffering struct {
}

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

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

type validateOpDescribeReservation struct {
}

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

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

type validateOpGrantFlowEntitlements struct {
}

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

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

type validateOpListTagsForResource struct {
}

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

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

type validateOpPurchaseOffering struct {
}

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

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

type validateOpRemoveBridgeOutput struct {
}

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

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

type validateOpRemoveBridgeSource struct {
}

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

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

type validateOpRemoveFlowMediaStream struct {
}

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

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

type validateOpRemoveFlowOutput struct {
}

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

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

type validateOpRemoveFlowSource struct {
}

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

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

type validateOpRemoveFlowVpcInterface struct {
}

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

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

type validateOpRevokeFlowEntitlement struct {
}

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

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

type validateOpStartFlow struct {
}

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

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

type validateOpStopFlow struct {
}

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

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

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

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

type validateOpUpdateBridgeOutput struct {
}

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

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

type validateOpUpdateBridgeSource struct {
}

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

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

type validateOpUpdateBridgeState struct {
}

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

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

type validateOpUpdateFlowEntitlement struct {
}

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

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

type validateOpUpdateFlow struct {
}

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

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

type validateOpUpdateFlowMediaStream struct {
}

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

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

type validateOpUpdateFlowOutput struct {
}

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

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

type validateOpUpdateFlowSource struct {
}

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

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

type validateOpUpdateGatewayInstance struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpStopFlowValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStopFlow{}, 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 addOpUpdateBridgeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateBridge{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateAddBridgeFlowSourceRequest(v *types.AddBridgeFlowSourceRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddBridgeFlowSourceRequest"}
	if v.FlowArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowArn"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAddBridgeNetworkOutputRequest(v *types.AddBridgeNetworkOutputRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddBridgeNetworkOutputRequest"}
	if v.IpAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpAddress"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.NetworkName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkName"))
	}
	if len(v.Protocol) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAddBridgeNetworkSourceRequest(v *types.AddBridgeNetworkSourceRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddBridgeNetworkSourceRequest"}
	if v.MulticastIp == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MulticastIp"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.NetworkName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkName"))
	}
	if len(v.Protocol) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAddBridgeOutputRequest(v *types.AddBridgeOutputRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddBridgeOutputRequest"}
	if v.NetworkOutput != nil {
		if err := validateAddBridgeNetworkOutputRequest(v.NetworkOutput); err != nil {
			invalidParams.AddNested("NetworkOutput", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAddBridgeSourceRequest(v *types.AddBridgeSourceRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddBridgeSourceRequest"}
	if v.FlowSource != nil {
		if err := validateAddBridgeFlowSourceRequest(v.FlowSource); err != nil {
			invalidParams.AddNested("FlowSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.NetworkSource != nil {
		if err := validateAddBridgeNetworkSourceRequest(v.NetworkSource); err != nil {
			invalidParams.AddNested("NetworkSource", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAddEgressGatewayBridgeRequest(v *types.AddEgressGatewayBridgeRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddEgressGatewayBridgeRequest"}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAddIngressGatewayBridgeRequest(v *types.AddIngressGatewayBridgeRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddIngressGatewayBridgeRequest"}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAddMaintenance(v *types.AddMaintenance) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddMaintenance"}
	if len(v.MaintenanceDay) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MaintenanceDay"))
	}
	if v.MaintenanceStartHour == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaintenanceStartHour"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAddMediaStreamRequest(v *types.AddMediaStreamRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddMediaStreamRequest"}
	if v.MediaStreamName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MediaStreamName"))
	}
	if len(v.MediaStreamType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MediaStreamType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAddOutputRequest(v *types.AddOutputRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddOutputRequest"}
	if v.Encryption != nil {
		if err := validateEncryption(v.Encryption); err != nil {
			invalidParams.AddNested("Encryption", err.(smithy.InvalidParamsError))
		}
	}
	if v.MediaStreamOutputConfigurations != nil {
		if err := validate__listOfMediaStreamOutputConfigurationRequest(v.MediaStreamOutputConfigurations); err != nil {
			invalidParams.AddNested("MediaStreamOutputConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.Protocol) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDestinationConfigurationRequest(v *types.DestinationConfigurationRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DestinationConfigurationRequest"}
	if v.DestinationIp == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationIp"))
	}
	if v.Interface == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Interface"))
	} else if v.Interface != nil {
		if err := validateInterfaceRequest(v.Interface); err != nil {
			invalidParams.AddNested("Interface", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEncodingParametersRequest(v *types.EncodingParametersRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EncodingParametersRequest"}
	if len(v.EncoderProfile) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EncoderProfile"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateGatewayNetwork(v *types.GatewayNetwork) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GatewayNetwork"}
	if v.CidrBlock == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CidrBlock"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGrantEntitlementRequest(v *types.GrantEntitlementRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GrantEntitlementRequest"}
	if v.Encryption != nil {
		if err := validateEncryption(v.Encryption); err != nil {
			invalidParams.AddNested("Encryption", err.(smithy.InvalidParamsError))
		}
	}
	if v.Subscribers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Subscribers"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInputConfigurationRequest(v *types.InputConfigurationRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InputConfigurationRequest"}
	if v.Interface == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Interface"))
	} else if v.Interface != nil {
		if err := validateInterfaceRequest(v.Interface); err != nil {
			invalidParams.AddNested("Interface", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateMediaStreamOutputConfigurationRequest(v *types.MediaStreamOutputConfigurationRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MediaStreamOutputConfigurationRequest"}
	if v.DestinationConfigurations != nil {
		if err := validate__listOfDestinationConfigurationRequest(v.DestinationConfigurations); err != nil {
			invalidParams.AddNested("DestinationConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.EncodingName) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EncodingName"))
	}
	if v.EncodingParameters != nil {
		if err := validateEncodingParametersRequest(v.EncodingParameters); err != nil {
			invalidParams.AddNested("EncodingParameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.MediaStreamName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MediaStreamName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMediaStreamSourceConfigurationRequest(v *types.MediaStreamSourceConfigurationRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MediaStreamSourceConfigurationRequest"}
	if len(v.EncodingName) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EncodingName"))
	}
	if v.InputConfigurations != nil {
		if err := validate__listOfInputConfigurationRequest(v.InputConfigurations); err != nil {
			invalidParams.AddNested("InputConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.MediaStreamName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MediaStreamName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSetSourceRequest(v *types.SetSourceRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetSourceRequest"}
	if v.Decryption != nil {
		if err := validateEncryption(v.Decryption); err != nil {
			invalidParams.AddNested("Decryption", err.(smithy.InvalidParamsError))
		}
	}
	if v.MediaStreamSourceConfigurations != nil {
		if err := validate__listOfMediaStreamSourceConfigurationRequest(v.MediaStreamSourceConfigurations); err != nil {
			invalidParams.AddNested("MediaStreamSourceConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.GatewayBridgeSource != nil {
		if err := validateSetGatewayBridgeSourceRequest(v.GatewayBridgeSource); err != nil {
			invalidParams.AddNested("GatewayBridgeSource", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateVpcInterfaceRequest(v *types.VpcInterfaceRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VpcInterfaceRequest"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.SecurityGroupIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupIds"))
	}
	if v.SubnetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddBridgeOutputsInput(v *AddBridgeOutputsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddBridgeOutputsInput"}
	if v.BridgeArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BridgeArn"))
	}
	if v.Outputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Outputs"))
	} else if v.Outputs != nil {
		if err := validate__listOfAddBridgeOutputRequest(v.Outputs); err != nil {
			invalidParams.AddNested("Outputs", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddBridgeSourcesInput(v *AddBridgeSourcesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddBridgeSourcesInput"}
	if v.BridgeArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BridgeArn"))
	}
	if v.Sources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Sources"))
	} else if v.Sources != nil {
		if err := validate__listOfAddBridgeSourceRequest(v.Sources); err != nil {
			invalidParams.AddNested("Sources", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddFlowMediaStreamsInput(v *AddFlowMediaStreamsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddFlowMediaStreamsInput"}
	if v.FlowArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowArn"))
	}
	if v.MediaStreams == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MediaStreams"))
	} else if v.MediaStreams != nil {
		if err := validate__listOfAddMediaStreamRequest(v.MediaStreams); err != nil {
			invalidParams.AddNested("MediaStreams", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddFlowOutputsInput(v *AddFlowOutputsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddFlowOutputsInput"}
	if v.FlowArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowArn"))
	}
	if v.Outputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Outputs"))
	} else if v.Outputs != nil {
		if err := validate__listOfAddOutputRequest(v.Outputs); err != nil {
			invalidParams.AddNested("Outputs", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddFlowSourcesInput(v *AddFlowSourcesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddFlowSourcesInput"}
	if v.FlowArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowArn"))
	}
	if v.Sources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Sources"))
	} else if v.Sources != nil {
		if err := validate__listOfSetSourceRequest(v.Sources); err != nil {
			invalidParams.AddNested("Sources", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddFlowVpcInterfacesInput(v *AddFlowVpcInterfacesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddFlowVpcInterfacesInput"}
	if v.FlowArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowArn"))
	}
	if v.VpcInterfaces == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcInterfaces"))
	} else if v.VpcInterfaces != nil {
		if err := validate__listOfVpcInterfaceRequest(v.VpcInterfaces); err != nil {
			invalidParams.AddNested("VpcInterfaces", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateBridgeInput(v *CreateBridgeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateBridgeInput"}
	if v.EgressGatewayBridge != nil {
		if err := validateAddEgressGatewayBridgeRequest(v.EgressGatewayBridge); err != nil {
			invalidParams.AddNested("EgressGatewayBridge", err.(smithy.InvalidParamsError))
		}
	}
	if v.IngressGatewayBridge != nil {
		if err := validateAddIngressGatewayBridgeRequest(v.IngressGatewayBridge); err != nil {
			invalidParams.AddNested("IngressGatewayBridge", err.(smithy.InvalidParamsError))
		}
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Outputs != nil {
		if err := validate__listOfAddBridgeOutputRequest(v.Outputs); err != nil {
			invalidParams.AddNested("Outputs", err.(smithy.InvalidParamsError))
		}
	}
	if v.PlacementArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PlacementArn"))
	}
	if v.Sources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Sources"))
	} else if v.Sources != nil {
		if err := validate__listOfAddBridgeSourceRequest(v.Sources); err != nil {
			invalidParams.AddNested("Sources", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFlowInput(v *CreateFlowInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFlowInput"}
	if v.Entitlements != nil {
		if err := validate__listOfGrantEntitlementRequest(v.Entitlements); err != nil {
			invalidParams.AddNested("Entitlements", err.(smithy.InvalidParamsError))
		}
	}
	if v.MediaStreams != nil {
		if err := validate__listOfAddMediaStreamRequest(v.MediaStreams); err != nil {
			invalidParams.AddNested("MediaStreams", err.(smithy.InvalidParamsError))
		}
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Outputs != nil {
		if err := validate__listOfAddOutputRequest(v.Outputs); err != nil {
			invalidParams.AddNested("Outputs", err.(smithy.InvalidParamsError))
		}
	}
	if v.Source != nil {
		if err := validateSetSourceRequest(v.Source); err != nil {
			invalidParams.AddNested("Source", err.(smithy.InvalidParamsError))
		}
	}
	if v.Sources != nil {
		if err := validate__listOfSetSourceRequest(v.Sources); err != nil {
			invalidParams.AddNested("Sources", err.(smithy.InvalidParamsError))
		}
	}
	if v.VpcInterfaces != nil {
		if err := validate__listOfVpcInterfaceRequest(v.VpcInterfaces); err != nil {
			invalidParams.AddNested("VpcInterfaces", err.(smithy.InvalidParamsError))
		}
	}
	if v.Maintenance != nil {
		if err := validateAddMaintenance(v.Maintenance); err != nil {
			invalidParams.AddNested("Maintenance", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateGatewayInput(v *CreateGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateGatewayInput"}
	if v.EgressCidrBlocks == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EgressCidrBlocks"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Networks == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Networks"))
	} else if v.Networks != nil {
		if err := validate__listOfGatewayNetwork(v.Networks); err != nil {
			invalidParams.AddNested("Networks", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

func validateOpGrantFlowEntitlementsInput(v *GrantFlowEntitlementsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GrantFlowEntitlementsInput"}
	if v.Entitlements == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Entitlements"))
	} else if v.Entitlements != nil {
		if err := validate__listOfGrantEntitlementRequest(v.Entitlements); err != nil {
			invalidParams.AddNested("Entitlements", err.(smithy.InvalidParamsError))
		}
	}
	if v.FlowArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpPurchaseOfferingInput(v *PurchaseOfferingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PurchaseOfferingInput"}
	if v.OfferingArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OfferingArn"))
	}
	if v.ReservationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReservationName"))
	}
	if v.Start == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Start"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRemoveBridgeOutputInput(v *RemoveBridgeOutputInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveBridgeOutputInput"}
	if v.BridgeArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BridgeArn"))
	}
	if v.OutputName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRemoveBridgeSourceInput(v *RemoveBridgeSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveBridgeSourceInput"}
	if v.BridgeArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BridgeArn"))
	}
	if v.SourceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRemoveFlowMediaStreamInput(v *RemoveFlowMediaStreamInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveFlowMediaStreamInput"}
	if v.FlowArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowArn"))
	}
	if v.MediaStreamName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MediaStreamName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRemoveFlowOutputInput(v *RemoveFlowOutputInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveFlowOutputInput"}
	if v.FlowArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowArn"))
	}
	if v.OutputArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRemoveFlowSourceInput(v *RemoveFlowSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveFlowSourceInput"}
	if v.FlowArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowArn"))
	}
	if v.SourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRemoveFlowVpcInterfaceInput(v *RemoveFlowVpcInterfaceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveFlowVpcInterfaceInput"}
	if v.FlowArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowArn"))
	}
	if v.VpcInterfaceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcInterfaceName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRevokeFlowEntitlementInput(v *RevokeFlowEntitlementInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RevokeFlowEntitlementInput"}
	if v.EntitlementArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntitlementArn"))
	}
	if v.FlowArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpStopFlowInput(v *StopFlowInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopFlowInput"}
	if v.FlowArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowArn"))
	}
	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"))
	}
	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 validateOpUpdateBridgeInput(v *UpdateBridgeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateBridgeInput"}
	if v.BridgeArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BridgeArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateBridgeOutputInput(v *UpdateBridgeOutputInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateBridgeOutputInput"}
	if v.BridgeArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BridgeArn"))
	}
	if v.OutputName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateBridgeSourceInput(v *UpdateBridgeSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateBridgeSourceInput"}
	if v.BridgeArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BridgeArn"))
	}
	if v.SourceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateBridgeStateInput(v *UpdateBridgeStateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateBridgeStateInput"}
	if v.BridgeArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BridgeArn"))
	}
	if len(v.DesiredState) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DesiredState"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateFlowEntitlementInput(v *UpdateFlowEntitlementInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFlowEntitlementInput"}
	if v.EntitlementArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntitlementArn"))
	}
	if v.FlowArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateFlowMediaStreamInput(v *UpdateFlowMediaStreamInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFlowMediaStreamInput"}
	if v.FlowArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowArn"))
	}
	if v.MediaStreamName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MediaStreamName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateFlowOutputInput(v *UpdateFlowOutputInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFlowOutputInput"}
	if v.FlowArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowArn"))
	}
	if v.MediaStreamOutputConfigurations != nil {
		if err := validate__listOfMediaStreamOutputConfigurationRequest(v.MediaStreamOutputConfigurations); err != nil {
			invalidParams.AddNested("MediaStreamOutputConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateFlowSourceInput(v *UpdateFlowSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFlowSourceInput"}
	if v.FlowArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowArn"))
	}
	if v.MediaStreamSourceConfigurations != nil {
		if err := validate__listOfMediaStreamSourceConfigurationRequest(v.MediaStreamSourceConfigurations); err != nil {
			invalidParams.AddNested("MediaStreamSourceConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.SourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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