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

package connect

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

type validateOpActivateEvaluationForm struct {
}

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

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

type validateOpAssociateApprovedOrigin struct {
}

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

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

type validateOpAssociateBot struct {
}

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

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

type validateOpAssociateDefaultVocabulary struct {
}

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

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

type validateOpAssociateInstanceStorageConfig struct {
}

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

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

type validateOpAssociateLambdaFunction struct {
}

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

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

type validateOpAssociateLexBot struct {
}

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

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

type validateOpAssociatePhoneNumberContactFlow struct {
}

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

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

type validateOpAssociateQueueQuickConnects struct {
}

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

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

type validateOpAssociateRoutingProfileQueues struct {
}

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

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

type validateOpAssociateSecurityKey struct {
}

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

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

type validateOpClaimPhoneNumber struct {
}

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

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

type validateOpCreateAgentStatus struct {
}

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

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

type validateOpCreateContactFlow struct {
}

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

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

type validateOpCreateContactFlowModule struct {
}

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

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

type validateOpCreateEvaluationForm struct {
}

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

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

type validateOpCreateHoursOfOperation struct {
}

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

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

type validateOpCreateInstance struct {
}

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

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

type validateOpCreateIntegrationAssociation struct {
}

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

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

type validateOpCreateParticipant struct {
}

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

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

type validateOpCreatePrompt struct {
}

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

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

type validateOpCreateQueue struct {
}

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

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

type validateOpCreateQuickConnect struct {
}

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

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

type validateOpCreateRoutingProfile struct {
}

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

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

type validateOpCreateRule struct {
}

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

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

type validateOpCreateSecurityProfile struct {
}

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

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

type validateOpCreateTaskTemplate struct {
}

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

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

type validateOpCreateTrafficDistributionGroup struct {
}

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

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

type validateOpCreateUseCase struct {
}

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

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

type validateOpCreateUserHierarchyGroup struct {
}

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

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

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

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

type validateOpDeactivateEvaluationForm struct {
}

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

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

type validateOpDeleteContactEvaluation struct {
}

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

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

type validateOpDeleteContactFlow struct {
}

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

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

type validateOpDeleteContactFlowModule struct {
}

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

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

type validateOpDeleteEvaluationForm struct {
}

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

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

type validateOpDeleteHoursOfOperation struct {
}

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

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

type validateOpDeleteInstance struct {
}

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

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

type validateOpDeleteIntegrationAssociation struct {
}

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

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

type validateOpDeletePrompt struct {
}

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

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

type validateOpDeleteQueue struct {
}

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

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

type validateOpDeleteQuickConnect struct {
}

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

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

type validateOpDeleteRoutingProfile struct {
}

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

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

type validateOpDeleteRule struct {
}

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

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

type validateOpDeleteSecurityProfile struct {
}

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

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

type validateOpDeleteTaskTemplate struct {
}

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

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

type validateOpDeleteTrafficDistributionGroup struct {
}

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

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

type validateOpDeleteUseCase struct {
}

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

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

type validateOpDeleteUserHierarchyGroup struct {
}

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

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

type validateOpDeleteUser struct {
}

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

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

type validateOpDeleteVocabulary struct {
}

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

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

type validateOpDescribeAgentStatus struct {
}

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

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

type validateOpDescribeContactEvaluation struct {
}

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

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

type validateOpDescribeContactFlow struct {
}

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

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

type validateOpDescribeContactFlowModule struct {
}

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

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

type validateOpDescribeContact struct {
}

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

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

type validateOpDescribeEvaluationForm struct {
}

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

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

type validateOpDescribeHoursOfOperation struct {
}

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

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

type validateOpDescribeInstanceAttribute struct {
}

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

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

type validateOpDescribeInstance struct {
}

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

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

type validateOpDescribeInstanceStorageConfig struct {
}

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

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

type validateOpDescribePhoneNumber struct {
}

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

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

type validateOpDescribePrompt struct {
}

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

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

type validateOpDescribeQueue struct {
}

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

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

type validateOpDescribeQuickConnect struct {
}

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

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

type validateOpDescribeRoutingProfile struct {
}

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

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

type validateOpDescribeRule struct {
}

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

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

type validateOpDescribeSecurityProfile struct {
}

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

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

type validateOpDescribeTrafficDistributionGroup struct {
}

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

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

type validateOpDescribeUserHierarchyGroup struct {
}

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

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

type validateOpDescribeUserHierarchyStructure struct {
}

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

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

type validateOpDescribeUser struct {
}

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

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

type validateOpDescribeVocabulary struct {
}

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

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

type validateOpDisassociateApprovedOrigin struct {
}

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

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

type validateOpDisassociateBot struct {
}

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

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

type validateOpDisassociateInstanceStorageConfig struct {
}

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

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

type validateOpDisassociateLambdaFunction struct {
}

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

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

type validateOpDisassociateLexBot struct {
}

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

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

type validateOpDisassociatePhoneNumberContactFlow struct {
}

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

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

type validateOpDisassociateQueueQuickConnects struct {
}

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

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

type validateOpDisassociateRoutingProfileQueues struct {
}

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

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

type validateOpDisassociateSecurityKey struct {
}

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

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

type validateOpDismissUserContact struct {
}

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

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

type validateOpGetContactAttributes struct {
}

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

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

type validateOpGetCurrentMetricData struct {
}

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

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

type validateOpGetCurrentUserData struct {
}

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

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

type validateOpGetFederationToken struct {
}

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

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

type validateOpGetMetricData struct {
}

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

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

type validateOpGetMetricDataV2 struct {
}

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

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

type validateOpGetPromptFile struct {
}

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

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

type validateOpGetTaskTemplate struct {
}

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

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

type validateOpGetTrafficDistribution struct {
}

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

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

type validateOpListAgentStatuses struct {
}

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

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

type validateOpListApprovedOrigins struct {
}

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

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

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

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

type validateOpListContactFlowModules struct {
}

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

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

type validateOpListContactFlows struct {
}

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

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

type validateOpListContactReferences struct {
}

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

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

type validateOpListDefaultVocabularies struct {
}

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

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

type validateOpListEvaluationForms struct {
}

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

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

type validateOpListEvaluationFormVersions struct {
}

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

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

