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

package globalaccelerator

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

type validateOpAddCustomRoutingEndpoints struct {
}

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

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

type validateOpAddEndpoints struct {
}

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

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

type validateOpAdvertiseByoipCidr struct {
}

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

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

type validateOpAllowCustomRoutingTraffic struct {
}

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

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

type validateOpCreateAccelerator struct {
}

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

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

type validateOpCreateCustomRoutingAccelerator struct {
}

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

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

type validateOpCreateCustomRoutingEndpointGroup struct {
}

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

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

type validateOpCreateCustomRoutingListener struct {
}

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

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

type validateOpCreateEndpointGroup struct {
}

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

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

type validateOpCreateListener struct {
}

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

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

type validateOpDeleteAccelerator struct {
}

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

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

type validateOpDeleteCustomRoutingAccelerator struct {
}

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

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

type validateOpDeleteCustomRoutingEndpointGroup struct {
}

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

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

type validateOpDeleteCustomRoutingListener struct {
}

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

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

type validateOpDeleteEndpointGroup struct {
}

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

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

type validateOpDeleteListener struct {
}

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

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

type validateOpDenyCustomRoutingTraffic struct {
}

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

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

type validateOpDeprovisionByoipCidr struct {
}

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

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

type validateOpDescribeAcceleratorAttributes struct {
}

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

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

type validateOpDescribeAccelerator struct {
}

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

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

type validateOpDescribeCustomRoutingAcceleratorAttributes struct {
}

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

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

type validateOpDescribeCustomRoutingAccelerator struct {
}

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

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

type validateOpDescribeCustomRoutingEndpointGroup struct {
}

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

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

type validateOpDescribeCustomRoutingListener struct {
}

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

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

type validateOpDescribeEndpointGroup struct {
}

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

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

type validateOpDescribeListener struct {
}

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

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

type validateOpListCustomRoutingEndpointGroups struct {
}

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

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

type validateOpListCustomRoutingListeners struct {
}

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

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

type validateOpListCustomRoutingPortMappingsByDestination struct {
}

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

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

type validateOpListCustomRoutingPortMappings struct {
}

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

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

type validateOpListEndpointGroups struct {
}

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

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

type validateOpListListeners struct {
}

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

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

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

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

type validateOpRemoveCustomRoutingEndpoints struct {
}

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

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

type validateOpRemoveEndpoints struct {
}

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

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

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

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

type validateOpUpdateAccelerator struct {
}

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

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

type validateOpUpdateCustomRoutingAcceleratorAttributes struct {
}

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

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

type validateOpUpdateCustomRoutingAccelerator struct {
}

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

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

type validateOpUpdateCustomRoutingListener struct {
}

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

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

type validateOpUpdateEndpointGroup struct {
}

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

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

type validateOpUpdateListener struct {
}

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

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

type validateOpWithdrawByoipCidr struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpRemoveEndpointsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRemoveEndpoints{}, 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 addOpUpdateAcceleratorAttributesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateAcceleratorAttributes{}, middleware.After)
}

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

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

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

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

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

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

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

