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

package chimesdkvoice

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

type validateOpAssociatePhoneNumbersWithVoiceConnectorGroup struct {
}

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

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

type validateOpAssociatePhoneNumbersWithVoiceConnector struct {
}

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

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

type validateOpBatchDeletePhoneNumber struct {
}

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

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

type validateOpBatchUpdatePhoneNumber struct {
}

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

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

type validateOpCreatePhoneNumberOrder struct {
}

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

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

type validateOpCreateProxySession struct {
}

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

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

type validateOpCreateSipMediaApplicationCall struct {
}

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

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

type validateOpCreateSipMediaApplication struct {
}

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

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

type validateOpCreateSipRule struct {
}

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

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

type validateOpCreateVoiceConnectorGroup struct {
}

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

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

type validateOpCreateVoiceConnector struct {
}

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

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

type validateOpCreateVoiceProfileDomain struct {
}

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

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

type validateOpCreateVoiceProfile struct {
}

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

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

type validateOpDeletePhoneNumber struct {
}

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

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

type validateOpDeleteProxySession struct {
}

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

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

type validateOpDeleteSipMediaApplication struct {
}

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

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

type validateOpDeleteSipRule struct {
}

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

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

type validateOpDeleteVoiceConnectorEmergencyCallingConfiguration struct {
}

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

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

type validateOpDeleteVoiceConnectorGroup struct {
}

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

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

type validateOpDeleteVoiceConnector struct {
}

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

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

type validateOpDeleteVoiceConnectorOrigination struct {
}

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

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

type validateOpDeleteVoiceConnectorProxy struct {
}

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

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

type validateOpDeleteVoiceConnectorStreamingConfiguration struct {
}

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

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

type validateOpDeleteVoiceConnectorTerminationCredentials struct {
}

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

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

type validateOpDeleteVoiceConnectorTermination struct {
}

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

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

type validateOpDeleteVoiceProfileDomain struct {
}

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

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

type validateOpDeleteVoiceProfile struct {
}

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

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

type validateOpDisassociatePhoneNumbersFromVoiceConnectorGroup struct {
}

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

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

type validateOpDisassociatePhoneNumbersFromVoiceConnector struct {
}

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

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

type validateOpGetPhoneNumber struct {
}

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

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

type validateOpGetPhoneNumberOrder struct {
}

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

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

type validateOpGetProxySession struct {
}

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

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

type validateOpGetSipMediaApplicationAlexaSkillConfiguration struct {
}

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

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

type validateOpGetSipMediaApplication struct {
}

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

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

type validateOpGetSipMediaApplicationLoggingConfiguration struct {
}

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

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

type validateOpGetSipRule struct {
}

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

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

type validateOpGetSpeakerSearchTask struct {
}

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

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

type validateOpGetVoiceConnectorEmergencyCallingConfiguration struct {
}

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

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

type validateOpGetVoiceConnectorGroup struct {
}

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

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

type validateOpGetVoiceConnector struct {
}

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

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

type validateOpGetVoiceConnectorLoggingConfiguration struct {
}

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

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

type validateOpGetVoiceConnectorOrigination struct {
}

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

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

type validateOpGetVoiceConnectorProxy struct {
}

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

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

type validateOpGetVoiceConnectorStreamingConfiguration struct {
}

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

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

type validateOpGetVoiceConnectorTerminationHealth struct {
}

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

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

type validateOpGetVoiceConnectorTermination struct {
}

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

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

type validateOpGetVoiceProfileDomain struct {
}

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

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

type validateOpGetVoiceProfile struct {
}

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

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

type validateOpGetVoiceToneAnalysisTask struct {
}

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

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

type validateOpListProxySessions struct {
}

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

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

type validateOpListSupportedPhoneNumberCountries struct {
}

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

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

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

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

type validateOpListVoiceProfiles struct {
}

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

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

type validateOpPutSipMediaApplicationAlexaSkillConfiguration struct {
}

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

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

type validateOpPutSipMediaApplicationLoggingConfiguration struct {
}

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

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

type validateOpPutVoiceConnectorEmergencyCallingConfiguration struct {
}

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

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

type validateOpPutVoiceConnectorLoggingConfiguration struct {
}

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

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

type validateOpPutVoiceConnectorOrigination struct {
}

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

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

type validateOpPutVoiceConnectorProxy struct {
}

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

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

type validateOpPutVoiceConnectorStreamingConfiguration struct {
}

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

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

