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

package pinpointsmsvoicev2

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

type validateOpAssociateOriginationIdentity struct {
}

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

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

type validateOpCreateConfigurationSet struct {
}

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

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

type validateOpCreateEventDestination struct {
}

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

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

type validateOpCreateOptOutList struct {
}

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

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

type validateOpCreatePool struct {
}

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

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

type validateOpDeleteConfigurationSet struct {
}

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

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

type validateOpDeleteDefaultMessageType struct {
}

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

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

type validateOpDeleteDefaultSenderId struct {
}

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

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

type validateOpDeleteEventDestination struct {
}

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

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

type validateOpDeleteKeyword struct {
}

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

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

type validateOpDeleteOptedOutNumber struct {
}

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

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

type validateOpDeleteOptOutList struct {
}

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

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

type validateOpDeletePool struct {
}

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

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

type validateOpDescribeConfigurationSets struct {
}

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

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

type validateOpDescribeKeywords struct {
}

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

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

type validateOpDescribeOptedOutNumbers struct {
}

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

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

type validateOpDescribePhoneNumbers struct {
}

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

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

type validateOpDescribePools struct {
}

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

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

type validateOpDescribeSenderIds struct {
}

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

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

type validateOpDisassociateOriginationIdentity struct {
}

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

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

type validateOpListPoolOriginationIdentities struct {
}

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

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

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

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

type validateOpPutOptedOutNumber struct {
}

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

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

type validateOpReleasePhoneNumber struct {
}

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

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

type validateOpRequestPhoneNumber struct {
}

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

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

type validateOpSendTextMessage struct {
}

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

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

type validateOpSendVoiceMessage struct {
}

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

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

type validateOpSetDefaultMessageType struct {
}

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

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

type validateOpSetDefaultSenderId struct {
}

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

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

type validateOpSetTextMessageSpendLimitOverride struct {
}

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

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

type validateOpSetVoiceMessageSpendLimitOverride struct {
}

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

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

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

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

type validateOpUpdatePhoneNumber struct {
}

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

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

type validateOpUpdatePool struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpSetVoiceMessageSpendLimitOverrideValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSetVoiceMessageSpendLimitOverride{}, 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 addOpUpdateEventDestinationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateEventDestination{}, middleware.After)
}

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

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