func validateCidrAuthorizationContext(v *types.CidrAuthorizationContext) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CidrAuthorizationContext"}
	if v.Message == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Message"))
	}
	if v.Signature == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Signature"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomRoutingDestinationConfiguration(v *types.CustomRoutingDestinationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomRoutingDestinationConfiguration"}
	if v.FromPort == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FromPort"))
	}
	if v.ToPort == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ToPort"))
	}
	if v.Protocols == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Protocols"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateEndpointIdentifiers(v []types.EndpointIdentifier) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EndpointIdentifiers"}
	for i := range v {
		if err := validateEndpointIdentifier(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), 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 v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTags(v []types.Tag) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Tags"}
	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 validateOpAddCustomRoutingEndpointsInput(v *AddCustomRoutingEndpointsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddCustomRoutingEndpointsInput"}
	if v.EndpointConfigurations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointConfigurations"))
	}
	if v.EndpointGroupArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointGroupArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddEndpointsInput(v *AddEndpointsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddEndpointsInput"}
	if v.EndpointConfigurations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointConfigurations"))
	}
	if v.EndpointGroupArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointGroupArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpAllowCustomRoutingTrafficInput(v *AllowCustomRoutingTrafficInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AllowCustomRoutingTrafficInput"}
	if v.EndpointGroupArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointGroupArn"))
	}
	if v.EndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAcceleratorInput(v *CreateAcceleratorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAcceleratorInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.IdempotencyToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdempotencyToken"))
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCustomRoutingAcceleratorInput(v *CreateCustomRoutingAcceleratorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCustomRoutingAcceleratorInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.IdempotencyToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdempotencyToken"))
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCustomRoutingEndpointGroupInput(v *CreateCustomRoutingEndpointGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCustomRoutingEndpointGroupInput"}
	if v.ListenerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ListenerArn"))
	}
	if v.EndpointGroupRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointGroupRegion"))
	}
	if v.DestinationConfigurations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationConfigurations"))
	} else if v.DestinationConfigurations != nil {
		if err := validateCustomRoutingDestinationConfigurations(v.DestinationConfigurations); err != nil {
			invalidParams.AddNested("DestinationConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.IdempotencyToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdempotencyToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCustomRoutingListenerInput(v *CreateCustomRoutingListenerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCustomRoutingListenerInput"}
	if v.AcceleratorArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AcceleratorArn"))
	}
	if v.PortRanges == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortRanges"))
	}
	if v.IdempotencyToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdempotencyToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateEndpointGroupInput(v *CreateEndpointGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateEndpointGroupInput"}
	if v.ListenerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ListenerArn"))
	}
	if v.EndpointGroupRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointGroupRegion"))
	}
	if v.IdempotencyToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdempotencyToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateListenerInput(v *CreateListenerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateListenerInput"}
	if v.AcceleratorArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AcceleratorArn"))
	}
	if v.PortRanges == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortRanges"))
	}
	if len(v.Protocol) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
	}
	if v.IdempotencyToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdempotencyToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateOpDenyCustomRoutingTrafficInput(v *DenyCustomRoutingTrafficInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DenyCustomRoutingTrafficInput"}
	if v.EndpointGroupArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointGroupArn"))
	}
	if v.EndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

func validateOpListCustomRoutingPortMappingsByDestinationInput(v *ListCustomRoutingPortMappingsByDestinationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListCustomRoutingPortMappingsByDestinationInput"}
	if v.EndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointId"))
	}
	if v.DestinationAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationAddress"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListListenersInput(v *ListListenersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListListenersInput"}
	if v.AcceleratorArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AcceleratorArn"))
	}
	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 validateOpProvisionByoipCidrInput(v *ProvisionByoipCidrInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProvisionByoipCidrInput"}
	if v.Cidr == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cidr"))
	}
	if v.CidrAuthorizationContext == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CidrAuthorizationContext"))
	} else if v.CidrAuthorizationContext != nil {
		if err := validateCidrAuthorizationContext(v.CidrAuthorizationContext); err != nil {
			invalidParams.AddNested("CidrAuthorizationContext", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRemoveCustomRoutingEndpointsInput(v *RemoveCustomRoutingEndpointsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveCustomRoutingEndpointsInput"}
	if v.EndpointIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointIds"))
	}
	if v.EndpointGroupArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointGroupArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRemoveEndpointsInput(v *RemoveEndpointsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveEndpointsInput"}
	if v.EndpointIdentifiers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointIdentifiers"))
	} else if v.EndpointIdentifiers != nil {
		if err := validateEndpointIdentifiers(v.EndpointIdentifiers); err != nil {
			invalidParams.AddNested("EndpointIdentifiers", err.(smithy.InvalidParamsError))
		}
	}
	if v.EndpointGroupArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointGroupArn"))
	}
	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 := validateTags(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 validateOpUpdateAcceleratorAttributesInput(v *UpdateAcceleratorAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAcceleratorAttributesInput"}
	if v.AcceleratorArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AcceleratorArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpUpdateCustomRoutingListenerInput(v *UpdateCustomRoutingListenerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCustomRoutingListenerInput"}
	if v.ListenerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ListenerArn"))
	}
	if v.PortRanges == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortRanges"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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