type validateOpPutVoiceConnectorTerminationCredentials struct {
}

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

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

type validateOpPutVoiceConnectorTermination struct {
}

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

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

type validateOpRestorePhoneNumber struct {
}

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

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

type validateOpStartSpeakerSearchTask struct {
}

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

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

type validateOpStartVoiceToneAnalysisTask struct {
}

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

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

type validateOpStopSpeakerSearchTask struct {
}

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

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

type validateOpStopVoiceToneAnalysisTask struct {
}

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

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

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

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

type validateOpUpdateProxySession struct {
}

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

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

type validateOpUpdateSipMediaApplicationCall struct {
}

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

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

type validateOpUpdateSipMediaApplication struct {
}

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

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

type validateOpUpdateSipRule struct {
}

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

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

type validateOpUpdateVoiceConnectorGroup struct {
}

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

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

type validateOpUpdateVoiceConnector struct {
}

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

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

type validateOpUpdateVoiceProfileDomain struct {
}

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

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

type validateOpUpdateVoiceProfile struct {
}

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

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

type validateOpValidateE911Address struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpStopVoiceToneAnalysisTaskValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStopVoiceToneAnalysisTask{}, 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 addOpUpdatePhoneNumberValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdatePhoneNumber{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

func validateDNISEmergencyCallingConfiguration(v *types.DNISEmergencyCallingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DNISEmergencyCallingConfiguration"}
	if v.EmergencyPhoneNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EmergencyPhoneNumber"))
	}
	if v.CallingCountry == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CallingCountry"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateEmergencyCallingConfiguration(v *types.EmergencyCallingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EmergencyCallingConfiguration"}
	if v.DNIS != nil {
		if err := validateDNISEmergencyCallingConfigurationList(v.DNIS); err != nil {
			invalidParams.AddNested("DNIS", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGeoMatchParams(v *types.GeoMatchParams) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GeoMatchParams"}
	if v.Country == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Country"))
	}
	if v.AreaCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AreaCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSipMediaApplicationAlexaSkillConfiguration(v *types.SipMediaApplicationAlexaSkillConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SipMediaApplicationAlexaSkillConfiguration"}
	if len(v.AlexaSkillStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AlexaSkillStatus"))
	}
	if v.AlexaSkillIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AlexaSkillIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateStreamingConfiguration(v *types.StreamingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StreamingConfiguration"}
	if v.DataRetentionInHours == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataRetentionInHours"))
	}
	if v.Disabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Disabled"))
	}
	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 validateUpdatePhoneNumberRequestItem(v *types.UpdatePhoneNumberRequestItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePhoneNumberRequestItem"}
	if v.PhoneNumberId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PhoneNumberId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateVoiceConnectorItem(v *types.VoiceConnectorItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VoiceConnectorItem"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.Priority == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Priority"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpAssociatePhoneNumbersWithVoiceConnectorGroupInput(v *AssociatePhoneNumbersWithVoiceConnectorGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociatePhoneNumbersWithVoiceConnectorGroupInput"}
	if v.VoiceConnectorGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorGroupId"))
	}
	if v.E164PhoneNumbers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("E164PhoneNumbers"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociatePhoneNumbersWithVoiceConnectorInput(v *AssociatePhoneNumbersWithVoiceConnectorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociatePhoneNumbersWithVoiceConnectorInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.E164PhoneNumbers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("E164PhoneNumbers"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpBatchUpdatePhoneNumberInput(v *BatchUpdatePhoneNumberInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchUpdatePhoneNumberInput"}
	if v.UpdatePhoneNumberRequestItems == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UpdatePhoneNumberRequestItems"))
	} else if v.UpdatePhoneNumberRequestItems != nil {
		if err := validateUpdatePhoneNumberRequestItemList(v.UpdatePhoneNumberRequestItems); err != nil {
			invalidParams.AddNested("UpdatePhoneNumberRequestItems", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePhoneNumberOrderInput(v *CreatePhoneNumberOrderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePhoneNumberOrderInput"}
	if len(v.ProductType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ProductType"))
	}
	if v.E164PhoneNumbers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("E164PhoneNumbers"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateProxySessionInput(v *CreateProxySessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateProxySessionInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.ParticipantPhoneNumbers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParticipantPhoneNumbers"))
	}
	if v.Capabilities == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Capabilities"))
	}
	if v.GeoMatchParams != nil {
		if err := validateGeoMatchParams(v.GeoMatchParams); err != nil {
			invalidParams.AddNested("GeoMatchParams", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSipMediaApplicationCallInput(v *CreateSipMediaApplicationCallInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSipMediaApplicationCallInput"}
	if v.FromPhoneNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FromPhoneNumber"))
	}
	if v.ToPhoneNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ToPhoneNumber"))
	}
	if v.SipMediaApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SipMediaApplicationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSipMediaApplicationInput(v *CreateSipMediaApplicationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSipMediaApplicationInput"}
	if v.AwsRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsRegion"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Endpoints == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Endpoints"))
	}
	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 validateOpCreateSipRuleInput(v *CreateSipRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSipRuleInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.TriggerType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TriggerType"))
	}
	if v.TriggerValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TriggerValue"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateVoiceConnectorGroupInput(v *CreateVoiceConnectorGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVoiceConnectorGroupInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.VoiceConnectorItems != nil {
		if err := validateVoiceConnectorItemList(v.VoiceConnectorItems); err != nil {
			invalidParams.AddNested("VoiceConnectorItems", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateVoiceConnectorInput(v *CreateVoiceConnectorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVoiceConnectorInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.RequireEncryption == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequireEncryption"))
	}
	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 validateOpCreateVoiceProfileDomainInput(v *CreateVoiceProfileDomainInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVoiceProfileDomainInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ServerSideEncryptionConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServerSideEncryptionConfiguration"))
	} else if v.ServerSideEncryptionConfiguration != nil {
		if err := validateServerSideEncryptionConfiguration(v.ServerSideEncryptionConfiguration); err != nil {
			invalidParams.AddNested("ServerSideEncryptionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	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 validateOpCreateVoiceProfileInput(v *CreateVoiceProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVoiceProfileInput"}
	if v.SpeakerSearchTaskId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SpeakerSearchTaskId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteProxySessionInput(v *DeleteProxySessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteProxySessionInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.ProxySessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProxySessionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

func validateOpDeleteVoiceConnectorTerminationCredentialsInput(v *DeleteVoiceConnectorTerminationCredentialsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVoiceConnectorTerminationCredentialsInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.Usernames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Usernames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpDisassociatePhoneNumbersFromVoiceConnectorGroupInput(v *DisassociatePhoneNumbersFromVoiceConnectorGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociatePhoneNumbersFromVoiceConnectorGroupInput"}
	if v.VoiceConnectorGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorGroupId"))
	}
	if v.E164PhoneNumbers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("E164PhoneNumbers"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociatePhoneNumbersFromVoiceConnectorInput(v *DisassociatePhoneNumbersFromVoiceConnectorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociatePhoneNumbersFromVoiceConnectorInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.E164PhoneNumbers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("E164PhoneNumbers"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpGetProxySessionInput(v *GetProxySessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetProxySessionInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.ProxySessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProxySessionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpGetSpeakerSearchTaskInput(v *GetSpeakerSearchTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSpeakerSearchTaskInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.SpeakerSearchTaskId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SpeakerSearchTaskId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

func validateOpGetVoiceToneAnalysisTaskInput(v *GetVoiceToneAnalysisTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetVoiceToneAnalysisTaskInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.VoiceToneAnalysisTaskId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceToneAnalysisTaskId"))
	}
	if v.IsCaller == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IsCaller"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListSupportedPhoneNumberCountriesInput(v *ListSupportedPhoneNumberCountriesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListSupportedPhoneNumberCountriesInput"}
	if len(v.ProductType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ProductType"))
	}
	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 validateOpListVoiceConnectorTerminationCredentialsInput(v *ListVoiceConnectorTerminationCredentialsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListVoiceConnectorTerminationCredentialsInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpPutSipMediaApplicationAlexaSkillConfigurationInput(v *PutSipMediaApplicationAlexaSkillConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutSipMediaApplicationAlexaSkillConfigurationInput"}
	if v.SipMediaApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SipMediaApplicationId"))
	}
	if v.SipMediaApplicationAlexaSkillConfiguration != nil {
		if err := validateSipMediaApplicationAlexaSkillConfiguration(v.SipMediaApplicationAlexaSkillConfiguration); err != nil {
			invalidParams.AddNested("SipMediaApplicationAlexaSkillConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpPutVoiceConnectorEmergencyCallingConfigurationInput(v *PutVoiceConnectorEmergencyCallingConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutVoiceConnectorEmergencyCallingConfigurationInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.EmergencyCallingConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EmergencyCallingConfiguration"))
	} else if v.EmergencyCallingConfiguration != nil {
		if err := validateEmergencyCallingConfiguration(v.EmergencyCallingConfiguration); err != nil {
			invalidParams.AddNested("EmergencyCallingConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutVoiceConnectorLoggingConfigurationInput(v *PutVoiceConnectorLoggingConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutVoiceConnectorLoggingConfigurationInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.LoggingConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LoggingConfiguration"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutVoiceConnectorOriginationInput(v *PutVoiceConnectorOriginationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutVoiceConnectorOriginationInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.Origination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Origination"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutVoiceConnectorProxyInput(v *PutVoiceConnectorProxyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutVoiceConnectorProxyInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.DefaultSessionExpiryMinutes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultSessionExpiryMinutes"))
	}
	if v.PhoneNumberPoolCountries == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PhoneNumberPoolCountries"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutVoiceConnectorStreamingConfigurationInput(v *PutVoiceConnectorStreamingConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutVoiceConnectorStreamingConfigurationInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.StreamingConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StreamingConfiguration"))
	} else if v.StreamingConfiguration != nil {
		if err := validateStreamingConfiguration(v.StreamingConfiguration); err != nil {
			invalidParams.AddNested("StreamingConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpPutVoiceConnectorTerminationInput(v *PutVoiceConnectorTerminationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutVoiceConnectorTerminationInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.Termination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Termination"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpStartSpeakerSearchTaskInput(v *StartSpeakerSearchTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartSpeakerSearchTaskInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.TransactionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransactionId"))
	}
	if v.VoiceProfileDomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceProfileDomainId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartVoiceToneAnalysisTaskInput(v *StartVoiceToneAnalysisTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartVoiceToneAnalysisTaskInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.TransactionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransactionId"))
	}
	if len(v.LanguageCode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LanguageCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopSpeakerSearchTaskInput(v *StopSpeakerSearchTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopSpeakerSearchTaskInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.SpeakerSearchTaskId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SpeakerSearchTaskId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopVoiceToneAnalysisTaskInput(v *StopVoiceToneAnalysisTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopVoiceToneAnalysisTaskInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.VoiceToneAnalysisTaskId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceToneAnalysisTaskId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func 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 validateOpUpdatePhoneNumberSettingsInput(v *UpdatePhoneNumberSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePhoneNumberSettingsInput"}
	if v.CallingName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CallingName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateProxySessionInput(v *UpdateProxySessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateProxySessionInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.ProxySessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProxySessionId"))
	}
	if v.Capabilities == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Capabilities"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateSipMediaApplicationCallInput(v *UpdateSipMediaApplicationCallInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSipMediaApplicationCallInput"}
	if v.SipMediaApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SipMediaApplicationId"))
	}
	if v.TransactionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransactionId"))
	}
	if v.Arguments == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arguments"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpUpdateVoiceConnectorGroupInput(v *UpdateVoiceConnectorGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateVoiceConnectorGroupInput"}
	if v.VoiceConnectorGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorGroupId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.VoiceConnectorItems == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorItems"))
	} else if v.VoiceConnectorItems != nil {
		if err := validateVoiceConnectorItemList(v.VoiceConnectorItems); err != nil {
			invalidParams.AddNested("VoiceConnectorItems", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateVoiceConnectorInput(v *UpdateVoiceConnectorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateVoiceConnectorInput"}
	if v.VoiceConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnectorId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.RequireEncryption == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequireEncryption"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateVoiceProfileInput(v *UpdateVoiceProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateVoiceProfileInput"}
	if v.VoiceProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceProfileId"))
	}
	if v.SpeakerSearchTaskId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SpeakerSearchTaskId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpValidateE911AddressInput(v *ValidateE911AddressInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ValidateE911AddressInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.StreetNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StreetNumber"))
	}
	if v.StreetInfo == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StreetInfo"))
	}
	if v.City == nil {
		invalidParams.Add(smithy.NewErrParamRequired("City"))
	}
	if v.State == nil {
		invalidParams.Add(smithy.NewErrParamRequired("State"))
	}
	if v.Country == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Country"))
	}
	if v.PostalCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PostalCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}