xref: /dports/security/vault/aws-sdk-go-v2-fdbaadbce5fd/service/chime/validators.go

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

package chime

import (
	"context"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/chime/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 validateOpAssociatePhoneNumberWithUser struct {
}

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

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

type validateOpAssociateSigninDelegateGroupsWithAccount struct {
}

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

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

type validateOpBatchCreateAttendee struct {
}

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

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

type validateOpBatchCreateRoomMembership struct {
}

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

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

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

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

type validateOpBatchUnsuspendUser struct {
}

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

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

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

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

type validateOpCreateAccount struct {
}

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

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

type validateOpCreateAppInstanceAdmin struct {
}

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

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

type validateOpCreateAppInstance struct {
}

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

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

type validateOpCreateAppInstanceUser struct {
}

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

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

type validateOpCreateAttendee struct {
}

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

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

type validateOpCreateBot struct {
}

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

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

type validateOpCreateChannelBan struct {
}

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

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

type validateOpCreateChannel struct {
}

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

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

type validateOpCreateChannelMembership struct {
}

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

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

type validateOpCreateChannelModerator struct {
}

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

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

type validateOpCreateMeetingDialOut struct {
}

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

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

type validateOpCreateMeeting struct {
}

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

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

type validateOpCreateMeetingWithAttendees struct {
}

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

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

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

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

type validateOpCreateRoomMembership struct {
}

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

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

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

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

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

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

type validateOpDeleteAppInstanceAdmin struct {
}

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

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

type validateOpDeleteAppInstance struct {
}

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

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

type validateOpDeleteAppInstanceStreamingConfigurations struct {
}

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

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

type validateOpDeleteAppInstanceUser struct {
}

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

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

type validateOpDeleteAttendee struct {
}

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

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

type validateOpDeleteChannelBan struct {
}

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

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

type validateOpDeleteChannel struct {
}

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

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

type validateOpDeleteChannelMembership struct {
}

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

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

type validateOpDeleteChannelMessage struct {
}

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

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

type validateOpDeleteChannelModerator struct {
}

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

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

type validateOpDeleteEventsConfiguration struct {
}

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

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

type validateOpDeleteMeeting struct {
}

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

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

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

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

type validateOpDeleteRoomMembership struct {
}

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

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

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

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

type validateOpDescribeAppInstance struct {
}

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

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

type validateOpDescribeAppInstanceUser struct {
}

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

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

type validateOpDescribeChannelBan struct {
}

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

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

type validateOpDescribeChannel struct {
}

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

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

type validateOpDescribeChannelMembershipForAppInstanceUser struct {
}

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

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

type validateOpDescribeChannelMembership struct {
}

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

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

type validateOpDescribeChannelModeratedByAppInstanceUser struct {
}

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

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

type validateOpDescribeChannelModerator struct {
}

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

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

type validateOpDisassociatePhoneNumberFromUser struct {
}

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

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

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

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

type validateOpGetAccount struct {
}

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

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

type validateOpGetAccountSettings struct {
}

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

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

type validateOpGetAppInstanceRetentionSettings struct {
}

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

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

type validateOpGetAppInstanceStreamingConfigurations struct {
}

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

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

type validateOpGetAttendee struct {
}

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

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

type validateOpGetBot struct {
}

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

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

type validateOpGetChannelMessage struct {
}

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

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

type validateOpGetEventsConfiguration struct {
}

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

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

type validateOpGetMeeting struct {
}

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

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

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

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

type validateOpGetRoom struct {
}

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

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

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

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

type validateOpGetUserSettings struct {
}

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

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

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

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

type validateOpListAppInstanceAdmins struct {
}

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

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

type validateOpListAppInstanceUsers struct {
}

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

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

type validateOpListAttendees struct {
}

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

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

type validateOpListAttendeeTags struct {
}

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

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

type validateOpListBots struct {
}

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

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

type validateOpListChannelBans struct {
}

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

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

type validateOpListChannelMemberships struct {
}

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

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

type validateOpListChannelMessages struct {
}

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

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

type validateOpListChannelModerators struct {
}

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

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

type validateOpListChannels struct {
}

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

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

type validateOpListMeetingTags struct {
}

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

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

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

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

type validateOpListRooms struct {
}

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

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

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

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

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

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

type validateOpPutAppInstanceRetentionSettings struct {
}

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

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

type validateOpPutAppInstanceStreamingConfigurations struct {
}

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

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

type validateOpPutEventsConfiguration struct {
}

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

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

type validateOpPutRetentionSettings struct {
}

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

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

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

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

type validateOpRedactConversationMessage struct {
}

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

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

type validateOpRedactRoomMessage struct {
}

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

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

type validateOpRegenerateSecurityToken struct {
}

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

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

type validateOpResetPersonalPIN struct {
}

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

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

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

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

type validateOpTagAttendee struct {
}

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

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

type validateOpTagMeeting struct {
}

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

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

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

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

type validateOpUntagMeeting struct {
}

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

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

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

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

type validateOpUpdateAccountSettings struct {
}

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

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

type validateOpUpdateAppInstance struct {
}

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

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

type validateOpUpdateAppInstanceUser struct {
}

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

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

type validateOpUpdateBot struct {
}

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

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

type validateOpUpdateChannel struct {
}

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

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

type validateOpUpdateChannelMessage struct {
}

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

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

type validateOpUpdateChannelReadMarker struct {
}

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

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

type validateOpUpdateGlobalSettings struct {
}

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

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

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

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

type validateOpUpdateRoomMembership struct {
}

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

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

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

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

type validateOpUpdateUserSettings struct {
}

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

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

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 addOpAssociatePhoneNumberWithUserValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAssociatePhoneNumberWithUser{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpCreateMeetingWithAttendeesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateMeetingWithAttendees{}, 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 addOpCreateRoomValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateRoom{}, middleware.After)
}

func addOpCreateRoomMembershipValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateRoomMembership{}, 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 addOpCreateUserValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateUser{}, 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 addOpDeleteAccountValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteAccount{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

func addOpDeleteMeetingValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteMeeting{}, 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 addOpDeleteRoomValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteRoom{}, middleware.After)
}

func addOpDeleteRoomMembershipValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteRoomMembership{}, 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 addOpDescribeAppInstanceAdminValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeAppInstanceAdmin{}, middleware.After)
}

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

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

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

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

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

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

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

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

func addOpDisassociatePhoneNumberFromUserValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociatePhoneNumberFromUser{}, 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 addOpDisassociateSigninDelegateGroupsFromAccountValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDisassociateSigninDelegateGroupsFromAccount{}, middleware.After)
}

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

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

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

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

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

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

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

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

func addOpGetMeetingValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetMeeting{}, 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 addOpGetRetentionSettingsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetRetentionSettings{}, middleware.After)
}

func addOpGetRoomValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetRoom{}, 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 addOpGetUserValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetUser{}, middleware.After)
}

func addOpGetUserSettingsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetUserSettings{}, 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 addOpInviteUsersValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpInviteUsers{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpPutRetentionSettingsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutRetentionSettings{}, 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 addOpRedactChannelMessageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRedactChannelMessage{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpUpdateGlobalSettingsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateGlobalSettings{}, 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 addOpUpdateRoomValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateRoom{}, middleware.After)
}

func addOpUpdateRoomMembershipValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateRoomMembership{}, 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 addOpUpdateUserValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateUser{}, middleware.After)
}

func addOpUpdateUserSettingsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateUserSettings{}, 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 validateAppInstanceStreamingConfiguration(v *types.AppInstanceStreamingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AppInstanceStreamingConfiguration"}
	if len(v.AppInstanceDataType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AppInstanceDataType"))
	}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateAttendeeTagList(v []types.Tag) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttendeeTagList"}
	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 validateCreateAttendeeRequestItem(v *types.CreateAttendeeRequestItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAttendeeRequestItem"}
	if v.ExternalUserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExternalUserId"))
	}
	if v.Tags != nil {
		if err := validateAttendeeTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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 validateMeetingTagList(v []types.Tag) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MeetingTagList"}
	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 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.StreamingNotificationTargets != nil {
		if err := validateStreamingNotificationTargetList(v.StreamingNotificationTargets); err != nil {
			invalidParams.AddNested("StreamingNotificationTargets", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func 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 validateTelephonySettings(v *types.TelephonySettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TelephonySettings"}
	if v.InboundCalling == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InboundCalling"))
	}
	if v.OutboundCalling == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutboundCalling"))
	}
	if v.SMS == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SMS"))
	}
	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 validateUpdateUserRequestItem(v *types.UpdateUserRequestItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserRequestItem"}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateUserSettings(v *types.UserSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UserSettings"}
	if v.Telephony == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Telephony"))
	} else if v.Telephony != nil {
		if err := validateTelephonySettings(v.Telephony); err != nil {
			invalidParams.AddNested("Telephony", 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 validateOpAssociatePhoneNumberWithUserInput(v *AssociatePhoneNumberWithUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociatePhoneNumberWithUserInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if v.E164PhoneNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("E164PhoneNumber"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateSigninDelegateGroupsWithAccountInput(v *AssociateSigninDelegateGroupsWithAccountInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateSigninDelegateGroupsWithAccountInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.SigninDelegateGroups == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SigninDelegateGroups"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchCreateAttendeeInput(v *BatchCreateAttendeeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchCreateAttendeeInput"}
	if v.MeetingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MeetingId"))
	}
	if v.Attendees == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Attendees"))
	} else if v.Attendees != nil {
		if err := validateCreateAttendeeRequestItemList(v.Attendees); err != nil {
			invalidParams.AddNested("Attendees", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchCreateRoomMembershipInput(v *BatchCreateRoomMembershipInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchCreateRoomMembershipInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.RoomId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoomId"))
	}
	if v.MembershipItemList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipItemList"))
	}
	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 validateOpBatchSuspendUserInput(v *BatchSuspendUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchSuspendUserInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.UserIdList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserIdList"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchUnsuspendUserInput(v *BatchUnsuspendUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchUnsuspendUserInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.UserIdList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserIdList"))
	}
	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 validateOpBatchUpdateUserInput(v *BatchUpdateUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchUpdateUserInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.UpdateUserRequestItems == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UpdateUserRequestItems"))
	} else if v.UpdateUserRequestItems != nil {
		if err := validateUpdateUserRequestItemList(v.UpdateUserRequestItems); err != nil {
			invalidParams.AddNested("UpdateUserRequestItems", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateAppInstanceAdminInput(v *CreateAppInstanceAdminInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAppInstanceAdminInput"}
	if v.AppInstanceAdminArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppInstanceAdminArn"))
	}
	if v.AppInstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppInstanceArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAppInstanceInput(v *CreateAppInstanceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAppInstanceInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	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 validateOpCreateAppInstanceUserInput(v *CreateAppInstanceUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAppInstanceUserInput"}
	if v.AppInstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppInstanceArn"))
	}
	if v.AppInstanceUserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppInstanceUserId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	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 validateOpCreateAttendeeInput(v *CreateAttendeeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAttendeeInput"}
	if v.MeetingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MeetingId"))
	}
	if v.ExternalUserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExternalUserId"))
	}
	if v.Tags != nil {
		if err := validateAttendeeTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateBotInput(v *CreateBotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateBotInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.DisplayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DisplayName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateChannelBanInput(v *CreateChannelBanInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateChannelBanInput"}
	if v.ChannelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
	}
	if v.MemberArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemberArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateChannelInput(v *CreateChannelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateChannelInput"}
	if v.AppInstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppInstanceArn"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	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 validateOpCreateChannelMembershipInput(v *CreateChannelMembershipInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateChannelMembershipInput"}
	if v.ChannelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
	}
	if v.MemberArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemberArn"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateChannelModeratorInput(v *CreateChannelModeratorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateChannelModeratorInput"}
	if v.ChannelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
	}
	if v.ChannelModeratorArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelModeratorArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMeetingDialOutInput(v *CreateMeetingDialOutInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMeetingDialOutInput"}
	if v.MeetingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MeetingId"))
	}
	if v.FromPhoneNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FromPhoneNumber"))
	}
	if v.ToPhoneNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ToPhoneNumber"))
	}
	if v.JoinToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JoinToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMeetingInput(v *CreateMeetingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMeetingInput"}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if v.Tags != nil {
		if err := validateMeetingTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMeetingWithAttendeesInput(v *CreateMeetingWithAttendeesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMeetingWithAttendeesInput"}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if v.Tags != nil {
		if err := validateMeetingTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.Attendees != nil {
		if err := validateCreateMeetingWithAttendeesRequestItemList(v.Attendees); err != nil {
			invalidParams.AddNested("Attendees", 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 validateOpCreateRoomInput(v *CreateRoomInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRoomInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRoomMembershipInput(v *CreateRoomMembershipInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRoomMembershipInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.RoomId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoomId"))
	}
	if v.MemberId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemberId"))
	}
	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 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 v.TargetApplications == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetApplications"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteAppInstanceAdminInput(v *DeleteAppInstanceAdminInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAppInstanceAdminInput"}
	if v.AppInstanceAdminArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppInstanceAdminArn"))
	}
	if v.AppInstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppInstanceArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpDeleteAttendeeInput(v *DeleteAttendeeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAttendeeInput"}
	if v.MeetingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MeetingId"))
	}
	if v.AttendeeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttendeeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteChannelBanInput(v *DeleteChannelBanInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteChannelBanInput"}
	if v.ChannelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
	}
	if v.MemberArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemberArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteChannelMembershipInput(v *DeleteChannelMembershipInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteChannelMembershipInput"}
	if v.ChannelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
	}
	if v.MemberArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemberArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteChannelMessageInput(v *DeleteChannelMessageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteChannelMessageInput"}
	if v.ChannelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
	}
	if v.MessageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteChannelModeratorInput(v *DeleteChannelModeratorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteChannelModeratorInput"}
	if v.ChannelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
	}
	if v.ChannelModeratorArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelModeratorArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteEventsConfigurationInput(v *DeleteEventsConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteEventsConfigurationInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteMeetingInput(v *DeleteMeetingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteMeetingInput"}
	if v.MeetingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MeetingId"))
	}
	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 validateOpDeleteRoomInput(v *DeleteRoomInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRoomInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.RoomId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoomId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRoomMembershipInput(v *DeleteRoomMembershipInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRoomMembershipInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.RoomId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoomId"))
	}
	if v.MemberId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemberId"))
	}
	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 validateOpDescribeAppInstanceAdminInput(v *DescribeAppInstanceAdminInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeAppInstanceAdminInput"}
	if v.AppInstanceAdminArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppInstanceAdminArn"))
	}
	if v.AppInstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppInstanceArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDescribeChannelBanInput(v *DescribeChannelBanInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeChannelBanInput"}
	if v.ChannelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
	}
	if v.MemberArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemberArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDescribeChannelMembershipForAppInstanceUserInput(v *DescribeChannelMembershipForAppInstanceUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeChannelMembershipForAppInstanceUserInput"}
	if v.ChannelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
	}
	if v.AppInstanceUserArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppInstanceUserArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeChannelMembershipInput(v *DescribeChannelMembershipInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeChannelMembershipInput"}
	if v.ChannelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
	}
	if v.MemberArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemberArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeChannelModeratedByAppInstanceUserInput(v *DescribeChannelModeratedByAppInstanceUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeChannelModeratedByAppInstanceUserInput"}
	if v.ChannelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
	}
	if v.AppInstanceUserArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppInstanceUserArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeChannelModeratorInput(v *DescribeChannelModeratorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeChannelModeratorInput"}
	if v.ChannelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
	}
	if v.ChannelModeratorArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelModeratorArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociatePhoneNumberFromUserInput(v *DisassociatePhoneNumberFromUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociatePhoneNumberFromUserInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	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 validateOpDisassociateSigninDelegateGroupsFromAccountInput(v *DisassociateSigninDelegateGroupsFromAccountInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateSigninDelegateGroupsFromAccountInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.GroupNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpGetAttendeeInput(v *GetAttendeeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAttendeeInput"}
	if v.MeetingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MeetingId"))
	}
	if v.AttendeeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttendeeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetBotInput(v *GetBotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetBotInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetChannelMessageInput(v *GetChannelMessageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetChannelMessageInput"}
	if v.ChannelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
	}
	if v.MessageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetEventsConfigurationInput(v *GetEventsConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetEventsConfigurationInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetMeetingInput(v *GetMeetingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMeetingInput"}
	if v.MeetingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MeetingId"))
	}
	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 validateOpGetRetentionSettingsInput(v *GetRetentionSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRetentionSettingsInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetRoomInput(v *GetRoomInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRoomInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.RoomId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoomId"))
	}
	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 validateOpGetUserInput(v *GetUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetUserInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetUserSettingsInput(v *GetUserSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetUserSettingsInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	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 validateOpInviteUsersInput(v *InviteUsersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InviteUsersInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.UserEmailList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserEmailList"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpListAttendeeTagsInput(v *ListAttendeeTagsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAttendeeTagsInput"}
	if v.MeetingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MeetingId"))
	}
	if v.AttendeeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttendeeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateOpListMeetingTagsInput(v *ListMeetingTagsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListMeetingTagsInput"}
	if v.MeetingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MeetingId"))
	}
	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 validateOpListRoomMembershipsInput(v *ListRoomMembershipsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListRoomMembershipsInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.RoomId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoomId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListRoomsInput(v *ListRoomsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListRoomsInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	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 validateOpListUsersInput(v *ListUsersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListUsersInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	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 validateOpLogoutUserInput(v *LogoutUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LogoutUserInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutAppInstanceRetentionSettingsInput(v *PutAppInstanceRetentionSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutAppInstanceRetentionSettingsInput"}
	if v.AppInstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppInstanceArn"))
	}
	if v.AppInstanceRetentionSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppInstanceRetentionSettings"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutAppInstanceStreamingConfigurationsInput(v *PutAppInstanceStreamingConfigurationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutAppInstanceStreamingConfigurationsInput"}
	if v.AppInstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppInstanceArn"))
	}
	if v.AppInstanceStreamingConfigurations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppInstanceStreamingConfigurations"))
	} else if v.AppInstanceStreamingConfigurations != nil {
		if err := validateAppInstanceStreamingConfigurationList(v.AppInstanceStreamingConfigurations); err != nil {
			invalidParams.AddNested("AppInstanceStreamingConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutEventsConfigurationInput(v *PutEventsConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutEventsConfigurationInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutRetentionSettingsInput(v *PutRetentionSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutRetentionSettingsInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.RetentionSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RetentionSettings"))
	}
	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 validateOpRedactChannelMessageInput(v *RedactChannelMessageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RedactChannelMessageInput"}
	if v.ChannelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
	}
	if v.MessageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRedactConversationMessageInput(v *RedactConversationMessageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RedactConversationMessageInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.ConversationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConversationId"))
	}
	if v.MessageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRedactRoomMessageInput(v *RedactRoomMessageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RedactRoomMessageInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.RoomId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoomId"))
	}
	if v.MessageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRegenerateSecurityTokenInput(v *RegenerateSecurityTokenInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegenerateSecurityTokenInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpResetPersonalPINInput(v *ResetPersonalPINInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResetPersonalPINInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	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 validateOpSendChannelMessageInput(v *SendChannelMessageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SendChannelMessageInput"}
	if v.ChannelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if len(v.Persistence) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Persistence"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTagAttendeeInput(v *TagAttendeeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagAttendeeInput"}
	if v.MeetingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MeetingId"))
	}
	if v.AttendeeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttendeeId"))
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	} else if v.Tags != nil {
		if err := validateAttendeeTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTagMeetingInput(v *TagMeetingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagMeetingInput"}
	if v.MeetingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MeetingId"))
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	} else if v.Tags != nil {
		if err := validateMeetingTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	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 validateOpUntagAttendeeInput(v *UntagAttendeeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UntagAttendeeInput"}
	if v.MeetingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MeetingId"))
	}
	if v.AttendeeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttendeeId"))
	}
	if v.TagKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUntagMeetingInput(v *UntagMeetingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UntagMeetingInput"}
	if v.MeetingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MeetingId"))
	}
	if v.TagKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
	}
	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 validateOpUpdateAccountInput(v *UpdateAccountInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAccountInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAccountSettingsInput(v *UpdateAccountSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAccountSettingsInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.AccountSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountSettings"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpUpdateBotInput(v *UpdateBotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateBotInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateChannelInput(v *UpdateChannelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateChannelInput"}
	if v.ChannelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Mode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Mode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateChannelMessageInput(v *UpdateChannelMessageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateChannelMessageInput"}
	if v.ChannelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelArn"))
	}
	if v.MessageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateGlobalSettingsInput(v *UpdateGlobalSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateGlobalSettingsInput"}
	if v.BusinessCalling == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BusinessCalling"))
	}
	if v.VoiceConnector == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceConnector"))
	}
	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 validateOpUpdateRoomInput(v *UpdateRoomInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRoomInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.RoomId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoomId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRoomMembershipInput(v *UpdateRoomMembershipInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRoomMembershipInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.RoomId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoomId"))
	}
	if v.MemberId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemberId"))
	}
	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 validateOpUpdateUserInput(v *UpdateUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateUserSettingsInput(v *UpdateUserSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserSettingsInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if v.UserSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserSettings"))
	} else if v.UserSettings != nil {
		if err := validateUserSettings(v.UserSettings); err != nil {
			invalidParams.AddNested("UserSettings", err.(smithy.InvalidParamsError))
		}
	}
	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
	}
}