type validateOpListHoursOfOperations struct {
}

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

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

type validateOpListInstanceAttributes struct {
}

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

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

type validateOpListInstanceStorageConfigs struct {
}

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

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

type validateOpListIntegrationAssociations struct {
}

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

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

type validateOpListLambdaFunctions struct {
}

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

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

type validateOpListLexBots struct {
}

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

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

type validateOpListPhoneNumbers struct {
}

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

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

type validateOpListPrompts struct {
}

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

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

type validateOpListQueueQuickConnects struct {
}

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

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

type validateOpListQueues struct {
}

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

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

type validateOpListQuickConnects struct {
}

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

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

type validateOpListRoutingProfileQueues struct {
}

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

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

type validateOpListRoutingProfiles struct {
}

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

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

type validateOpListRules struct {
}

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

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

type validateOpListSecurityKeys struct {
}

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

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

type validateOpListSecurityProfilePermissions struct {
}

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

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

type validateOpListSecurityProfiles struct {
}

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

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

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

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

type validateOpListUseCases struct {
}

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

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

type validateOpListUserHierarchyGroups struct {
}

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

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

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

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

type validateOpPutUserStatus struct {
}

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

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

type validateOpReleasePhoneNumber struct {
}

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

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

type validateOpReplicateInstance struct {
}

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

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

type validateOpResumeContactRecording struct {
}

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

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

type validateOpSearchAvailablePhoneNumbers struct {
}

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

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

type validateOpSearchHoursOfOperations struct {
}

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

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

type validateOpSearchPrompts struct {
}

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

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

type validateOpSearchQueues struct {
}

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

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

type validateOpSearchQuickConnects struct {
}

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

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

type validateOpSearchResourceTags struct {
}

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

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

type validateOpSearchRoutingProfiles struct {
}

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

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

type validateOpSearchSecurityProfiles struct {
}

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

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

type validateOpSearchVocabularies struct {
}

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

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

type validateOpStartChatContact struct {
}

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

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

type validateOpStartContactEvaluation struct {
}

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

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

type validateOpStartContactRecording struct {
}

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

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

type validateOpStartContactStreaming struct {
}

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

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

type validateOpStartOutboundVoiceContact struct {
}

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

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

type validateOpStartTaskContact struct {
}

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

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

type validateOpStopContact struct {
}

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

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

type validateOpStopContactRecording struct {
}

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

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

type validateOpStopContactStreaming struct {
}

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

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

type validateOpSubmitContactEvaluation struct {
}

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

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

type validateOpSuspendContactRecording struct {
}

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

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

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

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

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

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

type validateOpUpdateContactAttributes struct {
}

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

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

type validateOpUpdateContactEvaluation struct {
}

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

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

type validateOpUpdateContactFlowContent struct {
}

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

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

type validateOpUpdateContactFlowMetadata struct {
}

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

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

type validateOpUpdateContactFlowModuleContent struct {
}

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

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

type validateOpUpdateContactFlowModuleMetadata struct {
}

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

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

type validateOpUpdateContactFlowName struct {
}

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

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

type validateOpUpdateContact struct {
}

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

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

type validateOpUpdateContactSchedule struct {
}

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

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

type validateOpUpdateEvaluationForm struct {
}

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

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

type validateOpUpdateHoursOfOperation struct {
}

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

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

type validateOpUpdateInstanceAttribute struct {
}

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

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

type validateOpUpdateInstanceStorageConfig struct {
}

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

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

type validateOpUpdateParticipantRoleConfig struct {
}

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

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

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

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

type validateOpUpdateQueueHoursOfOperation struct {
}

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

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

type validateOpUpdateQueueMaxContacts struct {
}

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

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

type validateOpUpdateQueueName struct {
}

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

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

type validateOpUpdateQueueOutboundCallerConfig struct {
}

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

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

type validateOpUpdateQueueStatus struct {
}

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

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

type validateOpUpdateQuickConnectConfig struct {
}

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

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

type validateOpUpdateQuickConnectName struct {
}

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

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

type validateOpUpdateRoutingProfileConcurrency struct {
}

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

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

type validateOpUpdateRoutingProfileDefaultOutboundQueue struct {
}

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

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

type validateOpUpdateRoutingProfileName struct {
}

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

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

type validateOpUpdateRoutingProfileQueues struct {
}

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

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

type validateOpUpdateRule struct {
}

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

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

type validateOpUpdateSecurityProfile struct {
}

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

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

type validateOpUpdateTaskTemplate struct {
}

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

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

type validateOpUpdateTrafficDistribution struct {
}

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

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

type validateOpUpdateUserHierarchyGroupName struct {
}

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

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

type validateOpUpdateUserHierarchy struct {
}

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

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

type validateOpUpdateUserHierarchyStructure struct {
}

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

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

type validateOpUpdateUserIdentityInfo struct {
}

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

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

type validateOpUpdateUserPhoneConfig struct {
}

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

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

type validateOpUpdateUserRoutingProfile struct {
}

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

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