func validateCloudWatchLogsDestination(v *types.CloudWatchLogsDestination) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CloudWatchLogsDestination"}
	if v.IamRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IamRoleArn"))
	}
	if v.LogGroupArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LogGroupArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateKinesisFirehoseDestination(v *types.KinesisFirehoseDestination) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KinesisFirehoseDestination"}
	if v.IamRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IamRoleArn"))
	}
	if v.DeliveryStreamArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeliveryStreamArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNonEmptyTagList(v []types.Tag) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NonEmptyTagList"}
	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 validateOptedOutFilter(v *types.OptedOutFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OptedOutFilter"}
	if len(v.Name) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Values == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Values"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

func validateSenderIdAndCountry(v *types.SenderIdAndCountry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SenderIdAndCountry"}
	if v.SenderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SenderId"))
	}
	if v.IsoCountryCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IsoCountryCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateSnsDestination(v *types.SnsDestination) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SnsDestination"}
	if v.TopicArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopicArn"))
	}
	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 validateTagList(v []types.Tag) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
	for i := range v {
		if err := validateTag(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateOriginationIdentityInput(v *AssociateOriginationIdentityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateOriginationIdentityInput"}
	if v.PoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PoolId"))
	}
	if v.OriginationIdentity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginationIdentity"))
	}
	if v.IsoCountryCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IsoCountryCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateEventDestinationInput(v *CreateEventDestinationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateEventDestinationInput"}
	if v.ConfigurationSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
	}
	if v.EventDestinationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EventDestinationName"))
	}
	if v.MatchingEventTypes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MatchingEventTypes"))
	}
	if v.CloudWatchLogsDestination != nil {
		if err := validateCloudWatchLogsDestination(v.CloudWatchLogsDestination); err != nil {
			invalidParams.AddNested("CloudWatchLogsDestination", err.(smithy.InvalidParamsError))
		}
	}
	if v.KinesisFirehoseDestination != nil {
		if err := validateKinesisFirehoseDestination(v.KinesisFirehoseDestination); err != nil {
			invalidParams.AddNested("KinesisFirehoseDestination", err.(smithy.InvalidParamsError))
		}
	}
	if v.SnsDestination != nil {
		if err := validateSnsDestination(v.SnsDestination); err != nil {
			invalidParams.AddNested("SnsDestination", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreatePoolInput(v *CreatePoolInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePoolInput"}
	if v.OriginationIdentity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginationIdentity"))
	}
	if v.IsoCountryCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IsoCountryCode"))
	}
	if len(v.MessageType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MessageType"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpDeleteEventDestinationInput(v *DeleteEventDestinationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteEventDestinationInput"}
	if v.ConfigurationSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
	}
	if v.EventDestinationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EventDestinationName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteKeywordInput(v *DeleteKeywordInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteKeywordInput"}
	if v.OriginationIdentity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginationIdentity"))
	}
	if v.Keyword == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Keyword"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteOptedOutNumberInput(v *DeleteOptedOutNumberInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteOptedOutNumberInput"}
	if v.OptOutListName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OptOutListName"))
	}
	if v.OptedOutNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OptedOutNumber"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDescribeConfigurationSetsInput(v *DescribeConfigurationSetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeConfigurationSetsInput"}
	if v.Filters != nil {
		if err := validateConfigurationSetFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeKeywordsInput(v *DescribeKeywordsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeKeywordsInput"}
	if v.OriginationIdentity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginationIdentity"))
	}
	if v.Filters != nil {
		if err := validateKeywordFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeOptedOutNumbersInput(v *DescribeOptedOutNumbersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeOptedOutNumbersInput"}
	if v.OptOutListName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OptOutListName"))
	}
	if v.Filters != nil {
		if err := validateOptedOutFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribePhoneNumbersInput(v *DescribePhoneNumbersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribePhoneNumbersInput"}
	if v.Filters != nil {
		if err := validatePhoneNumberFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribePoolsInput(v *DescribePoolsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribePoolsInput"}
	if v.Filters != nil {
		if err := validatePoolFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeSenderIdsInput(v *DescribeSenderIdsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeSenderIdsInput"}
	if v.SenderIds != nil {
		if err := validateSenderIdList(v.SenderIds); err != nil {
			invalidParams.AddNested("SenderIds", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filters != nil {
		if err := validateSenderIdFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateOriginationIdentityInput(v *DisassociateOriginationIdentityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateOriginationIdentityInput"}
	if v.PoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PoolId"))
	}
	if v.OriginationIdentity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginationIdentity"))
	}
	if v.IsoCountryCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IsoCountryCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListPoolOriginationIdentitiesInput(v *ListPoolOriginationIdentitiesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListPoolOriginationIdentitiesInput"}
	if v.PoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PoolId"))
	}
	if v.Filters != nil {
		if err := validatePoolOriginationIdentitiesFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	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 validateOpPutKeywordInput(v *PutKeywordInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutKeywordInput"}
	if v.OriginationIdentity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginationIdentity"))
	}
	if v.Keyword == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Keyword"))
	}
	if v.KeywordMessage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeywordMessage"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutOptedOutNumberInput(v *PutOptedOutNumberInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutOptedOutNumberInput"}
	if v.OptOutListName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OptOutListName"))
	}
	if v.OptedOutNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OptedOutNumber"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpRequestPhoneNumberInput(v *RequestPhoneNumberInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RequestPhoneNumberInput"}
	if v.IsoCountryCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IsoCountryCode"))
	}
	if len(v.MessageType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MessageType"))
	}
	if v.NumberCapabilities == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NumberCapabilities"))
	}
	if len(v.NumberType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("NumberType"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpSendVoiceMessageInput(v *SendVoiceMessageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SendVoiceMessageInput"}
	if v.DestinationPhoneNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationPhoneNumber"))
	}
	if v.OriginationIdentity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginationIdentity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSetDefaultMessageTypeInput(v *SetDefaultMessageTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetDefaultMessageTypeInput"}
	if v.ConfigurationSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
	}
	if len(v.MessageType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MessageType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSetDefaultSenderIdInput(v *SetDefaultSenderIdInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetDefaultSenderIdInput"}
	if v.ConfigurationSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
	}
	if v.SenderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SenderId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpSetVoiceMessageSpendLimitOverrideInput(v *SetVoiceMessageSpendLimitOverrideInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetVoiceMessageSpendLimitOverrideInput"}
	if v.MonthlyLimit == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MonthlyLimit"))
	}
	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 := validateNonEmptyTagList(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 validateOpUpdateEventDestinationInput(v *UpdateEventDestinationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateEventDestinationInput"}
	if v.ConfigurationSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
	}
	if v.EventDestinationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EventDestinationName"))
	}
	if v.CloudWatchLogsDestination != nil {
		if err := validateCloudWatchLogsDestination(v.CloudWatchLogsDestination); err != nil {
			invalidParams.AddNested("CloudWatchLogsDestination", err.(smithy.InvalidParamsError))
		}
	}
	if v.KinesisFirehoseDestination != nil {
		if err := validateKinesisFirehoseDestination(v.KinesisFirehoseDestination); err != nil {
			invalidParams.AddNested("KinesisFirehoseDestination", err.(smithy.InvalidParamsError))
		}
	}
	if v.SnsDestination != nil {
		if err := validateSnsDestination(v.SnsDestination); err != nil {
			invalidParams.AddNested("SnsDestination", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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