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

package transcribe

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

type validateOpCreateCallAnalyticsCategory struct {
}

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

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

type validateOpCreateLanguageModel struct {
}

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

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

type validateOpCreateMedicalVocabulary struct {
}

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

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

type validateOpCreateVocabularyFilter struct {
}

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

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

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

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

type validateOpDeleteCallAnalyticsJob struct {
}

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

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

type validateOpDeleteLanguageModel struct {
}

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

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

type validateOpDeleteMedicalTranscriptionJob struct {
}

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

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

type validateOpDeleteMedicalVocabulary struct {
}

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

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

type validateOpDeleteTranscriptionJob struct {
}

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

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

type validateOpDeleteVocabularyFilter struct {
}

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

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

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

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

type validateOpGetCallAnalyticsCategory struct {
}

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

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

type validateOpGetCallAnalyticsJob struct {
}

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

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

type validateOpGetMedicalTranscriptionJob struct {
}

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

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

type validateOpGetMedicalVocabulary struct {
}

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

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

type validateOpGetTranscriptionJob struct {
}

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

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

type validateOpGetVocabularyFilter struct {
}

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

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

type validateOpGetVocabulary struct {
}

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

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

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

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

type validateOpStartMedicalTranscriptionJob struct {
}

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

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

type validateOpStartTranscriptionJob struct {
}

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

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

type validateOpTagResource struct {
}

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

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

type validateOpUntagResource struct {
}

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

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

type validateOpUpdateCallAnalyticsCategory struct {
}

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

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

type validateOpUpdateMedicalVocabulary struct {
}

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

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

type validateOpUpdateVocabularyFilter struct {
}

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

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

type validateOpUpdateVocabulary struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateCallAnalyticsJobSettings(v *types.CallAnalyticsJobSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CallAnalyticsJobSettings"}
	if v.ContentRedaction != nil {
		if err := validateContentRedaction(v.ContentRedaction); err != nil {
			invalidParams.AddNested("ContentRedaction", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateContentRedaction(v *types.ContentRedaction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContentRedaction"}
	if len(v.RedactionType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RedactionType"))
	}
	if len(v.RedactionOutput) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RedactionOutput"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInputDataConfig(v *types.InputDataConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InputDataConfig"}
	if v.S3Uri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3Uri"))
	}
	if v.DataAccessRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataAccessRoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRule(v types.Rule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Rule"}
	switch uv := v.(type) {
	case *types.RuleMemberSentimentFilter:
		if err := validateSentimentFilter(&uv.Value); err != nil {
			invalidParams.AddNested("[SentimentFilter]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

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

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

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

func validateTranscriptFilter(v *types.TranscriptFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TranscriptFilter"}
	if len(v.TranscriptFilterType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TranscriptFilterType"))
	}
	if v.Targets == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Targets"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCallAnalyticsCategoryInput(v *CreateCallAnalyticsCategoryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCallAnalyticsCategoryInput"}
	if v.CategoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CategoryName"))
	}
	if v.Rules == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Rules"))
	} else if v.Rules != nil {
		if err := validateRuleList(v.Rules); err != nil {
			invalidParams.AddNested("Rules", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLanguageModelInput(v *CreateLanguageModelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLanguageModelInput"}
	if len(v.LanguageCode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LanguageCode"))
	}
	if len(v.BaseModelName) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("BaseModelName"))
	}
	if v.ModelName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelName"))
	}
	if v.InputDataConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputDataConfig"))
	} else if v.InputDataConfig != nil {
		if err := validateInputDataConfig(v.InputDataConfig); err != nil {
			invalidParams.AddNested("InputDataConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMedicalVocabularyInput(v *CreateMedicalVocabularyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMedicalVocabularyInput"}
	if v.VocabularyName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VocabularyName"))
	}
	if len(v.LanguageCode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LanguageCode"))
	}
	if v.VocabularyFileUri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VocabularyFileUri"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpGetVocabularyInput(v *GetVocabularyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetVocabularyInput"}
	if v.VocabularyName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VocabularyName"))
	}
	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 validateOpStartCallAnalyticsJobInput(v *StartCallAnalyticsJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartCallAnalyticsJobInput"}
	if v.CallAnalyticsJobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CallAnalyticsJobName"))
	}
	if v.Media == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Media"))
	}
	if v.Settings != nil {
		if err := validateCallAnalyticsJobSettings(v.Settings); err != nil {
			invalidParams.AddNested("Settings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartMedicalTranscriptionJobInput(v *StartMedicalTranscriptionJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartMedicalTranscriptionJobInput"}
	if v.MedicalTranscriptionJobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MedicalTranscriptionJobName"))
	}
	if len(v.LanguageCode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LanguageCode"))
	}
	if v.Media == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Media"))
	}
	if v.OutputBucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputBucketName"))
	}
	if len(v.Specialty) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Specialty"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartTranscriptionJobInput(v *StartTranscriptionJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartTranscriptionJobInput"}
	if v.TranscriptionJobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TranscriptionJobName"))
	}
	if v.Media == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Media"))
	}
	if v.ContentRedaction != nil {
		if err := validateContentRedaction(v.ContentRedaction); err != nil {
			invalidParams.AddNested("ContentRedaction", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.ToxicityDetection != nil {
		if err := validateToxicityDetection(v.ToxicityDetection); err != nil {
			invalidParams.AddNested("ToxicityDetection", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func 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 validateOpUpdateCallAnalyticsCategoryInput(v *UpdateCallAnalyticsCategoryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCallAnalyticsCategoryInput"}
	if v.CategoryName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CategoryName"))
	}
	if v.Rules == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Rules"))
	} else if v.Rules != nil {
		if err := validateRuleList(v.Rules); err != nil {
			invalidParams.AddNested("Rules", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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