type validateOpUpdateUserSecurityProfiles struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateChatMessage(v *types.ChatMessage) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChatMessage"}
	if v.ContentType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContentType"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateChatParticipantRoleConfig(v *types.ChatParticipantRoleConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChatParticipantRoleConfig"}
	if v.ParticipantTimerConfigList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParticipantTimerConfigList"))
	} else if v.ParticipantTimerConfigList != nil {
		if err := validateParticipantTimerConfigList(v.ParticipantTimerConfigList); err != nil {
			invalidParams.AddNested("ParticipantTimerConfigList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateContactReferences(v map[string]types.Reference) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContactReferences"}
	for key := range v {
		value := v[key]
		if err := validateReference(&value); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateEncryptionConfig(v *types.EncryptionConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EncryptionConfig"}
	if len(v.EncryptionType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EncryptionType"))
	}
	if v.KeyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEvaluationFormItem(v types.EvaluationFormItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EvaluationFormItem"}
	switch uv := v.(type) {
	case *types.EvaluationFormItemMemberQuestion:
		if err := validateEvaluationFormQuestion(&uv.Value); err != nil {
			invalidParams.AddNested("[Question]", err.(smithy.InvalidParamsError))
		}

	case *types.EvaluationFormItemMemberSection:
		if err := validateEvaluationFormSection(&uv.Value); err != nil {
			invalidParams.AddNested("[Section]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateEvaluationFormNumericQuestionAutomation(v types.EvaluationFormNumericQuestionAutomation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EvaluationFormNumericQuestionAutomation"}
	switch uv := v.(type) {
	case *types.EvaluationFormNumericQuestionAutomationMemberPropertyValue:
		if err := validateNumericQuestionPropertyValueAutomation(&uv.Value); err != nil {
			invalidParams.AddNested("[PropertyValue]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateEvaluationFormNumericQuestionProperties(v *types.EvaluationFormNumericQuestionProperties) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EvaluationFormNumericQuestionProperties"}
	if v.Options != nil {
		if err := validateEvaluationFormNumericQuestionOptionList(v.Options); err != nil {
			invalidParams.AddNested("Options", err.(smithy.InvalidParamsError))
		}
	}
	if v.Automation != nil {
		if err := validateEvaluationFormNumericQuestionAutomation(v.Automation); err != nil {
			invalidParams.AddNested("Automation", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEvaluationFormQuestion(v *types.EvaluationFormQuestion) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EvaluationFormQuestion"}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.RefId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RefId"))
	}
	if len(v.QuestionType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("QuestionType"))
	}
	if v.QuestionTypeProperties != nil {
		if err := validateEvaluationFormQuestionTypeProperties(v.QuestionTypeProperties); err != nil {
			invalidParams.AddNested("QuestionTypeProperties", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEvaluationFormQuestionTypeProperties(v types.EvaluationFormQuestionTypeProperties) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EvaluationFormQuestionTypeProperties"}
	switch uv := v.(type) {
	case *types.EvaluationFormQuestionTypePropertiesMemberNumeric:
		if err := validateEvaluationFormNumericQuestionProperties(&uv.Value); err != nil {
			invalidParams.AddNested("[Numeric]", err.(smithy.InvalidParamsError))
		}

	case *types.EvaluationFormQuestionTypePropertiesMemberSingleSelect:
		if err := validateEvaluationFormSingleSelectQuestionProperties(&uv.Value); err != nil {
			invalidParams.AddNested("[SingleSelect]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEvaluationFormScoringStrategy(v *types.EvaluationFormScoringStrategy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EvaluationFormScoringStrategy"}
	if len(v.Mode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Mode"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEvaluationFormSection(v *types.EvaluationFormSection) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EvaluationFormSection"}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.RefId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RefId"))
	}
	if v.Items == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Items"))
	} else if v.Items != nil {
		if err := validateEvaluationFormItemsList(v.Items); err != nil {
			invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEvaluationFormSingleSelectQuestionAutomation(v *types.EvaluationFormSingleSelectQuestionAutomation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EvaluationFormSingleSelectQuestionAutomation"}
	if v.Options == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Options"))
	} else if v.Options != nil {
		if err := validateEvaluationFormSingleSelectQuestionAutomationOptionList(v.Options); err != nil {
			invalidParams.AddNested("Options", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEvaluationFormSingleSelectQuestionAutomationOption(v types.EvaluationFormSingleSelectQuestionAutomationOption) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EvaluationFormSingleSelectQuestionAutomationOption"}
	switch uv := v.(type) {
	case *types.EvaluationFormSingleSelectQuestionAutomationOptionMemberRuleCategory:
		if err := validateSingleSelectQuestionRuleCategoryAutomation(&uv.Value); err != nil {
			invalidParams.AddNested("[RuleCategory]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateEvaluationFormSingleSelectQuestionOption(v *types.EvaluationFormSingleSelectQuestionOption) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EvaluationFormSingleSelectQuestionOption"}
	if v.RefId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RefId"))
	}
	if v.Text == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Text"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateEvaluationFormSingleSelectQuestionProperties(v *types.EvaluationFormSingleSelectQuestionProperties) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EvaluationFormSingleSelectQuestionProperties"}
	if v.Options == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Options"))
	} else if v.Options != nil {
		if err := validateEvaluationFormSingleSelectQuestionOptionList(v.Options); err != nil {
			invalidParams.AddNested("Options", err.(smithy.InvalidParamsError))
		}
	}
	if v.Automation != nil {
		if err := validateEvaluationFormSingleSelectQuestionAutomation(v.Automation); err != nil {
			invalidParams.AddNested("Automation", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateHierarchyStructureUpdate(v *types.HierarchyStructureUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HierarchyStructureUpdate"}
	if v.LevelOne != nil {
		if err := validateHierarchyLevelUpdate(v.LevelOne); err != nil {
			invalidParams.AddNested("LevelOne", err.(smithy.InvalidParamsError))
		}
	}
	if v.LevelTwo != nil {
		if err := validateHierarchyLevelUpdate(v.LevelTwo); err != nil {
			invalidParams.AddNested("LevelTwo", err.(smithy.InvalidParamsError))
		}
	}
	if v.LevelThree != nil {
		if err := validateHierarchyLevelUpdate(v.LevelThree); err != nil {
			invalidParams.AddNested("LevelThree", err.(smithy.InvalidParamsError))
		}
	}
	if v.LevelFour != nil {
		if err := validateHierarchyLevelUpdate(v.LevelFour); err != nil {
			invalidParams.AddNested("LevelFour", err.(smithy.InvalidParamsError))
		}
	}
	if v.LevelFive != nil {
		if err := validateHierarchyLevelUpdate(v.LevelFive); err != nil {
			invalidParams.AddNested("LevelFive", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateHoursOfOperationConfig(v *types.HoursOfOperationConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HoursOfOperationConfig"}
	if len(v.Day) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Day"))
	}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	} else if v.StartTime != nil {
		if err := validateHoursOfOperationTimeSlice(v.StartTime); err != nil {
			invalidParams.AddNested("StartTime", err.(smithy.InvalidParamsError))
		}
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	} else if v.EndTime != nil {
		if err := validateHoursOfOperationTimeSlice(v.EndTime); err != nil {
			invalidParams.AddNested("EndTime", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateHoursOfOperationTimeSlice(v *types.HoursOfOperationTimeSlice) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HoursOfOperationTimeSlice"}
	if v.Hours == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Hours"))
	}
	if v.Minutes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Minutes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInstanceStorageConfig(v *types.InstanceStorageConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InstanceStorageConfig"}
	if len(v.StorageType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("StorageType"))
	}
	if v.S3Config != nil {
		if err := validateS3Config(v.S3Config); err != nil {
			invalidParams.AddNested("S3Config", err.(smithy.InvalidParamsError))
		}
	}
	if v.KinesisVideoStreamConfig != nil {
		if err := validateKinesisVideoStreamConfig(v.KinesisVideoStreamConfig); err != nil {
			invalidParams.AddNested("KinesisVideoStreamConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.KinesisStreamConfig != nil {
		if err := validateKinesisStreamConfig(v.KinesisStreamConfig); err != nil {
			invalidParams.AddNested("KinesisStreamConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.KinesisFirehoseConfig != nil {
		if err := validateKinesisFirehoseConfig(v.KinesisFirehoseConfig); err != nil {
			invalidParams.AddNested("KinesisFirehoseConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateKinesisVideoStreamConfig(v *types.KinesisVideoStreamConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KinesisVideoStreamConfig"}
	if v.Prefix == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Prefix"))
	}
	if v.EncryptionConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EncryptionConfig"))
	} else if v.EncryptionConfig != nil {
		if err := validateEncryptionConfig(v.EncryptionConfig); err != nil {
			invalidParams.AddNested("EncryptionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateMediaConcurrency(v *types.MediaConcurrency) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MediaConcurrency"}
	if len(v.Channel) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Channel"))
	}
	if v.CrossChannelBehavior != nil {
		if err := validateCrossChannelBehavior(v.CrossChannelBehavior); err != nil {
			invalidParams.AddNested("CrossChannelBehavior", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateParticipantTimerConfiguration(v *types.ParticipantTimerConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParticipantTimerConfiguration"}
	if len(v.ParticipantRole) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ParticipantRole"))
	}
	if len(v.TimerType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TimerType"))
	}
	if v.TimerValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimerValue"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateQueueQuickConnectConfig(v *types.QueueQuickConnectConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QueueQuickConnectConfig"}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.ContactFlowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateQuickConnectConfig(v *types.QuickConnectConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QuickConnectConfig"}
	if len(v.QuickConnectType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("QuickConnectType"))
	}
	if v.UserConfig != nil {
		if err := validateUserQuickConnectConfig(v.UserConfig); err != nil {
			invalidParams.AddNested("UserConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.QueueConfig != nil {
		if err := validateQueueQuickConnectConfig(v.QueueConfig); err != nil {
			invalidParams.AddNested("QueueConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.PhoneConfig != nil {
		if err := validatePhoneNumberQuickConnectConfig(v.PhoneConfig); err != nil {
			invalidParams.AddNested("PhoneConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateReference(v *types.Reference) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Reference"}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRoutingProfileQueueConfig(v *types.RoutingProfileQueueConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RoutingProfileQueueConfig"}
	if v.QueueReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueReference"))
	} else if v.QueueReference != nil {
		if err := validateRoutingProfileQueueReference(v.QueueReference); err != nil {
			invalidParams.AddNested("QueueReference", err.(smithy.InvalidParamsError))
		}
	}
	if v.Priority == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Priority"))
	}
	if v.Delay == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Delay"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRoutingProfileQueueReference(v *types.RoutingProfileQueueReference) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RoutingProfileQueueReference"}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if len(v.Channel) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Channel"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRuleAction(v *types.RuleAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RuleAction"}
	if len(v.ActionType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ActionType"))
	}
	if v.TaskAction != nil {
		if err := validateTaskActionDefinition(v.TaskAction); err != nil {
			invalidParams.AddNested("TaskAction", err.(smithy.InvalidParamsError))
		}
	}
	if v.EventBridgeAction != nil {
		if err := validateEventBridgeActionDefinition(v.EventBridgeAction); err != nil {
			invalidParams.AddNested("EventBridgeAction", err.(smithy.InvalidParamsError))
		}
	}
	if v.SendNotificationAction != nil {
		if err := validateSendNotificationActionDefinition(v.SendNotificationAction); err != nil {
			invalidParams.AddNested("SendNotificationAction", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateS3Config(v *types.S3Config) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3Config"}
	if v.BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
	}
	if v.BucketPrefix == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BucketPrefix"))
	}
	if v.EncryptionConfig != nil {
		if err := validateEncryptionConfig(v.EncryptionConfig); err != nil {
			invalidParams.AddNested("EncryptionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSendNotificationActionDefinition(v *types.SendNotificationActionDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SendNotificationActionDefinition"}
	if len(v.DeliveryMethod) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DeliveryMethod"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	}
	if len(v.ContentType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ContentType"))
	}
	if v.Recipient == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Recipient"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSingleSelectQuestionRuleCategoryAutomation(v *types.SingleSelectQuestionRuleCategoryAutomation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SingleSelectQuestionRuleCategoryAutomation"}
	if v.Category == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Category"))
	}
	if len(v.Condition) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Condition"))
	}
	if v.OptionRefId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OptionRefId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTaskActionDefinition(v *types.TaskActionDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TaskActionDefinition"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ContactFlowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowId"))
	}
	if v.References != nil {
		if err := validateContactReferences(v.References); err != nil {
			invalidParams.AddNested("References", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateTelephonyConfig(v *types.TelephonyConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TelephonyConfig"}
	if v.Distributions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Distributions"))
	} else if v.Distributions != nil {
		if err := validateDistributionList(v.Distributions); err != nil {
			invalidParams.AddNested("Distributions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateUpdateParticipantRoleConfigChannelInfo(v types.UpdateParticipantRoleConfigChannelInfo) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateParticipantRoleConfigChannelInfo"}
	switch uv := v.(type) {
	case *types.UpdateParticipantRoleConfigChannelInfoMemberChat:
		if err := validateChatParticipantRoleConfig(&uv.Value); err != nil {
			invalidParams.AddNested("[Chat]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateUserQuickConnectConfig(v *types.UserQuickConnectConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UserQuickConnectConfig"}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if v.ContactFlowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpActivateEvaluationFormInput(v *ActivateEvaluationFormInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ActivateEvaluationFormInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.EvaluationFormId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluationFormId"))
	}
	if v.EvaluationFormVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluationFormVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateApprovedOriginInput(v *AssociateApprovedOriginInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateApprovedOriginInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Origin == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Origin"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateBotInput(v *AssociateBotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateBotInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.LexBot != nil {
		if err := validateLexBot(v.LexBot); err != nil {
			invalidParams.AddNested("LexBot", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateDefaultVocabularyInput(v *AssociateDefaultVocabularyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateDefaultVocabularyInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if len(v.LanguageCode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LanguageCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateInstanceStorageConfigInput(v *AssociateInstanceStorageConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateInstanceStorageConfigInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if v.StorageConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StorageConfig"))
	} else if v.StorageConfig != nil {
		if err := validateInstanceStorageConfig(v.StorageConfig); err != nil {
			invalidParams.AddNested("StorageConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateLambdaFunctionInput(v *AssociateLambdaFunctionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateLambdaFunctionInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.FunctionArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateLexBotInput(v *AssociateLexBotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateLexBotInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.LexBot == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LexBot"))
	} else if v.LexBot != nil {
		if err := validateLexBot(v.LexBot); err != nil {
			invalidParams.AddNested("LexBot", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpAssociateQueueQuickConnectsInput(v *AssociateQueueQuickConnectsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateQueueQuickConnectsInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.QuickConnectIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QuickConnectIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateRoutingProfileQueuesInput(v *AssociateRoutingProfileQueuesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateRoutingProfileQueuesInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.RoutingProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
	}
	if v.QueueConfigs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueConfigs"))
	} else if v.QueueConfigs != nil {
		if err := validateRoutingProfileQueueConfigList(v.QueueConfigs); err != nil {
			invalidParams.AddNested("QueueConfigs", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateSecurityKeyInput(v *AssociateSecurityKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateSecurityKeyInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Key == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Key"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpClaimPhoneNumberInput(v *ClaimPhoneNumberInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ClaimPhoneNumberInput"}
	if v.TargetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetArn"))
	}
	if v.PhoneNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PhoneNumber"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAgentStatusInput(v *CreateAgentStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAgentStatusInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.State) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("State"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateContactFlowInput(v *CreateContactFlowInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateContactFlowInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateEvaluationFormInput(v *CreateEvaluationFormInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateEvaluationFormInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.Items == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Items"))
	} else if v.Items != nil {
		if err := validateEvaluationFormItemsList(v.Items); err != nil {
			invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
		}
	}
	if v.ScoringStrategy != nil {
		if err := validateEvaluationFormScoringStrategy(v.ScoringStrategy); err != nil {
			invalidParams.AddNested("ScoringStrategy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateHoursOfOperationInput(v *CreateHoursOfOperationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateHoursOfOperationInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.TimeZone == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimeZone"))
	}
	if v.Config == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Config"))
	} else if v.Config != nil {
		if err := validateHoursOfOperationConfigList(v.Config); err != nil {
			invalidParams.AddNested("Config", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateInstanceInput(v *CreateInstanceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateInstanceInput"}
	if len(v.IdentityManagementType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("IdentityManagementType"))
	}
	if v.InboundCallsEnabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InboundCallsEnabled"))
	}
	if v.OutboundCallsEnabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutboundCallsEnabled"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateIntegrationAssociationInput(v *CreateIntegrationAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateIntegrationAssociationInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if len(v.IntegrationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationType"))
	}
	if v.IntegrationArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateParticipantInput(v *CreateParticipantInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateParticipantInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
	}
	if v.ParticipantDetails == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParticipantDetails"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpCreateQuickConnectInput(v *CreateQuickConnectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateQuickConnectInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.QuickConnectConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QuickConnectConfig"))
	} else if v.QuickConnectConfig != nil {
		if err := validateQuickConnectConfig(v.QuickConnectConfig); err != nil {
			invalidParams.AddNested("QuickConnectConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRoutingProfileInput(v *CreateRoutingProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRoutingProfileInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Description == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Description"))
	}
	if v.DefaultOutboundQueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultOutboundQueueId"))
	}
	if v.QueueConfigs != nil {
		if err := validateRoutingProfileQueueConfigList(v.QueueConfigs); err != nil {
			invalidParams.AddNested("QueueConfigs", err.(smithy.InvalidParamsError))
		}
	}
	if v.MediaConcurrencies == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MediaConcurrencies"))
	} else if v.MediaConcurrencies != nil {
		if err := validateMediaConcurrencies(v.MediaConcurrencies); err != nil {
			invalidParams.AddNested("MediaConcurrencies", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRuleInput(v *CreateRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRuleInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.TriggerEventSource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TriggerEventSource"))
	} else if v.TriggerEventSource != nil {
		if err := validateRuleTriggerEventSource(v.TriggerEventSource); err != nil {
			invalidParams.AddNested("TriggerEventSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.Function == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Function"))
	}
	if v.Actions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Actions"))
	} else if v.Actions != nil {
		if err := validateRuleActions(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.PublishStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PublishStatus"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSecurityProfileInput(v *CreateSecurityProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSecurityProfileInput"}
	if v.SecurityProfileName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityProfileName"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTaskTemplateInput(v *CreateTaskTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTaskTemplateInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Fields == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Fields"))
	} else if v.Fields != nil {
		if err := validateTaskTemplateFields(v.Fields); err != nil {
			invalidParams.AddNested("Fields", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateUseCaseInput(v *CreateUseCaseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateUseCaseInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.IntegrationAssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationAssociationId"))
	}
	if len(v.UseCaseType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("UseCaseType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateUserHierarchyGroupInput(v *CreateUserHierarchyGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateUserHierarchyGroupInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	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.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if v.PhoneConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PhoneConfig"))
	} else if v.PhoneConfig != nil {
		if err := validateUserPhoneConfig(v.PhoneConfig); err != nil {
			invalidParams.AddNested("PhoneConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.SecurityProfileIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityProfileIds"))
	}
	if v.RoutingProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateVocabularyInput(v *CreateVocabularyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVocabularyInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.VocabularyName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VocabularyName"))
	}
	if len(v.LanguageCode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LanguageCode"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeactivateEvaluationFormInput(v *DeactivateEvaluationFormInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeactivateEvaluationFormInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.EvaluationFormId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluationFormId"))
	}
	if v.EvaluationFormVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluationFormVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteContactEvaluationInput(v *DeleteContactEvaluationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteContactEvaluationInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.EvaluationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteContactFlowInput(v *DeleteContactFlowInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteContactFlowInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactFlowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteContactFlowModuleInput(v *DeleteContactFlowModuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteContactFlowModuleInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactFlowModuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowModuleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteEvaluationFormInput(v *DeleteEvaluationFormInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteEvaluationFormInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.EvaluationFormId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluationFormId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteHoursOfOperationInput(v *DeleteHoursOfOperationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteHoursOfOperationInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.HoursOfOperationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HoursOfOperationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteIntegrationAssociationInput(v *DeleteIntegrationAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIntegrationAssociationInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.IntegrationAssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationAssociationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeletePromptInput(v *DeletePromptInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeletePromptInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.PromptId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PromptId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteQueueInput(v *DeleteQueueInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteQueueInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteQuickConnectInput(v *DeleteQuickConnectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteQuickConnectInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.QuickConnectId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QuickConnectId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRoutingProfileInput(v *DeleteRoutingProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRoutingProfileInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.RoutingProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRuleInput(v *DeleteRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRuleInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.RuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteSecurityProfileInput(v *DeleteSecurityProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteSecurityProfileInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.SecurityProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityProfileId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTaskTemplateInput(v *DeleteTaskTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTaskTemplateInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.TaskTemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskTemplateId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteUseCaseInput(v *DeleteUseCaseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteUseCaseInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.IntegrationAssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationAssociationId"))
	}
	if v.UseCaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UseCaseId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteUserHierarchyGroupInput(v *DeleteUserHierarchyGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserHierarchyGroupInput"}
	if v.HierarchyGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HierarchyGroupId"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteUserInput(v *DeleteUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteVocabularyInput(v *DeleteVocabularyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVocabularyInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.VocabularyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VocabularyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeAgentStatusInput(v *DescribeAgentStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeAgentStatusInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.AgentStatusId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentStatusId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeContactEvaluationInput(v *DescribeContactEvaluationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeContactEvaluationInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.EvaluationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeContactFlowInput(v *DescribeContactFlowInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeContactFlowInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactFlowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeContactFlowModuleInput(v *DescribeContactFlowModuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeContactFlowModuleInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactFlowModuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowModuleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeContactInput(v *DescribeContactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeContactInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeEvaluationFormInput(v *DescribeEvaluationFormInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeEvaluationFormInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.EvaluationFormId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluationFormId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeHoursOfOperationInput(v *DescribeHoursOfOperationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeHoursOfOperationInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.HoursOfOperationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HoursOfOperationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeInstanceAttributeInput(v *DescribeInstanceAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeInstanceAttributeInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if len(v.AttributeType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDescribeInstanceStorageConfigInput(v *DescribeInstanceStorageConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeInstanceStorageConfigInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.AssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
	}
	if len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDescribePromptInput(v *DescribePromptInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribePromptInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.PromptId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PromptId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeQueueInput(v *DescribeQueueInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeQueueInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeQuickConnectInput(v *DescribeQuickConnectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeQuickConnectInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.QuickConnectId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QuickConnectId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeRoutingProfileInput(v *DescribeRoutingProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeRoutingProfileInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.RoutingProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeRuleInput(v *DescribeRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeRuleInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.RuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeSecurityProfileInput(v *DescribeSecurityProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeSecurityProfileInput"}
	if v.SecurityProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityProfileId"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDescribeUserHierarchyGroupInput(v *DescribeUserHierarchyGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeUserHierarchyGroupInput"}
	if v.HierarchyGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HierarchyGroupId"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDescribeUserInput(v *DescribeUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeUserInput"}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeVocabularyInput(v *DescribeVocabularyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeVocabularyInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.VocabularyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VocabularyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateApprovedOriginInput(v *DisassociateApprovedOriginInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateApprovedOriginInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Origin == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Origin"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateBotInput(v *DisassociateBotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateBotInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.LexBot != nil {
		if err := validateLexBot(v.LexBot); err != nil {
			invalidParams.AddNested("LexBot", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateInstanceStorageConfigInput(v *DisassociateInstanceStorageConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateInstanceStorageConfigInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.AssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
	}
	if len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateLambdaFunctionInput(v *DisassociateLambdaFunctionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateLambdaFunctionInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.FunctionArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateLexBotInput(v *DisassociateLexBotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateLexBotInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.BotName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotName"))
	}
	if v.LexRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LexRegion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDisassociateQueueQuickConnectsInput(v *DisassociateQueueQuickConnectsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateQueueQuickConnectsInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.QuickConnectIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QuickConnectIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateRoutingProfileQueuesInput(v *DisassociateRoutingProfileQueuesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateRoutingProfileQueuesInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.RoutingProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
	}
	if v.QueueReferences == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueReferences"))
	} else if v.QueueReferences != nil {
		if err := validateRoutingProfileQueueReferenceList(v.QueueReferences); err != nil {
			invalidParams.AddNested("QueueReferences", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateSecurityKeyInput(v *DisassociateSecurityKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateSecurityKeyInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.AssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDismissUserContactInput(v *DismissUserContactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DismissUserContactInput"}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetContactAttributesInput(v *GetContactAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetContactAttributesInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.InitialContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InitialContactId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCurrentMetricDataInput(v *GetCurrentMetricDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCurrentMetricDataInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Filters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
	}
	if v.CurrentMetrics == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CurrentMetrics"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCurrentUserDataInput(v *GetCurrentUserDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCurrentUserDataInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Filters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetMetricDataInput(v *GetMetricDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMetricDataInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if v.Filters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
	}
	if v.HistoricalMetrics == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HistoricalMetrics"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetMetricDataV2Input(v *GetMetricDataV2Input) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMetricDataV2Input"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if v.Filters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
	}
	if v.Metrics == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Metrics"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetPromptFileInput(v *GetPromptFileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPromptFileInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.PromptId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PromptId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetTaskTemplateInput(v *GetTaskTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTaskTemplateInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.TaskTemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskTemplateId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpListContactEvaluationsInput(v *ListContactEvaluationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListContactEvaluationsInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListContactReferencesInput(v *ListContactReferencesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListContactReferencesInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
	}
	if v.ReferenceTypes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReferenceTypes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListEvaluationFormVersionsInput(v *ListEvaluationFormVersionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListEvaluationFormVersionsInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.EvaluationFormId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluationFormId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListInstanceStorageConfigsInput(v *ListInstanceStorageConfigsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListInstanceStorageConfigsInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpListQueueQuickConnectsInput(v *ListQueueQuickConnectsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListQueueQuickConnectsInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListRoutingProfileQueuesInput(v *ListRoutingProfileQueuesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListRoutingProfileQueuesInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.RoutingProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpListSecurityProfilePermissionsInput(v *ListSecurityProfilePermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListSecurityProfilePermissionsInput"}
	if v.SecurityProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityProfileId"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListUseCasesInput(v *ListUseCasesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListUseCasesInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.IntegrationAssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationAssociationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpMonitorContactInput(v *MonitorContactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MonitorContactInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
	}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutUserStatusInput(v *PutUserStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutUserStatusInput"}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.AgentStatusId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentStatusId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpReplicateInstanceInput(v *ReplicateInstanceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReplicateInstanceInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ReplicaRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicaRegion"))
	}
	if v.ReplicaAlias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicaAlias"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpResumeContactRecordingInput(v *ResumeContactRecordingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResumeContactRecordingInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
	}
	if v.InitialContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InitialContactId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchAvailablePhoneNumbersInput(v *SearchAvailablePhoneNumbersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchAvailablePhoneNumbersInput"}
	if v.TargetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetArn"))
	}
	if len(v.PhoneNumberCountryCode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PhoneNumberCountryCode"))
	}
	if len(v.PhoneNumberType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PhoneNumberType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

func validateOpStartChatContactInput(v *StartChatContactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartChatContactInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactFlowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowId"))
	}
	if v.ParticipantDetails == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParticipantDetails"))
	} else if v.ParticipantDetails != nil {
		if err := validateParticipantDetails(v.ParticipantDetails); err != nil {
			invalidParams.AddNested("ParticipantDetails", err.(smithy.InvalidParamsError))
		}
	}
	if v.InitialMessage != nil {
		if err := validateChatMessage(v.InitialMessage); err != nil {
			invalidParams.AddNested("InitialMessage", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartContactEvaluationInput(v *StartContactEvaluationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartContactEvaluationInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
	}
	if v.EvaluationFormId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluationFormId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartContactRecordingInput(v *StartContactRecordingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartContactRecordingInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
	}
	if v.InitialContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InitialContactId"))
	}
	if v.VoiceRecordingConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceRecordingConfiguration"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartContactStreamingInput(v *StartContactStreamingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartContactStreamingInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
	}
	if v.ChatStreamingConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChatStreamingConfiguration"))
	} else if v.ChatStreamingConfiguration != nil {
		if err := validateChatStreamingConfiguration(v.ChatStreamingConfiguration); err != nil {
			invalidParams.AddNested("ChatStreamingConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ClientToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpStartTaskContactInput(v *StartTaskContactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartTaskContactInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.References != nil {
		if err := validateContactReferences(v.References); err != nil {
			invalidParams.AddNested("References", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopContactInput(v *StopContactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopContactInput"}
	if v.ContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopContactRecordingInput(v *StopContactRecordingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopContactRecordingInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
	}
	if v.InitialContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InitialContactId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopContactStreamingInput(v *StopContactStreamingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopContactStreamingInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
	}
	if v.StreamingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StreamingId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSubmitContactEvaluationInput(v *SubmitContactEvaluationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SubmitContactEvaluationInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.EvaluationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSuspendContactRecordingInput(v *SuspendContactRecordingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SuspendContactRecordingInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
	}
	if v.InitialContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InitialContactId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpTransferContactInput(v *TransferContactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TransferContactInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
	}
	if v.ContactFlowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowId"))
	}
	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 validateOpUpdateAgentStatusInput(v *UpdateAgentStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAgentStatusInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.AgentStatusId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentStatusId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateContactAttributesInput(v *UpdateContactAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateContactAttributesInput"}
	if v.InitialContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InitialContactId"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Attributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Attributes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateContactEvaluationInput(v *UpdateContactEvaluationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateContactEvaluationInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.EvaluationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateContactFlowContentInput(v *UpdateContactFlowContentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateContactFlowContentInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactFlowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowId"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateContactFlowMetadataInput(v *UpdateContactFlowMetadataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateContactFlowMetadataInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactFlowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateContactFlowModuleContentInput(v *UpdateContactFlowModuleContentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateContactFlowModuleContentInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactFlowModuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowModuleId"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateContactFlowModuleMetadataInput(v *UpdateContactFlowModuleMetadataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateContactFlowModuleMetadataInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactFlowModuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowModuleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateContactFlowNameInput(v *UpdateContactFlowNameInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateContactFlowNameInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactFlowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactFlowId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateContactInput(v *UpdateContactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateContactInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
	}
	if v.References != nil {
		if err := validateContactReferences(v.References); err != nil {
			invalidParams.AddNested("References", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateContactScheduleInput(v *UpdateContactScheduleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateContactScheduleInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
	}
	if v.ScheduledTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScheduledTime"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateEvaluationFormInput(v *UpdateEvaluationFormInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateEvaluationFormInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.EvaluationFormId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluationFormId"))
	}
	if v.EvaluationFormVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluationFormVersion"))
	}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.Items == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Items"))
	} else if v.Items != nil {
		if err := validateEvaluationFormItemsList(v.Items); err != nil {
			invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
		}
	}
	if v.ScoringStrategy != nil {
		if err := validateEvaluationFormScoringStrategy(v.ScoringStrategy); err != nil {
			invalidParams.AddNested("ScoringStrategy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateHoursOfOperationInput(v *UpdateHoursOfOperationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateHoursOfOperationInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.HoursOfOperationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HoursOfOperationId"))
	}
	if v.Config != nil {
		if err := validateHoursOfOperationConfigList(v.Config); err != nil {
			invalidParams.AddNested("Config", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateInstanceAttributeInput(v *UpdateInstanceAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateInstanceAttributeInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if len(v.AttributeType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeType"))
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateInstanceStorageConfigInput(v *UpdateInstanceStorageConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateInstanceStorageConfigInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.AssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
	}
	if len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if v.StorageConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StorageConfig"))
	} else if v.StorageConfig != nil {
		if err := validateInstanceStorageConfig(v.StorageConfig); err != nil {
			invalidParams.AddNested("StorageConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateParticipantRoleConfigInput(v *UpdateParticipantRoleConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateParticipantRoleConfigInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.ContactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactId"))
	}
	if v.ChannelConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelConfiguration"))
	} else if v.ChannelConfiguration != nil {
		if err := validateUpdateParticipantRoleConfigChannelInfo(v.ChannelConfiguration); err != nil {
			invalidParams.AddNested("ChannelConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdatePromptInput(v *UpdatePromptInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePromptInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.PromptId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PromptId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateQueueHoursOfOperationInput(v *UpdateQueueHoursOfOperationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateQueueHoursOfOperationInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.HoursOfOperationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HoursOfOperationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateQueueMaxContactsInput(v *UpdateQueueMaxContactsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateQueueMaxContactsInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateQueueNameInput(v *UpdateQueueNameInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateQueueNameInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateQueueOutboundCallerConfigInput(v *UpdateQueueOutboundCallerConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateQueueOutboundCallerConfigInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.OutboundCallerConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutboundCallerConfig"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateQueueStatusInput(v *UpdateQueueStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateQueueStatusInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateQuickConnectConfigInput(v *UpdateQuickConnectConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateQuickConnectConfigInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.QuickConnectId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QuickConnectId"))
	}
	if v.QuickConnectConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QuickConnectConfig"))
	} else if v.QuickConnectConfig != nil {
		if err := validateQuickConnectConfig(v.QuickConnectConfig); err != nil {
			invalidParams.AddNested("QuickConnectConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateQuickConnectNameInput(v *UpdateQuickConnectNameInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateQuickConnectNameInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.QuickConnectId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QuickConnectId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRoutingProfileConcurrencyInput(v *UpdateRoutingProfileConcurrencyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRoutingProfileConcurrencyInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.RoutingProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
	}
	if v.MediaConcurrencies == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MediaConcurrencies"))
	} else if v.MediaConcurrencies != nil {
		if err := validateMediaConcurrencies(v.MediaConcurrencies); err != nil {
			invalidParams.AddNested("MediaConcurrencies", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRoutingProfileDefaultOutboundQueueInput(v *UpdateRoutingProfileDefaultOutboundQueueInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRoutingProfileDefaultOutboundQueueInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.RoutingProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
	}
	if v.DefaultOutboundQueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultOutboundQueueId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRoutingProfileNameInput(v *UpdateRoutingProfileNameInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRoutingProfileNameInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.RoutingProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRoutingProfileQueuesInput(v *UpdateRoutingProfileQueuesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRoutingProfileQueuesInput"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.RoutingProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
	}
	if v.QueueConfigs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueConfigs"))
	} else if v.QueueConfigs != nil {
		if err := validateRoutingProfileQueueConfigList(v.QueueConfigs); err != nil {
			invalidParams.AddNested("QueueConfigs", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRuleInput(v *UpdateRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRuleInput"}
	if v.RuleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleId"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Function == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Function"))
	}
	if v.Actions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Actions"))
	} else if v.Actions != nil {
		if err := validateRuleActions(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.PublishStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PublishStatus"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateSecurityProfileInput(v *UpdateSecurityProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSecurityProfileInput"}
	if v.SecurityProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityProfileId"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateTaskTemplateInput(v *UpdateTaskTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTaskTemplateInput"}
	if v.TaskTemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskTemplateId"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Fields != nil {
		if err := validateTaskTemplateFields(v.Fields); err != nil {
			invalidParams.AddNested("Fields", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateTrafficDistributionInput(v *UpdateTrafficDistributionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTrafficDistributionInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.TelephonyConfig != nil {
		if err := validateTelephonyConfig(v.TelephonyConfig); err != nil {
			invalidParams.AddNested("TelephonyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateUserHierarchyInput(v *UpdateUserHierarchyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserHierarchyInput"}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateUserHierarchyStructureInput(v *UpdateUserHierarchyStructureInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserHierarchyStructureInput"}
	if v.HierarchyStructure == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HierarchyStructure"))
	} else if v.HierarchyStructure != nil {
		if err := validateHierarchyStructureUpdate(v.HierarchyStructure); err != nil {
			invalidParams.AddNested("HierarchyStructure", err.(smithy.InvalidParamsError))
		}
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateUserIdentityInfoInput(v *UpdateUserIdentityInfoInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserIdentityInfoInput"}
	if v.IdentityInfo == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdentityInfo"))
	}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateUserPhoneConfigInput(v *UpdateUserPhoneConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserPhoneConfigInput"}
	if v.PhoneConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PhoneConfig"))
	} else if v.PhoneConfig != nil {
		if err := validateUserPhoneConfig(v.PhoneConfig); err != nil {
			invalidParams.AddNested("PhoneConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateUserRoutingProfileInput(v *UpdateUserRoutingProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserRoutingProfileInput"}
	if v.RoutingProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoutingProfileId"))
	}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateUserSecurityProfilesInput(v *UpdateUserSecurityProfilesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserSecurityProfilesInput"}
	if v.SecurityProfileIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityProfileIds"))
	}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}