service/lexmodelsv2/validators.go

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

package lexmodelsv2

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

type validateOpBatchCreateCustomVocabularyItem struct {
}

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

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

type validateOpBatchDeleteCustomVocabularyItem struct {
}

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

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

type validateOpBatchUpdateCustomVocabularyItem struct {
}

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

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

type validateOpBuildBotLocale struct {
}

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

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

type validateOpCreateBotAlias struct {
}

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

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

type validateOpCreateBot struct {
}

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

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

type validateOpCreateBotLocale struct {
}

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

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

type validateOpCreateBotReplica struct {
}

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

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

type validateOpCreateBotVersion struct {
}

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

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

type validateOpCreateExport struct {
}

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

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

type validateOpCreateIntent struct {
}

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

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

type validateOpCreateResourcePolicy struct {
}

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

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

type validateOpCreateResourcePolicyStatement struct {
}

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

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

type validateOpCreateSlot struct {
}

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

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

type validateOpCreateSlotType struct {
}

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

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

type validateOpCreateTestSetDiscrepancyReport struct {
}

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

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

type validateOpDeleteBotAlias struct {
}

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

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

type validateOpDeleteBot struct {
}

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

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

type validateOpDeleteBotLocale struct {
}

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

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

type validateOpDeleteBotReplica struct {
}

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

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

type validateOpDeleteBotVersion struct {
}

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

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

type validateOpDeleteCustomVocabulary struct {
}

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

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

type validateOpDeleteExport struct {
}

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

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

type validateOpDeleteImport struct {
}

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

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

type validateOpDeleteIntent struct {
}

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

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

type validateOpDeleteResourcePolicy struct {
}

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

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

type validateOpDeleteResourcePolicyStatement struct {
}

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

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

type validateOpDeleteSlot struct {
}

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

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

type validateOpDeleteSlotType struct {
}

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

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

type validateOpDeleteTestSet struct {
}

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

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

type validateOpDeleteUtterances struct {
}

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

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

type validateOpDescribeBotAlias struct {
}

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

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

type validateOpDescribeBot struct {
}

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

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

type validateOpDescribeBotLocale struct {
}

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

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

type validateOpDescribeBotRecommendation struct {
}

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

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

type validateOpDescribeBotReplica struct {
}

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

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

type validateOpDescribeBotResourceGeneration struct {
}

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

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

type validateOpDescribeBotVersion struct {
}

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

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

type validateOpDescribeCustomVocabularyMetadata struct {
}

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

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

type validateOpDescribeExport struct {
}

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

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

type validateOpDescribeImport struct {
}

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

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

type validateOpDescribeIntent struct {
}

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

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

type validateOpDescribeResourcePolicy struct {
}

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

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

type validateOpDescribeSlot struct {
}

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

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

type validateOpDescribeSlotType struct {
}

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

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

type validateOpDescribeTestExecution struct {
}

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

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

type validateOpDescribeTestSetDiscrepancyReport struct {
}

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

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

type validateOpDescribeTestSetGeneration struct {
}

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

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

type validateOpDescribeTestSet struct {
}

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

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

type validateOpGenerateBotElement struct {
}

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

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

type validateOpGetTestExecutionArtifactsUrl struct {
}

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

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

type validateOpListAggregatedUtterances struct {
}

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

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

type validateOpListBotAliases struct {
}

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

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

type validateOpListBotAliasReplicas struct {
}

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

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

type validateOpListBotLocales struct {
}

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

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

type validateOpListBotRecommendations struct {
}

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

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

type validateOpListBotReplicas struct {
}

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

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

type validateOpListBotResourceGenerations struct {
}

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

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

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

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

type validateOpListBotVersions struct {
}

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

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

type validateOpListBuiltInIntents struct {
}

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

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

type validateOpListBuiltInSlotTypes struct {
}

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

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

type validateOpListCustomVocabularyItems struct {
}

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

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

type validateOpListExports struct {
}

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

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

type validateOpListImports struct {
}

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

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

type validateOpListIntentMetrics struct {
}

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

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

type validateOpListIntentPaths struct {
}

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

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

type validateOpListIntents struct {
}

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

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

type validateOpListIntentStageMetrics struct {
}

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

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

type validateOpListRecommendedIntents struct {
}

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

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

type validateOpListSessionAnalyticsData struct {
}

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

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

type validateOpListSessionMetrics struct {
}

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

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

type validateOpListSlots struct {
}

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

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

type validateOpListSlotTypes struct {
}

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

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

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

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

type validateOpListTestExecutions struct {
}

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

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

type validateOpListTestSetRecords struct {
}

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

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

type validateOpListTestSets struct {
}

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

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

type validateOpListUtteranceAnalyticsData struct {
}

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

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

type validateOpListUtteranceMetrics struct {
}

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

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

type validateOpSearchAssociatedTranscripts struct {
}

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

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

type validateOpStartBotRecommendation struct {
}

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

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

type validateOpStartBotResourceGeneration struct {
}

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

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

type validateOpStartImport struct {
}

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

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

type validateOpStartTestExecution struct {
}

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

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

type validateOpStartTestSetGeneration struct {
}

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

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

type validateOpStopBotRecommendation struct {
}

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

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

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

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

type validateOpUpdateBot struct {
}

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

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

type validateOpUpdateBotLocale struct {
}

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

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

type validateOpUpdateBotRecommendation struct {
}

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

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

type validateOpUpdateExport struct {
}

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

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

type validateOpUpdateIntent struct {
}

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

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

type validateOpUpdateResourcePolicy struct {
}

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

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

type validateOpUpdateSlot struct {
}

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

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

type validateOpUpdateSlotType struct {
}

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

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

type validateOpUpdateTestSet struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpStopBotRecommendationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStopBotRecommendation{}, 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 addOpUpdateBotAliasValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateBotAlias{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

func validateAggregatedUtterancesSortBy(v *types.AggregatedUtterancesSortBy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AggregatedUtterancesSortBy"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if len(v.Order) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Order"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAllowedInputTypes(v *types.AllowedInputTypes) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AllowedInputTypes"}
	if v.AllowAudioInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AllowAudioInput"))
	}
	if v.AllowDTMFInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AllowDTMFInput"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateAudioAndDTMFInputSpecification(v *types.AudioAndDTMFInputSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AudioAndDTMFInputSpecification"}
	if v.StartTimeoutMs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTimeoutMs"))
	}
	if v.AudioSpecification != nil {
		if err := validateAudioSpecification(v.AudioSpecification); err != nil {
			invalidParams.AddNested("AudioSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.DtmfSpecification != nil {
		if err := validateDTMFSpecification(v.DtmfSpecification); err != nil {
			invalidParams.AddNested("DtmfSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAudioLogDestination(v *types.AudioLogDestination) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AudioLogDestination"}
	if v.S3Bucket == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3Bucket"))
	} else if v.S3Bucket != nil {
		if err := validateS3BucketLogDestination(v.S3Bucket); err != nil {
			invalidParams.AddNested("S3Bucket", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAudioLogSetting(v *types.AudioLogSetting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AudioLogSetting"}
	if v.Destination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
	} else if v.Destination != nil {
		if err := validateAudioLogDestination(v.Destination); err != nil {
			invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateAudioSpecification(v *types.AudioSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AudioSpecification"}
	if v.MaxLengthMs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxLengthMs"))
	}
	if v.EndTimeoutMs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTimeoutMs"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBedrockGuardrailConfiguration(v *types.BedrockGuardrailConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BedrockGuardrailConfiguration"}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.Version == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Version"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateBedrockModelSpecification(v *types.BedrockModelSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BedrockModelSpecification"}
	if v.ModelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelArn"))
	}
	if v.Guardrail != nil {
		if err := validateBedrockGuardrailConfiguration(v.Guardrail); err != nil {
			invalidParams.AddNested("Guardrail", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBotAliasLocaleSettings(v *types.BotAliasLocaleSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BotAliasLocaleSettings"}
	if v.CodeHookSpecification != nil {
		if err := validateCodeHookSpecification(v.CodeHookSpecification); err != nil {
			invalidParams.AddNested("CodeHookSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateBotAliasTestExecutionTarget(v *types.BotAliasTestExecutionTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BotAliasTestExecutionTarget"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotAliasId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotAliasId"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBotExportSpecification(v *types.BotExportSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BotExportSpecification"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateBotImportSpecification(v *types.BotImportSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BotImportSpecification"}
	if v.BotName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotName"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.DataPrivacy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataPrivacy"))
	} else if v.DataPrivacy != nil {
		if err := validateDataPrivacy(v.DataPrivacy); err != nil {
			invalidParams.AddNested("DataPrivacy", err.(smithy.InvalidParamsError))
		}
	}
	if v.ErrorLogSettings != nil {
		if err := validateErrorLogSettings(v.ErrorLogSettings); err != nil {
			invalidParams.AddNested("ErrorLogSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBotLocaleExportSpecification(v *types.BotLocaleExportSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BotLocaleExportSpecification"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateBotLocaleImportSpecification(v *types.BotLocaleImportSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BotLocaleImportSpecification"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.VoiceSettings != nil {
		if err := validateVoiceSettings(v.VoiceSettings); err != nil {
			invalidParams.AddNested("VoiceSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBotLocaleSortBy(v *types.BotLocaleSortBy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BotLocaleSortBy"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if len(v.Order) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Order"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBotMember(v *types.BotMember) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BotMember"}
	if v.BotMemberId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotMemberId"))
	}
	if v.BotMemberName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotMemberName"))
	}
	if v.BotMemberAliasId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotMemberAliasId"))
	}
	if v.BotMemberAliasName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotMemberAliasName"))
	}
	if v.BotMemberVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotMemberVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateBotSortBy(v *types.BotSortBy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BotSortBy"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if len(v.Order) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Order"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateBotVersionReplicaSortBy(v *types.BotVersionReplicaSortBy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BotVersionReplicaSortBy"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if len(v.Order) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Order"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBotVersionSortBy(v *types.BotVersionSortBy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BotVersionSortBy"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if len(v.Order) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Order"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBuildtimeSettings(v *types.BuildtimeSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BuildtimeSettings"}
	if v.DescriptiveBotBuilder != nil {
		if err := validateDescriptiveBotBuilderSpecification(v.DescriptiveBotBuilder); err != nil {
			invalidParams.AddNested("DescriptiveBotBuilder", err.(smithy.InvalidParamsError))
		}
	}
	if v.SampleUtteranceGeneration != nil {
		if err := validateSampleUtteranceGenerationSpecification(v.SampleUtteranceGeneration); err != nil {
			invalidParams.AddNested("SampleUtteranceGeneration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBuiltInIntentSortBy(v *types.BuiltInIntentSortBy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BuiltInIntentSortBy"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if len(v.Order) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Order"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBuiltInSlotTypeSortBy(v *types.BuiltInSlotTypeSortBy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BuiltInSlotTypeSortBy"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if len(v.Order) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Order"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateCloudWatchLogGroupLogDestination(v *types.CloudWatchLogGroupLogDestination) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CloudWatchLogGroupLogDestination"}
	if v.CloudWatchLogGroupArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CloudWatchLogGroupArn"))
	}
	if v.LogPrefix == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LogPrefix"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCodeHookSpecification(v *types.CodeHookSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CodeHookSpecification"}
	if v.LambdaCodeHook == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LambdaCodeHook"))
	} else if v.LambdaCodeHook != nil {
		if err := validateLambdaCodeHook(v.LambdaCodeHook); err != nil {
			invalidParams.AddNested("LambdaCodeHook", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCompositeSlotTypeSetting(v *types.CompositeSlotTypeSetting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CompositeSlotTypeSetting"}
	if v.SubSlots != nil {
		if err := validateSubSlotTypeList(v.SubSlots); err != nil {
			invalidParams.AddNested("SubSlots", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateConditionalBranch(v *types.ConditionalBranch) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConditionalBranch"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Condition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Condition"))
	} else if v.Condition != nil {
		if err := validateCondition(v.Condition); err != nil {
			invalidParams.AddNested("Condition", err.(smithy.InvalidParamsError))
		}
	}
	if v.NextStep == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NextStep"))
	} else if v.NextStep != nil {
		if err := validateDialogState(v.NextStep); err != nil {
			invalidParams.AddNested("NextStep", err.(smithy.InvalidParamsError))
		}
	}
	if v.Response != nil {
		if err := validateResponseSpecification(v.Response); err != nil {
			invalidParams.AddNested("Response", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateConditionalSpecification(v *types.ConditionalSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConditionalSpecification"}
	if v.Active == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Active"))
	}
	if v.ConditionalBranches == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConditionalBranches"))
	} else if v.ConditionalBranches != nil {
		if err := validateConditionalBranches(v.ConditionalBranches); err != nil {
			invalidParams.AddNested("ConditionalBranches", err.(smithy.InvalidParamsError))
		}
	}
	if v.DefaultBranch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultBranch"))
	} else if v.DefaultBranch != nil {
		if err := validateDefaultConditionalBranch(v.DefaultBranch); err != nil {
			invalidParams.AddNested("DefaultBranch", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConversationLogsDataSource(v *types.ConversationLogsDataSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConversationLogsDataSource"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotAliasId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotAliasId"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.Filter == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Filter"))
	} else if v.Filter != nil {
		if err := validateConversationLogsDataSourceFilterBy(v.Filter); err != nil {
			invalidParams.AddNested("Filter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConversationLogsDataSourceFilterBy(v *types.ConversationLogsDataSourceFilterBy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConversationLogsDataSourceFilterBy"}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if len(v.InputMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InputMode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConversationLogSettings(v *types.ConversationLogSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConversationLogSettings"}
	if v.TextLogSettings != nil {
		if err := validateTextLogSettingsList(v.TextLogSettings); err != nil {
			invalidParams.AddNested("TextLogSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.AudioLogSettings != nil {
		if err := validateAudioLogSettingsList(v.AudioLogSettings); err != nil {
			invalidParams.AddNested("AudioLogSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateCustomVocabularyExportSpecification(v *types.CustomVocabularyExportSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomVocabularyExportSpecification"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomVocabularyImportSpecification(v *types.CustomVocabularyImportSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomVocabularyImportSpecification"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomVocabularyItem(v *types.CustomVocabularyItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomVocabularyItem"}
	if v.ItemId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ItemId"))
	}
	if v.Phrase == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Phrase"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDataSourceConfiguration(v *types.DataSourceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataSourceConfiguration"}
	if v.OpensearchConfiguration != nil {
		if err := validateOpensearchConfiguration(v.OpensearchConfiguration); err != nil {
			invalidParams.AddNested("OpensearchConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.KendraConfiguration != nil {
		if err := validateQnAKendraConfiguration(v.KendraConfiguration); err != nil {
			invalidParams.AddNested("KendraConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.BedrockKnowledgeStoreConfiguration != nil {
		if err := validateBedrockKnowledgeStoreConfiguration(v.BedrockKnowledgeStoreConfiguration); err != nil {
			invalidParams.AddNested("BedrockKnowledgeStoreConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDateRangeFilter(v *types.DateRangeFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DateRangeFilter"}
	if v.StartDateTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartDateTime"))
	}
	if v.EndDateTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndDateTime"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDefaultConditionalBranch(v *types.DefaultConditionalBranch) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DefaultConditionalBranch"}
	if v.NextStep != nil {
		if err := validateDialogState(v.NextStep); err != nil {
			invalidParams.AddNested("NextStep", err.(smithy.InvalidParamsError))
		}
	}
	if v.Response != nil {
		if err := validateResponseSpecification(v.Response); err != nil {
			invalidParams.AddNested("Response", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDescriptiveBotBuilderSpecification(v *types.DescriptiveBotBuilderSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescriptiveBotBuilderSpecification"}
	if v.BedrockModelSpecification != nil {
		if err := validateBedrockModelSpecification(v.BedrockModelSpecification); err != nil {
			invalidParams.AddNested("BedrockModelSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDialogCodeHookInvocationSetting(v *types.DialogCodeHookInvocationSetting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DialogCodeHookInvocationSetting"}
	if v.EnableCodeHookInvocation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnableCodeHookInvocation"))
	}
	if v.Active == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Active"))
	}
	if v.PostCodeHookSpecification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PostCodeHookSpecification"))
	} else if v.PostCodeHookSpecification != nil {
		if err := validatePostDialogCodeHookInvocationSpecification(v.PostCodeHookSpecification); err != nil {
			invalidParams.AddNested("PostCodeHookSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDialogState(v *types.DialogState) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DialogState"}
	if v.DialogAction != nil {
		if err := validateDialogAction(v.DialogAction); err != nil {
			invalidParams.AddNested("DialogAction", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDTMFSpecification(v *types.DTMFSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DTMFSpecification"}
	if v.MaxLength == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxLength"))
	}
	if v.EndTimeoutMs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTimeoutMs"))
	}
	if v.DeletionCharacter == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeletionCharacter"))
	}
	if v.EndCharacter == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndCharacter"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateExactResponseFields(v *types.ExactResponseFields) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExactResponseFields"}
	if v.QuestionField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QuestionField"))
	}
	if v.AnswerField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnswerField"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateExportResourceSpecification(v *types.ExportResourceSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExportResourceSpecification"}
	if v.BotExportSpecification != nil {
		if err := validateBotExportSpecification(v.BotExportSpecification); err != nil {
			invalidParams.AddNested("BotExportSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.BotLocaleExportSpecification != nil {
		if err := validateBotLocaleExportSpecification(v.BotLocaleExportSpecification); err != nil {
			invalidParams.AddNested("BotLocaleExportSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomVocabularyExportSpecification != nil {
		if err := validateCustomVocabularyExportSpecification(v.CustomVocabularyExportSpecification); err != nil {
			invalidParams.AddNested("CustomVocabularyExportSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.TestSetExportSpecification != nil {
		if err := validateTestSetExportSpecification(v.TestSetExportSpecification); err != nil {
			invalidParams.AddNested("TestSetExportSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateExportSortBy(v *types.ExportSortBy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExportSortBy"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if len(v.Order) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Order"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateExternalSourceSetting(v *types.ExternalSourceSetting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExternalSourceSetting"}
	if v.GrammarSlotTypeSetting != nil {
		if err := validateGrammarSlotTypeSetting(v.GrammarSlotTypeSetting); err != nil {
			invalidParams.AddNested("GrammarSlotTypeSetting", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFulfillmentCodeHookSettings(v *types.FulfillmentCodeHookSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FulfillmentCodeHookSettings"}
	if v.PostFulfillmentStatusSpecification != nil {
		if err := validatePostFulfillmentStatusSpecification(v.PostFulfillmentStatusSpecification); err != nil {
			invalidParams.AddNested("PostFulfillmentStatusSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.FulfillmentUpdatesSpecification != nil {
		if err := validateFulfillmentUpdatesSpecification(v.FulfillmentUpdatesSpecification); err != nil {
			invalidParams.AddNested("FulfillmentUpdatesSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFulfillmentStartResponseSpecification(v *types.FulfillmentStartResponseSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FulfillmentStartResponseSpecification"}
	if v.DelayInSeconds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DelayInSeconds"))
	}
	if v.MessageGroups == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageGroups"))
	} else if v.MessageGroups != nil {
		if err := validateMessageGroupsList(v.MessageGroups); err != nil {
			invalidParams.AddNested("MessageGroups", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFulfillmentUpdateResponseSpecification(v *types.FulfillmentUpdateResponseSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FulfillmentUpdateResponseSpecification"}
	if v.FrequencyInSeconds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FrequencyInSeconds"))
	}
	if v.MessageGroups == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageGroups"))
	} else if v.MessageGroups != nil {
		if err := validateMessageGroupsList(v.MessageGroups); err != nil {
			invalidParams.AddNested("MessageGroups", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFulfillmentUpdatesSpecification(v *types.FulfillmentUpdatesSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FulfillmentUpdatesSpecification"}
	if v.Active == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Active"))
	}
	if v.StartResponse != nil {
		if err := validateFulfillmentStartResponseSpecification(v.StartResponse); err != nil {
			invalidParams.AddNested("StartResponse", err.(smithy.InvalidParamsError))
		}
	}
	if v.UpdateResponse != nil {
		if err := validateFulfillmentUpdateResponseSpecification(v.UpdateResponse); err != nil {
			invalidParams.AddNested("UpdateResponse", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGenerationSortBy(v *types.GenerationSortBy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GenerationSortBy"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if len(v.Order) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Order"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGenerativeAISettings(v *types.GenerativeAISettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GenerativeAISettings"}
	if v.RuntimeSettings != nil {
		if err := validateRuntimeSettings(v.RuntimeSettings); err != nil {
			invalidParams.AddNested("RuntimeSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.BuildtimeSettings != nil {
		if err := validateBuildtimeSettings(v.BuildtimeSettings); err != nil {
			invalidParams.AddNested("BuildtimeSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGrammarSlotTypeSetting(v *types.GrammarSlotTypeSetting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GrammarSlotTypeSetting"}
	if v.Source != nil {
		if err := validateGrammarSlotTypeSource(v.Source); err != nil {
			invalidParams.AddNested("Source", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGrammarSlotTypeSource(v *types.GrammarSlotTypeSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GrammarSlotTypeSource"}
	if v.S3BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3BucketName"))
	}
	if v.S3ObjectKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3ObjectKey"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateImageResponseCard(v *types.ImageResponseCard) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImageResponseCard"}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.Buttons != nil {
		if err := validateButtonsList(v.Buttons); err != nil {
			invalidParams.AddNested("Buttons", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateImportResourceSpecification(v *types.ImportResourceSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportResourceSpecification"}
	if v.BotImportSpecification != nil {
		if err := validateBotImportSpecification(v.BotImportSpecification); err != nil {
			invalidParams.AddNested("BotImportSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.BotLocaleImportSpecification != nil {
		if err := validateBotLocaleImportSpecification(v.BotLocaleImportSpecification); err != nil {
			invalidParams.AddNested("BotLocaleImportSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomVocabularyImportSpecification != nil {
		if err := validateCustomVocabularyImportSpecification(v.CustomVocabularyImportSpecification); err != nil {
			invalidParams.AddNested("CustomVocabularyImportSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.TestSetImportResourceSpecification != nil {
		if err := validateTestSetImportResourceSpecification(v.TestSetImportResourceSpecification); err != nil {
			invalidParams.AddNested("TestSetImportResourceSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateImportSortBy(v *types.ImportSortBy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportSortBy"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if len(v.Order) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Order"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInitialResponseSetting(v *types.InitialResponseSetting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InitialResponseSetting"}
	if v.InitialResponse != nil {
		if err := validateResponseSpecification(v.InitialResponse); err != nil {
			invalidParams.AddNested("InitialResponse", err.(smithy.InvalidParamsError))
		}
	}
	if v.NextStep != nil {
		if err := validateDialogState(v.NextStep); err != nil {
			invalidParams.AddNested("NextStep", err.(smithy.InvalidParamsError))
		}
	}
	if v.Conditional != nil {
		if err := validateConditionalSpecification(v.Conditional); err != nil {
			invalidParams.AddNested("Conditional", err.(smithy.InvalidParamsError))
		}
	}
	if v.CodeHook != nil {
		if err := validateDialogCodeHookInvocationSetting(v.CodeHook); err != nil {
			invalidParams.AddNested("CodeHook", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateIntentClosingSetting(v *types.IntentClosingSetting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IntentClosingSetting"}
	if v.ClosingResponse != nil {
		if err := validateResponseSpecification(v.ClosingResponse); err != nil {
			invalidParams.AddNested("ClosingResponse", err.(smithy.InvalidParamsError))
		}
	}
	if v.NextStep != nil {
		if err := validateDialogState(v.NextStep); err != nil {
			invalidParams.AddNested("NextStep", err.(smithy.InvalidParamsError))
		}
	}
	if v.Conditional != nil {
		if err := validateConditionalSpecification(v.Conditional); err != nil {
			invalidParams.AddNested("Conditional", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateIntentConfirmationSetting(v *types.IntentConfirmationSetting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IntentConfirmationSetting"}
	if v.PromptSpecification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PromptSpecification"))
	} else if v.PromptSpecification != nil {
		if err := validatePromptSpecification(v.PromptSpecification); err != nil {
			invalidParams.AddNested("PromptSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.DeclinationResponse != nil {
		if err := validateResponseSpecification(v.DeclinationResponse); err != nil {
			invalidParams.AddNested("DeclinationResponse", err.(smithy.InvalidParamsError))
		}
	}
	if v.ConfirmationResponse != nil {
		if err := validateResponseSpecification(v.ConfirmationResponse); err != nil {
			invalidParams.AddNested("ConfirmationResponse", err.(smithy.InvalidParamsError))
		}
	}
	if v.ConfirmationNextStep != nil {
		if err := validateDialogState(v.ConfirmationNextStep); err != nil {
			invalidParams.AddNested("ConfirmationNextStep", err.(smithy.InvalidParamsError))
		}
	}
	if v.ConfirmationConditional != nil {
		if err := validateConditionalSpecification(v.ConfirmationConditional); err != nil {
			invalidParams.AddNested("ConfirmationConditional", err.(smithy.InvalidParamsError))
		}
	}
	if v.DeclinationNextStep != nil {
		if err := validateDialogState(v.DeclinationNextStep); err != nil {
			invalidParams.AddNested("DeclinationNextStep", err.(smithy.InvalidParamsError))
		}
	}
	if v.DeclinationConditional != nil {
		if err := validateConditionalSpecification(v.DeclinationConditional); err != nil {
			invalidParams.AddNested("DeclinationConditional", err.(smithy.InvalidParamsError))
		}
	}
	if v.FailureResponse != nil {
		if err := validateResponseSpecification(v.FailureResponse); err != nil {
			invalidParams.AddNested("FailureResponse", err.(smithy.InvalidParamsError))
		}
	}
	if v.FailureNextStep != nil {
		if err := validateDialogState(v.FailureNextStep); err != nil {
			invalidParams.AddNested("FailureNextStep", err.(smithy.InvalidParamsError))
		}
	}
	if v.FailureConditional != nil {
		if err := validateConditionalSpecification(v.FailureConditional); err != nil {
			invalidParams.AddNested("FailureConditional", err.(smithy.InvalidParamsError))
		}
	}
	if v.CodeHook != nil {
		if err := validateDialogCodeHookInvocationSetting(v.CodeHook); err != nil {
			invalidParams.AddNested("CodeHook", err.(smithy.InvalidParamsError))
		}
	}
	if v.ElicitationCodeHook != nil {
		if err := validateElicitationCodeHookInvocationSetting(v.ElicitationCodeHook); err != nil {
			invalidParams.AddNested("ElicitationCodeHook", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateIntentSortBy(v *types.IntentSortBy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IntentSortBy"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if len(v.Order) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Order"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateLambdaCodeHook(v *types.LambdaCodeHook) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LambdaCodeHook"}
	if v.LambdaARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LambdaARN"))
	}
	if v.CodeHookInterfaceVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CodeHookInterfaceVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLexTranscriptFilter(v *types.LexTranscriptFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LexTranscriptFilter"}
	if v.DateRangeFilter != nil {
		if err := validateDateRangeFilter(v.DateRangeFilter); err != nil {
			invalidParams.AddNested("DateRangeFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMessage(v *types.Message) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Message"}
	if v.PlainTextMessage != nil {
		if err := validatePlainTextMessage(v.PlainTextMessage); err != nil {
			invalidParams.AddNested("PlainTextMessage", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomPayload != nil {
		if err := validateCustomPayload(v.CustomPayload); err != nil {
			invalidParams.AddNested("CustomPayload", err.(smithy.InvalidParamsError))
		}
	}
	if v.SsmlMessage != nil {
		if err := validateSSMLMessage(v.SsmlMessage); err != nil {
			invalidParams.AddNested("SsmlMessage", err.(smithy.InvalidParamsError))
		}
	}
	if v.ImageResponseCard != nil {
		if err := validateImageResponseCard(v.ImageResponseCard); err != nil {
			invalidParams.AddNested("ImageResponseCard", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMessageGroup(v *types.MessageGroup) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MessageGroup"}
	if v.Message == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Message"))
	} else if v.Message != nil {
		if err := validateMessage(v.Message); err != nil {
			invalidParams.AddNested("Message", err.(smithy.InvalidParamsError))
		}
	}
	if v.Variations != nil {
		if err := validateMessageVariationsList(v.Variations); err != nil {
			invalidParams.AddNested("Variations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpensearchConfiguration(v *types.OpensearchConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OpensearchConfiguration"}
	if v.DomainEndpoint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainEndpoint"))
	}
	if v.IndexName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexName"))
	}
	if v.ExactResponseFields != nil {
		if err := validateExactResponseFields(v.ExactResponseFields); err != nil {
			invalidParams.AddNested("ExactResponseFields", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validatePostDialogCodeHookInvocationSpecification(v *types.PostDialogCodeHookInvocationSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PostDialogCodeHookInvocationSpecification"}
	if v.SuccessResponse != nil {
		if err := validateResponseSpecification(v.SuccessResponse); err != nil {
			invalidParams.AddNested("SuccessResponse", err.(smithy.InvalidParamsError))
		}
	}
	if v.SuccessNextStep != nil {
		if err := validateDialogState(v.SuccessNextStep); err != nil {
			invalidParams.AddNested("SuccessNextStep", err.(smithy.InvalidParamsError))
		}
	}
	if v.SuccessConditional != nil {
		if err := validateConditionalSpecification(v.SuccessConditional); err != nil {
			invalidParams.AddNested("SuccessConditional", err.(smithy.InvalidParamsError))
		}
	}
	if v.FailureResponse != nil {
		if err := validateResponseSpecification(v.FailureResponse); err != nil {
			invalidParams.AddNested("FailureResponse", err.(smithy.InvalidParamsError))
		}
	}
	if v.FailureNextStep != nil {
		if err := validateDialogState(v.FailureNextStep); err != nil {
			invalidParams.AddNested("FailureNextStep", err.(smithy.InvalidParamsError))
		}
	}
	if v.FailureConditional != nil {
		if err := validateConditionalSpecification(v.FailureConditional); err != nil {
			invalidParams.AddNested("FailureConditional", err.(smithy.InvalidParamsError))
		}
	}
	if v.TimeoutResponse != nil {
		if err := validateResponseSpecification(v.TimeoutResponse); err != nil {
			invalidParams.AddNested("TimeoutResponse", err.(smithy.InvalidParamsError))
		}
	}
	if v.TimeoutNextStep != nil {
		if err := validateDialogState(v.TimeoutNextStep); err != nil {
			invalidParams.AddNested("TimeoutNextStep", err.(smithy.InvalidParamsError))
		}
	}
	if v.TimeoutConditional != nil {
		if err := validateConditionalSpecification(v.TimeoutConditional); err != nil {
			invalidParams.AddNested("TimeoutConditional", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePostFulfillmentStatusSpecification(v *types.PostFulfillmentStatusSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PostFulfillmentStatusSpecification"}
	if v.SuccessResponse != nil {
		if err := validateResponseSpecification(v.SuccessResponse); err != nil {
			invalidParams.AddNested("SuccessResponse", err.(smithy.InvalidParamsError))
		}
	}
	if v.FailureResponse != nil {
		if err := validateResponseSpecification(v.FailureResponse); err != nil {
			invalidParams.AddNested("FailureResponse", err.(smithy.InvalidParamsError))
		}
	}
	if v.TimeoutResponse != nil {
		if err := validateResponseSpecification(v.TimeoutResponse); err != nil {
			invalidParams.AddNested("TimeoutResponse", err.(smithy.InvalidParamsError))
		}
	}
	if v.SuccessNextStep != nil {
		if err := validateDialogState(v.SuccessNextStep); err != nil {
			invalidParams.AddNested("SuccessNextStep", err.(smithy.InvalidParamsError))
		}
	}
	if v.SuccessConditional != nil {
		if err := validateConditionalSpecification(v.SuccessConditional); err != nil {
			invalidParams.AddNested("SuccessConditional", err.(smithy.InvalidParamsError))
		}
	}
	if v.FailureNextStep != nil {
		if err := validateDialogState(v.FailureNextStep); err != nil {
			invalidParams.AddNested("FailureNextStep", err.(smithy.InvalidParamsError))
		}
	}
	if v.FailureConditional != nil {
		if err := validateConditionalSpecification(v.FailureConditional); err != nil {
			invalidParams.AddNested("FailureConditional", err.(smithy.InvalidParamsError))
		}
	}
	if v.TimeoutNextStep != nil {
		if err := validateDialogState(v.TimeoutNextStep); err != nil {
			invalidParams.AddNested("TimeoutNextStep", err.(smithy.InvalidParamsError))
		}
	}
	if v.TimeoutConditional != nil {
		if err := validateConditionalSpecification(v.TimeoutConditional); err != nil {
			invalidParams.AddNested("TimeoutConditional", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePromptAttemptSpecification(v *types.PromptAttemptSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PromptAttemptSpecification"}
	if v.AllowedInputTypes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AllowedInputTypes"))
	} else if v.AllowedInputTypes != nil {
		if err := validateAllowedInputTypes(v.AllowedInputTypes); err != nil {
			invalidParams.AddNested("AllowedInputTypes", err.(smithy.InvalidParamsError))
		}
	}
	if v.AudioAndDTMFInputSpecification != nil {
		if err := validateAudioAndDTMFInputSpecification(v.AudioAndDTMFInputSpecification); err != nil {
			invalidParams.AddNested("AudioAndDTMFInputSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.TextInputSpecification != nil {
		if err := validateTextInputSpecification(v.TextInputSpecification); err != nil {
			invalidParams.AddNested("TextInputSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validatePromptSpecification(v *types.PromptSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PromptSpecification"}
	if v.MessageGroups == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageGroups"))
	} else if v.MessageGroups != nil {
		if err := validateMessageGroupsList(v.MessageGroups); err != nil {
			invalidParams.AddNested("MessageGroups", err.(smithy.InvalidParamsError))
		}
	}
	if v.MaxRetries == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxRetries"))
	}
	if v.PromptAttemptsSpecification != nil {
		if err := validatePromptAttemptsSpecificationMap(v.PromptAttemptsSpecification); err != nil {
			invalidParams.AddNested("PromptAttemptsSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateQInConnectIntentConfiguration(v *types.QInConnectIntentConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QInConnectIntentConfiguration"}
	if v.QInConnectAssistantConfiguration != nil {
		if err := validateQInConnectAssistantConfiguration(v.QInConnectAssistantConfiguration); err != nil {
			invalidParams.AddNested("QInConnectAssistantConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateQnAIntentConfiguration(v *types.QnAIntentConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QnAIntentConfiguration"}
	if v.DataSourceConfiguration != nil {
		if err := validateDataSourceConfiguration(v.DataSourceConfiguration); err != nil {
			invalidParams.AddNested("DataSourceConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.BedrockModelConfiguration != nil {
		if err := validateBedrockModelSpecification(v.BedrockModelConfiguration); err != nil {
			invalidParams.AddNested("BedrockModelConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRelativeAggregationDuration(v *types.RelativeAggregationDuration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RelativeAggregationDuration"}
	if len(v.TimeDimension) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TimeDimension"))
	}
	if v.TimeValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimeValue"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResponseSpecification(v *types.ResponseSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResponseSpecification"}
	if v.MessageGroups == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageGroups"))
	} else if v.MessageGroups != nil {
		if err := validateMessageGroupsList(v.MessageGroups); err != nil {
			invalidParams.AddNested("MessageGroups", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRuntimeSettings(v *types.RuntimeSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RuntimeSettings"}
	if v.SlotResolutionImprovement != nil {
		if err := validateSlotResolutionImprovementSpecification(v.SlotResolutionImprovement); err != nil {
			invalidParams.AddNested("SlotResolutionImprovement", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3BucketLogDestination(v *types.S3BucketLogDestination) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3BucketLogDestination"}
	if v.S3BucketArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3BucketArn"))
	}
	if v.LogPrefix == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LogPrefix"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3BucketTranscriptSource(v *types.S3BucketTranscriptSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3BucketTranscriptSource"}
	if v.S3BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3BucketName"))
	}
	if len(v.TranscriptFormat) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TranscriptFormat"))
	}
	if v.TranscriptFilter != nil {
		if err := validateTranscriptFilter(v.TranscriptFilter); err != nil {
			invalidParams.AddNested("TranscriptFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSampleUtteranceGenerationSpecification(v *types.SampleUtteranceGenerationSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SampleUtteranceGenerationSpecification"}
	if v.BedrockModelSpecification != nil {
		if err := validateBedrockModelSpecification(v.BedrockModelSpecification); err != nil {
			invalidParams.AddNested("BedrockModelSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateSlotCaptureSetting(v *types.SlotCaptureSetting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SlotCaptureSetting"}
	if v.CaptureResponse != nil {
		if err := validateResponseSpecification(v.CaptureResponse); err != nil {
			invalidParams.AddNested("CaptureResponse", err.(smithy.InvalidParamsError))
		}
	}
	if v.CaptureNextStep != nil {
		if err := validateDialogState(v.CaptureNextStep); err != nil {
			invalidParams.AddNested("CaptureNextStep", err.(smithy.InvalidParamsError))
		}
	}
	if v.CaptureConditional != nil {
		if err := validateConditionalSpecification(v.CaptureConditional); err != nil {
			invalidParams.AddNested("CaptureConditional", err.(smithy.InvalidParamsError))
		}
	}
	if v.FailureResponse != nil {
		if err := validateResponseSpecification(v.FailureResponse); err != nil {
			invalidParams.AddNested("FailureResponse", err.(smithy.InvalidParamsError))
		}
	}
	if v.FailureNextStep != nil {
		if err := validateDialogState(v.FailureNextStep); err != nil {
			invalidParams.AddNested("FailureNextStep", err.(smithy.InvalidParamsError))
		}
	}
	if v.FailureConditional != nil {
		if err := validateConditionalSpecification(v.FailureConditional); err != nil {
			invalidParams.AddNested("FailureConditional", err.(smithy.InvalidParamsError))
		}
	}
	if v.CodeHook != nil {
		if err := validateDialogCodeHookInvocationSetting(v.CodeHook); err != nil {
			invalidParams.AddNested("CodeHook", err.(smithy.InvalidParamsError))
		}
	}
	if v.ElicitationCodeHook != nil {
		if err := validateElicitationCodeHookInvocationSetting(v.ElicitationCodeHook); err != nil {
			invalidParams.AddNested("ElicitationCodeHook", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateSlotDefaultValueSpecification(v *types.SlotDefaultValueSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SlotDefaultValueSpecification"}
	if v.DefaultValueList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultValueList"))
	} else if v.DefaultValueList != nil {
		if err := validateSlotDefaultValueList(v.DefaultValueList); err != nil {
			invalidParams.AddNested("DefaultValueList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateSlotResolutionImprovementSpecification(v *types.SlotResolutionImprovementSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SlotResolutionImprovementSpecification"}
	if v.BedrockModelSpecification != nil {
		if err := validateBedrockModelSpecification(v.BedrockModelSpecification); err != nil {
			invalidParams.AddNested("BedrockModelSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSlotSortBy(v *types.SlotSortBy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SlotSortBy"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if len(v.Order) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Order"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateSlotTypeSortBy(v *types.SlotTypeSortBy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SlotTypeSortBy"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if len(v.Order) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Order"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSlotTypeValue(v *types.SlotTypeValue) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SlotTypeValue"}
	if v.SampleValue != nil {
		if err := validateSampleValue(v.SampleValue); err != nil {
			invalidParams.AddNested("SampleValue", err.(smithy.InvalidParamsError))
		}
	}
	if v.Synonyms != nil {
		if err := validateSynonymList(v.Synonyms); err != nil {
			invalidParams.AddNested("Synonyms", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSlotValueElicitationSetting(v *types.SlotValueElicitationSetting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SlotValueElicitationSetting"}
	if v.DefaultValueSpecification != nil {
		if err := validateSlotDefaultValueSpecification(v.DefaultValueSpecification); err != nil {
			invalidParams.AddNested("DefaultValueSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.SlotConstraint) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SlotConstraint"))
	}
	if v.PromptSpecification != nil {
		if err := validatePromptSpecification(v.PromptSpecification); err != nil {
			invalidParams.AddNested("PromptSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.SampleUtterances != nil {
		if err := validateSampleUtterancesList(v.SampleUtterances); err != nil {
			invalidParams.AddNested("SampleUtterances", err.(smithy.InvalidParamsError))
		}
	}
	if v.WaitAndContinueSpecification != nil {
		if err := validateWaitAndContinueSpecification(v.WaitAndContinueSpecification); err != nil {
			invalidParams.AddNested("WaitAndContinueSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.SlotCaptureSetting != nil {
		if err := validateSlotCaptureSetting(v.SlotCaptureSetting); err != nil {
			invalidParams.AddNested("SlotCaptureSetting", err.(smithy.InvalidParamsError))
		}
	}
	if v.SlotResolutionSetting != nil {
		if err := validateSlotResolutionSetting(v.SlotResolutionSetting); err != nil {
			invalidParams.AddNested("SlotResolutionSetting", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSlotValueSelectionSetting(v *types.SlotValueSelectionSetting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SlotValueSelectionSetting"}
	if len(v.ResolutionStrategy) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResolutionStrategy"))
	}
	if v.RegexFilter != nil {
		if err := validateSlotValueRegexFilter(v.RegexFilter); err != nil {
			invalidParams.AddNested("RegexFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSpecifications(v *types.Specifications) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Specifications"}
	if v.SlotTypeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SlotTypeId"))
	}
	if v.ValueElicitationSetting == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ValueElicitationSetting"))
	} else if v.ValueElicitationSetting != nil {
		if err := validateSubSlotValueElicitationSetting(v.ValueElicitationSetting); err != nil {
			invalidParams.AddNested("ValueElicitationSetting", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateStillWaitingResponseSpecification(v *types.StillWaitingResponseSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StillWaitingResponseSpecification"}
	if v.MessageGroups == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageGroups"))
	} else if v.MessageGroups != nil {
		if err := validateMessageGroupsList(v.MessageGroups); err != nil {
			invalidParams.AddNested("MessageGroups", err.(smithy.InvalidParamsError))
		}
	}
	if v.FrequencyInSeconds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FrequencyInSeconds"))
	}
	if v.TimeoutInSeconds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimeoutInSeconds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSubSlotSetting(v *types.SubSlotSetting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SubSlotSetting"}
	if v.SlotSpecifications != nil {
		if err := validateSubSlotSpecificationMap(v.SlotSpecifications); err != nil {
			invalidParams.AddNested("SlotSpecifications", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateSubSlotValueElicitationSetting(v *types.SubSlotValueElicitationSetting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SubSlotValueElicitationSetting"}
	if v.DefaultValueSpecification != nil {
		if err := validateSlotDefaultValueSpecification(v.DefaultValueSpecification); err != nil {
			invalidParams.AddNested("DefaultValueSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.PromptSpecification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PromptSpecification"))
	} else if v.PromptSpecification != nil {
		if err := validatePromptSpecification(v.PromptSpecification); err != nil {
			invalidParams.AddNested("PromptSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.SampleUtterances != nil {
		if err := validateSampleUtterancesList(v.SampleUtterances); err != nil {
			invalidParams.AddNested("SampleUtterances", err.(smithy.InvalidParamsError))
		}
	}
	if v.WaitAndContinueSpecification != nil {
		if err := validateWaitAndContinueSpecification(v.WaitAndContinueSpecification); err != nil {
			invalidParams.AddNested("WaitAndContinueSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateTestExecutionSortBy(v *types.TestExecutionSortBy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestExecutionSortBy"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if len(v.Order) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Order"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTestExecutionTarget(v *types.TestExecutionTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestExecutionTarget"}
	if v.BotAliasTarget != nil {
		if err := validateBotAliasTestExecutionTarget(v.BotAliasTarget); err != nil {
			invalidParams.AddNested("BotAliasTarget", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTestSetDiscrepancyReportBotAliasTarget(v *types.TestSetDiscrepancyReportBotAliasTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestSetDiscrepancyReportBotAliasTarget"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotAliasId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotAliasId"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTestSetDiscrepancyReportResourceTarget(v *types.TestSetDiscrepancyReportResourceTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestSetDiscrepancyReportResourceTarget"}
	if v.BotAliasTarget != nil {
		if err := validateTestSetDiscrepancyReportBotAliasTarget(v.BotAliasTarget); err != nil {
			invalidParams.AddNested("BotAliasTarget", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTestSetGenerationDataSource(v *types.TestSetGenerationDataSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestSetGenerationDataSource"}
	if v.ConversationLogsDataSource != nil {
		if err := validateConversationLogsDataSource(v.ConversationLogsDataSource); err != nil {
			invalidParams.AddNested("ConversationLogsDataSource", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTestSetImportInputLocation(v *types.TestSetImportInputLocation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestSetImportInputLocation"}
	if v.S3BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3BucketName"))
	}
	if v.S3Path == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3Path"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTestSetImportResourceSpecification(v *types.TestSetImportResourceSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestSetImportResourceSpecification"}
	if v.TestSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TestSetName"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.StorageLocation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StorageLocation"))
	} else if v.StorageLocation != nil {
		if err := validateTestSetStorageLocation(v.StorageLocation); err != nil {
			invalidParams.AddNested("StorageLocation", err.(smithy.InvalidParamsError))
		}
	}
	if v.ImportInputLocation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImportInputLocation"))
	} else if v.ImportInputLocation != nil {
		if err := validateTestSetImportInputLocation(v.ImportInputLocation); err != nil {
			invalidParams.AddNested("ImportInputLocation", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.Modality) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Modality"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTestSetSortBy(v *types.TestSetSortBy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestSetSortBy"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if len(v.Order) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Order"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTestSetStorageLocation(v *types.TestSetStorageLocation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestSetStorageLocation"}
	if v.S3BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3BucketName"))
	}
	if v.S3Path == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3Path"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTextLogDestination(v *types.TextLogDestination) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TextLogDestination"}
	if v.CloudWatch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CloudWatch"))
	} else if v.CloudWatch != nil {
		if err := validateCloudWatchLogGroupLogDestination(v.CloudWatch); err != nil {
			invalidParams.AddNested("CloudWatch", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTextLogSetting(v *types.TextLogSetting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TextLogSetting"}
	if v.Destination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
	} else if v.Destination != nil {
		if err := validateTextLogDestination(v.Destination); err != nil {
			invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTextLogSettingsList(v []types.TextLogSetting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TextLogSettingsList"}
	for i := range v {
		if err := validateTextLogSetting(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	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 v.LexTranscriptFilter != nil {
		if err := validateLexTranscriptFilter(v.LexTranscriptFilter); err != nil {
			invalidParams.AddNested("LexTranscriptFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTranscriptSourceSetting(v *types.TranscriptSourceSetting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TranscriptSourceSetting"}
	if v.S3BucketTranscriptSource != nil {
		if err := validateS3BucketTranscriptSource(v.S3BucketTranscriptSource); err != nil {
			invalidParams.AddNested("S3BucketTranscriptSource", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateUtteranceAggregationDuration(v *types.UtteranceAggregationDuration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UtteranceAggregationDuration"}
	if v.RelativeAggregationDuration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RelativeAggregationDuration"))
	} else if v.RelativeAggregationDuration != nil {
		if err := validateRelativeAggregationDuration(v.RelativeAggregationDuration); err != nil {
			invalidParams.AddNested("RelativeAggregationDuration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateWaitAndContinueSpecification(v *types.WaitAndContinueSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WaitAndContinueSpecification"}
	if v.WaitingResponse == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WaitingResponse"))
	} else if v.WaitingResponse != nil {
		if err := validateResponseSpecification(v.WaitingResponse); err != nil {
			invalidParams.AddNested("WaitingResponse", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContinueResponse == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContinueResponse"))
	} else if v.ContinueResponse != nil {
		if err := validateResponseSpecification(v.ContinueResponse); err != nil {
			invalidParams.AddNested("ContinueResponse", err.(smithy.InvalidParamsError))
		}
	}
	if v.StillWaitingResponse != nil {
		if err := validateStillWaitingResponseSpecification(v.StillWaitingResponse); err != nil {
			invalidParams.AddNested("StillWaitingResponse", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchCreateCustomVocabularyItemInput(v *BatchCreateCustomVocabularyItemInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchCreateCustomVocabularyItemInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.CustomVocabularyItemList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CustomVocabularyItemList"))
	} else if v.CustomVocabularyItemList != nil {
		if err := validateCreateCustomVocabularyItemsList(v.CustomVocabularyItemList); err != nil {
			invalidParams.AddNested("CustomVocabularyItemList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchDeleteCustomVocabularyItemInput(v *BatchDeleteCustomVocabularyItemInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteCustomVocabularyItemInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.CustomVocabularyItemList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CustomVocabularyItemList"))
	} else if v.CustomVocabularyItemList != nil {
		if err := validateDeleteCustomVocabularyItemsList(v.CustomVocabularyItemList); err != nil {
			invalidParams.AddNested("CustomVocabularyItemList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchUpdateCustomVocabularyItemInput(v *BatchUpdateCustomVocabularyItemInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchUpdateCustomVocabularyItemInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.CustomVocabularyItemList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CustomVocabularyItemList"))
	} else if v.CustomVocabularyItemList != nil {
		if err := validateUpdateCustomVocabularyItemsList(v.CustomVocabularyItemList); err != nil {
			invalidParams.AddNested("CustomVocabularyItemList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBuildBotLocaleInput(v *BuildBotLocaleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BuildBotLocaleInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateBotAliasInput(v *CreateBotAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateBotAliasInput"}
	if v.BotAliasName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotAliasName"))
	}
	if v.BotAliasLocaleSettings != nil {
		if err := validateBotAliasLocaleSettingsMap(v.BotAliasLocaleSettings); err != nil {
			invalidParams.AddNested("BotAliasLocaleSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.ConversationLogSettings != nil {
		if err := validateConversationLogSettings(v.ConversationLogSettings); err != nil {
			invalidParams.AddNested("ConversationLogSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.SentimentAnalysisSettings != nil {
		if err := validateSentimentAnalysisSettings(v.SentimentAnalysisSettings); err != nil {
			invalidParams.AddNested("SentimentAnalysisSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateBotInput(v *CreateBotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateBotInput"}
	if v.BotName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotName"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.DataPrivacy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataPrivacy"))
	} else if v.DataPrivacy != nil {
		if err := validateDataPrivacy(v.DataPrivacy); err != nil {
			invalidParams.AddNested("DataPrivacy", err.(smithy.InvalidParamsError))
		}
	}
	if v.IdleSessionTTLInSeconds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdleSessionTTLInSeconds"))
	}
	if v.BotMembers != nil {
		if err := validateBotMembers(v.BotMembers); err != nil {
			invalidParams.AddNested("BotMembers", err.(smithy.InvalidParamsError))
		}
	}
	if v.ErrorLogSettings != nil {
		if err := validateErrorLogSettings(v.ErrorLogSettings); err != nil {
			invalidParams.AddNested("ErrorLogSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateBotLocaleInput(v *CreateBotLocaleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateBotLocaleInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.NluIntentConfidenceThreshold == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NluIntentConfidenceThreshold"))
	}
	if v.VoiceSettings != nil {
		if err := validateVoiceSettings(v.VoiceSettings); err != nil {
			invalidParams.AddNested("VoiceSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.GenerativeAISettings != nil {
		if err := validateGenerativeAISettings(v.GenerativeAISettings); err != nil {
			invalidParams.AddNested("GenerativeAISettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateBotVersionInput(v *CreateBotVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateBotVersionInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersionLocaleSpecification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersionLocaleSpecification"))
	} else if v.BotVersionLocaleSpecification != nil {
		if err := validateBotVersionLocaleSpecification(v.BotVersionLocaleSpecification); err != nil {
			invalidParams.AddNested("BotVersionLocaleSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateExportInput(v *CreateExportInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateExportInput"}
	if v.ResourceSpecification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceSpecification"))
	} else if v.ResourceSpecification != nil {
		if err := validateExportResourceSpecification(v.ResourceSpecification); err != nil {
			invalidParams.AddNested("ResourceSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.FileFormat) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("FileFormat"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateIntentInput(v *CreateIntentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateIntentInput"}
	if v.IntentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntentName"))
	}
	if v.SampleUtterances != nil {
		if err := validateSampleUtterancesList(v.SampleUtterances); err != nil {
			invalidParams.AddNested("SampleUtterances", err.(smithy.InvalidParamsError))
		}
	}
	if v.DialogCodeHook != nil {
		if err := validateDialogCodeHookSettings(v.DialogCodeHook); err != nil {
			invalidParams.AddNested("DialogCodeHook", err.(smithy.InvalidParamsError))
		}
	}
	if v.FulfillmentCodeHook != nil {
		if err := validateFulfillmentCodeHookSettings(v.FulfillmentCodeHook); err != nil {
			invalidParams.AddNested("FulfillmentCodeHook", err.(smithy.InvalidParamsError))
		}
	}
	if v.IntentConfirmationSetting != nil {
		if err := validateIntentConfirmationSetting(v.IntentConfirmationSetting); err != nil {
			invalidParams.AddNested("IntentConfirmationSetting", err.(smithy.InvalidParamsError))
		}
	}
	if v.IntentClosingSetting != nil {
		if err := validateIntentClosingSetting(v.IntentClosingSetting); err != nil {
			invalidParams.AddNested("IntentClosingSetting", err.(smithy.InvalidParamsError))
		}
	}
	if v.InputContexts != nil {
		if err := validateInputContextsList(v.InputContexts); err != nil {
			invalidParams.AddNested("InputContexts", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputContexts != nil {
		if err := validateOutputContextsList(v.OutputContexts); err != nil {
			invalidParams.AddNested("OutputContexts", err.(smithy.InvalidParamsError))
		}
	}
	if v.KendraConfiguration != nil {
		if err := validateKendraConfiguration(v.KendraConfiguration); err != nil {
			invalidParams.AddNested("KendraConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.InitialResponseSetting != nil {
		if err := validateInitialResponseSetting(v.InitialResponseSetting); err != nil {
			invalidParams.AddNested("InitialResponseSetting", err.(smithy.InvalidParamsError))
		}
	}
	if v.QnAIntentConfiguration != nil {
		if err := validateQnAIntentConfiguration(v.QnAIntentConfiguration); err != nil {
			invalidParams.AddNested("QnAIntentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.QInConnectIntentConfiguration != nil {
		if err := validateQInConnectIntentConfiguration(v.QInConnectIntentConfiguration); err != nil {
			invalidParams.AddNested("QInConnectIntentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateResourcePolicyStatementInput(v *CreateResourcePolicyStatementInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateResourcePolicyStatementInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if v.StatementId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StatementId"))
	}
	if len(v.Effect) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Effect"))
	}
	if v.Principal == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Principal"))
	}
	if v.Action == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSlotInput(v *CreateSlotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSlotInput"}
	if v.SlotName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SlotName"))
	}
	if v.ValueElicitationSetting == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ValueElicitationSetting"))
	} else if v.ValueElicitationSetting != nil {
		if err := validateSlotValueElicitationSetting(v.ValueElicitationSetting); err != nil {
			invalidParams.AddNested("ValueElicitationSetting", err.(smithy.InvalidParamsError))
		}
	}
	if v.ObfuscationSetting != nil {
		if err := validateObfuscationSetting(v.ObfuscationSetting); err != nil {
			invalidParams.AddNested("ObfuscationSetting", err.(smithy.InvalidParamsError))
		}
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.IntentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntentId"))
	}
	if v.SubSlotSetting != nil {
		if err := validateSubSlotSetting(v.SubSlotSetting); err != nil {
			invalidParams.AddNested("SubSlotSetting", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSlotTypeInput(v *CreateSlotTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSlotTypeInput"}
	if v.SlotTypeName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SlotTypeName"))
	}
	if v.SlotTypeValues != nil {
		if err := validateSlotTypeValues(v.SlotTypeValues); err != nil {
			invalidParams.AddNested("SlotTypeValues", err.(smithy.InvalidParamsError))
		}
	}
	if v.ValueSelectionSetting != nil {
		if err := validateSlotValueSelectionSetting(v.ValueSelectionSetting); err != nil {
			invalidParams.AddNested("ValueSelectionSetting", err.(smithy.InvalidParamsError))
		}
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.ExternalSourceSetting != nil {
		if err := validateExternalSourceSetting(v.ExternalSourceSetting); err != nil {
			invalidParams.AddNested("ExternalSourceSetting", err.(smithy.InvalidParamsError))
		}
	}
	if v.CompositeSlotTypeSetting != nil {
		if err := validateCompositeSlotTypeSetting(v.CompositeSlotTypeSetting); err != nil {
			invalidParams.AddNested("CompositeSlotTypeSetting", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTestSetDiscrepancyReportInput(v *CreateTestSetDiscrepancyReportInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTestSetDiscrepancyReportInput"}
	if v.TestSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TestSetId"))
	}
	if v.Target == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Target"))
	} else if v.Target != nil {
		if err := validateTestSetDiscrepancyReportResourceTarget(v.Target); err != nil {
			invalidParams.AddNested("Target", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteBotLocaleInput(v *DeleteBotLocaleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteBotLocaleInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteCustomVocabularyInput(v *DeleteCustomVocabularyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteCustomVocabularyInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteIntentInput(v *DeleteIntentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIntentInput"}
	if v.IntentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntentId"))
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteSlotInput(v *DeleteSlotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteSlotInput"}
	if v.SlotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SlotId"))
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.IntentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteSlotTypeInput(v *DeleteSlotTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteSlotTypeInput"}
	if v.SlotTypeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SlotTypeId"))
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpDescribeBotLocaleInput(v *DescribeBotLocaleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeBotLocaleInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeBotRecommendationInput(v *DescribeBotRecommendationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeBotRecommendationInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.BotRecommendationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotRecommendationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDescribeBotResourceGenerationInput(v *DescribeBotResourceGenerationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeBotResourceGenerationInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.GenerationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GenerationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDescribeCustomVocabularyMetadataInput(v *DescribeCustomVocabularyMetadataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeCustomVocabularyMetadataInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDescribeIntentInput(v *DescribeIntentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeIntentInput"}
	if v.IntentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntentId"))
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDescribeSlotInput(v *DescribeSlotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeSlotInput"}
	if v.SlotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SlotId"))
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.IntentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeSlotTypeInput(v *DescribeSlotTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeSlotTypeInput"}
	if v.SlotTypeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SlotTypeId"))
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpGenerateBotElementInput(v *GenerateBotElementInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GenerateBotElementInput"}
	if v.IntentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntentId"))
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListAggregatedUtterancesInput(v *ListAggregatedUtterancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAggregatedUtterancesInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.AggregationDuration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AggregationDuration"))
	} else if v.AggregationDuration != nil {
		if err := validateUtteranceAggregationDuration(v.AggregationDuration); err != nil {
			invalidParams.AddNested("AggregationDuration", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortBy != nil {
		if err := validateAggregatedUtterancesSortBy(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filters != nil {
		if err := validateAggregatedUtterancesFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListBotLocalesInput(v *ListBotLocalesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListBotLocalesInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.SortBy != nil {
		if err := validateBotLocaleSortBy(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filters != nil {
		if err := validateBotLocaleFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListBotRecommendationsInput(v *ListBotRecommendationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListBotRecommendationsInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListBotResourceGenerationsInput(v *ListBotResourceGenerationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListBotResourceGenerationsInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.SortBy != nil {
		if err := validateGenerationSortBy(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	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.SortBy != nil {
		if err := validateBotSortBy(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filters != nil {
		if err := validateBotFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListBotVersionReplicasInput(v *ListBotVersionReplicasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListBotVersionReplicasInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.ReplicaRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicaRegion"))
	}
	if v.SortBy != nil {
		if err := validateBotVersionReplicaSortBy(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListBotVersionsInput(v *ListBotVersionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListBotVersionsInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.SortBy != nil {
		if err := validateBotVersionSortBy(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListBuiltInIntentsInput(v *ListBuiltInIntentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListBuiltInIntentsInput"}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.SortBy != nil {
		if err := validateBuiltInIntentSortBy(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListBuiltInSlotTypesInput(v *ListBuiltInSlotTypesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListBuiltInSlotTypesInput"}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.SortBy != nil {
		if err := validateBuiltInSlotTypeSortBy(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListCustomVocabularyItemsInput(v *ListCustomVocabularyItemsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListCustomVocabularyItemsInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListExportsInput(v *ListExportsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListExportsInput"}
	if v.SortBy != nil {
		if err := validateExportSortBy(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filters != nil {
		if err := validateExportFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListImportsInput(v *ListImportsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListImportsInput"}
	if v.SortBy != nil {
		if err := validateImportSortBy(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filters != nil {
		if err := validateImportFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListIntentMetricsInput(v *ListIntentMetricsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListIntentMetricsInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.StartDateTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartDateTime"))
	}
	if v.EndDateTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndDateTime"))
	}
	if v.Metrics == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Metrics"))
	} else if v.Metrics != nil {
		if err := validateAnalyticsIntentMetrics(v.Metrics); err != nil {
			invalidParams.AddNested("Metrics", err.(smithy.InvalidParamsError))
		}
	}
	if v.BinBy != nil {
		if err := validateAnalyticsBinByList(v.BinBy); err != nil {
			invalidParams.AddNested("BinBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.GroupBy != nil {
		if err := validateAnalyticsIntentGroupByList(v.GroupBy); err != nil {
			invalidParams.AddNested("GroupBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filters != nil {
		if err := validateAnalyticsIntentFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListIntentPathsInput(v *ListIntentPathsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListIntentPathsInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.StartDateTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartDateTime"))
	}
	if v.EndDateTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndDateTime"))
	}
	if v.IntentPath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntentPath"))
	}
	if v.Filters != nil {
		if err := validateAnalyticsPathFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListIntentsInput(v *ListIntentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListIntentsInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.SortBy != nil {
		if err := validateIntentSortBy(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filters != nil {
		if err := validateIntentFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListIntentStageMetricsInput(v *ListIntentStageMetricsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListIntentStageMetricsInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.StartDateTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartDateTime"))
	}
	if v.EndDateTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndDateTime"))
	}
	if v.Metrics == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Metrics"))
	} else if v.Metrics != nil {
		if err := validateAnalyticsIntentStageMetrics(v.Metrics); err != nil {
			invalidParams.AddNested("Metrics", err.(smithy.InvalidParamsError))
		}
	}
	if v.BinBy != nil {
		if err := validateAnalyticsBinByList(v.BinBy); err != nil {
			invalidParams.AddNested("BinBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.GroupBy != nil {
		if err := validateAnalyticsIntentStageGroupByList(v.GroupBy); err != nil {
			invalidParams.AddNested("GroupBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filters != nil {
		if err := validateAnalyticsIntentStageFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListRecommendedIntentsInput(v *ListRecommendedIntentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListRecommendedIntentsInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.BotRecommendationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotRecommendationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListSessionAnalyticsDataInput(v *ListSessionAnalyticsDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListSessionAnalyticsDataInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.StartDateTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartDateTime"))
	}
	if v.EndDateTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndDateTime"))
	}
	if v.SortBy != nil {
		if err := validateSessionDataSortBy(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filters != nil {
		if err := validateAnalyticsSessionFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListSessionMetricsInput(v *ListSessionMetricsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListSessionMetricsInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.StartDateTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartDateTime"))
	}
	if v.EndDateTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndDateTime"))
	}
	if v.Metrics == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Metrics"))
	} else if v.Metrics != nil {
		if err := validateAnalyticsSessionMetrics(v.Metrics); err != nil {
			invalidParams.AddNested("Metrics", err.(smithy.InvalidParamsError))
		}
	}
	if v.BinBy != nil {
		if err := validateAnalyticsBinByList(v.BinBy); err != nil {
			invalidParams.AddNested("BinBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.GroupBy != nil {
		if err := validateAnalyticsSessionGroupByList(v.GroupBy); err != nil {
			invalidParams.AddNested("GroupBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filters != nil {
		if err := validateAnalyticsSessionFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListSlotsInput(v *ListSlotsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListSlotsInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.IntentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntentId"))
	}
	if v.SortBy != nil {
		if err := validateSlotSortBy(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filters != nil {
		if err := validateSlotFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListSlotTypesInput(v *ListSlotTypesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListSlotTypesInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.SortBy != nil {
		if err := validateSlotTypeSortBy(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filters != nil {
		if err := validateSlotTypeFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListTestExecutionResultItemsInput(v *ListTestExecutionResultItemsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTestExecutionResultItemsInput"}
	if v.TestExecutionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TestExecutionId"))
	}
	if v.ResultFilterBy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResultFilterBy"))
	} else if v.ResultFilterBy != nil {
		if err := validateTestExecutionResultFilterBy(v.ResultFilterBy); err != nil {
			invalidParams.AddNested("ResultFilterBy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListTestExecutionsInput(v *ListTestExecutionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTestExecutionsInput"}
	if v.SortBy != nil {
		if err := validateTestExecutionSortBy(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListTestSetsInput(v *ListTestSetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTestSetsInput"}
	if v.SortBy != nil {
		if err := validateTestSetSortBy(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListUtteranceAnalyticsDataInput(v *ListUtteranceAnalyticsDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListUtteranceAnalyticsDataInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.StartDateTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartDateTime"))
	}
	if v.EndDateTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndDateTime"))
	}
	if v.SortBy != nil {
		if err := validateUtteranceDataSortBy(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filters != nil {
		if err := validateAnalyticsUtteranceFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListUtteranceMetricsInput(v *ListUtteranceMetricsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListUtteranceMetricsInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.StartDateTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartDateTime"))
	}
	if v.EndDateTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndDateTime"))
	}
	if v.Metrics == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Metrics"))
	} else if v.Metrics != nil {
		if err := validateAnalyticsUtteranceMetrics(v.Metrics); err != nil {
			invalidParams.AddNested("Metrics", err.(smithy.InvalidParamsError))
		}
	}
	if v.BinBy != nil {
		if err := validateAnalyticsBinByList(v.BinBy); err != nil {
			invalidParams.AddNested("BinBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.GroupBy != nil {
		if err := validateAnalyticsUtteranceGroupByList(v.GroupBy); err != nil {
			invalidParams.AddNested("GroupBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.Attributes != nil {
		if err := validateAnalyticsUtteranceAttributes(v.Attributes); err != nil {
			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filters != nil {
		if err := validateAnalyticsUtteranceFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchAssociatedTranscriptsInput(v *SearchAssociatedTranscriptsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchAssociatedTranscriptsInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.BotRecommendationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotRecommendationId"))
	}
	if v.Filters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
	} else if v.Filters != nil {
		if err := validateAssociatedTranscriptFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartBotRecommendationInput(v *StartBotRecommendationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartBotRecommendationInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.TranscriptSourceSetting == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TranscriptSourceSetting"))
	} else if v.TranscriptSourceSetting != nil {
		if err := validateTranscriptSourceSetting(v.TranscriptSourceSetting); err != nil {
			invalidParams.AddNested("TranscriptSourceSetting", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartBotResourceGenerationInput(v *StartBotResourceGenerationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartBotResourceGenerationInput"}
	if v.GenerationInputPrompt == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GenerationInputPrompt"))
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartImportInput(v *StartImportInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartImportInput"}
	if v.ImportId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImportId"))
	}
	if v.ResourceSpecification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceSpecification"))
	} else if v.ResourceSpecification != nil {
		if err := validateImportResourceSpecification(v.ResourceSpecification); err != nil {
			invalidParams.AddNested("ResourceSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.MergeStrategy) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MergeStrategy"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartTestExecutionInput(v *StartTestExecutionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartTestExecutionInput"}
	if v.TestSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TestSetId"))
	}
	if v.Target == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Target"))
	} else if v.Target != nil {
		if err := validateTestExecutionTarget(v.Target); err != nil {
			invalidParams.AddNested("Target", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.ApiMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ApiMode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartTestSetGenerationInput(v *StartTestSetGenerationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartTestSetGenerationInput"}
	if v.TestSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TestSetName"))
	}
	if v.StorageLocation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StorageLocation"))
	} else if v.StorageLocation != nil {
		if err := validateTestSetStorageLocation(v.StorageLocation); err != nil {
			invalidParams.AddNested("StorageLocation", err.(smithy.InvalidParamsError))
		}
	}
	if v.GenerationDataSource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GenerationDataSource"))
	} else if v.GenerationDataSource != nil {
		if err := validateTestSetGenerationDataSource(v.GenerationDataSource); err != nil {
			invalidParams.AddNested("GenerationDataSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopBotRecommendationInput(v *StopBotRecommendationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopBotRecommendationInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.BotRecommendationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotRecommendationId"))
	}
	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 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 validateOpUpdateBotAliasInput(v *UpdateBotAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateBotAliasInput"}
	if v.BotAliasId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotAliasId"))
	}
	if v.BotAliasName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotAliasName"))
	}
	if v.BotAliasLocaleSettings != nil {
		if err := validateBotAliasLocaleSettingsMap(v.BotAliasLocaleSettings); err != nil {
			invalidParams.AddNested("BotAliasLocaleSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.ConversationLogSettings != nil {
		if err := validateConversationLogSettings(v.ConversationLogSettings); err != nil {
			invalidParams.AddNested("ConversationLogSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.SentimentAnalysisSettings != nil {
		if err := validateSentimentAnalysisSettings(v.SentimentAnalysisSettings); err != nil {
			invalidParams.AddNested("SentimentAnalysisSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateBotInput(v *UpdateBotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateBotInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotName"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.DataPrivacy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataPrivacy"))
	} else if v.DataPrivacy != nil {
		if err := validateDataPrivacy(v.DataPrivacy); err != nil {
			invalidParams.AddNested("DataPrivacy", err.(smithy.InvalidParamsError))
		}
	}
	if v.IdleSessionTTLInSeconds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdleSessionTTLInSeconds"))
	}
	if v.BotMembers != nil {
		if err := validateBotMembers(v.BotMembers); err != nil {
			invalidParams.AddNested("BotMembers", err.(smithy.InvalidParamsError))
		}
	}
	if v.ErrorLogSettings != nil {
		if err := validateErrorLogSettings(v.ErrorLogSettings); err != nil {
			invalidParams.AddNested("ErrorLogSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateBotLocaleInput(v *UpdateBotLocaleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateBotLocaleInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.NluIntentConfidenceThreshold == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NluIntentConfidenceThreshold"))
	}
	if v.VoiceSettings != nil {
		if err := validateVoiceSettings(v.VoiceSettings); err != nil {
			invalidParams.AddNested("VoiceSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.GenerativeAISettings != nil {
		if err := validateGenerativeAISettings(v.GenerativeAISettings); err != nil {
			invalidParams.AddNested("GenerativeAISettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateBotRecommendationInput(v *UpdateBotRecommendationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateBotRecommendationInput"}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.BotRecommendationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotRecommendationId"))
	}
	if v.EncryptionSetting == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EncryptionSetting"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateIntentInput(v *UpdateIntentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateIntentInput"}
	if v.IntentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntentId"))
	}
	if v.IntentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntentName"))
	}
	if v.SampleUtterances != nil {
		if err := validateSampleUtterancesList(v.SampleUtterances); err != nil {
			invalidParams.AddNested("SampleUtterances", err.(smithy.InvalidParamsError))
		}
	}
	if v.DialogCodeHook != nil {
		if err := validateDialogCodeHookSettings(v.DialogCodeHook); err != nil {
			invalidParams.AddNested("DialogCodeHook", err.(smithy.InvalidParamsError))
		}
	}
	if v.FulfillmentCodeHook != nil {
		if err := validateFulfillmentCodeHookSettings(v.FulfillmentCodeHook); err != nil {
			invalidParams.AddNested("FulfillmentCodeHook", err.(smithy.InvalidParamsError))
		}
	}
	if v.SlotPriorities != nil {
		if err := validateSlotPrioritiesList(v.SlotPriorities); err != nil {
			invalidParams.AddNested("SlotPriorities", err.(smithy.InvalidParamsError))
		}
	}
	if v.IntentConfirmationSetting != nil {
		if err := validateIntentConfirmationSetting(v.IntentConfirmationSetting); err != nil {
			invalidParams.AddNested("IntentConfirmationSetting", err.(smithy.InvalidParamsError))
		}
	}
	if v.IntentClosingSetting != nil {
		if err := validateIntentClosingSetting(v.IntentClosingSetting); err != nil {
			invalidParams.AddNested("IntentClosingSetting", err.(smithy.InvalidParamsError))
		}
	}
	if v.InputContexts != nil {
		if err := validateInputContextsList(v.InputContexts); err != nil {
			invalidParams.AddNested("InputContexts", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputContexts != nil {
		if err := validateOutputContextsList(v.OutputContexts); err != nil {
			invalidParams.AddNested("OutputContexts", err.(smithy.InvalidParamsError))
		}
	}
	if v.KendraConfiguration != nil {
		if err := validateKendraConfiguration(v.KendraConfiguration); err != nil {
			invalidParams.AddNested("KendraConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.InitialResponseSetting != nil {
		if err := validateInitialResponseSetting(v.InitialResponseSetting); err != nil {
			invalidParams.AddNested("InitialResponseSetting", err.(smithy.InvalidParamsError))
		}
	}
	if v.QnAIntentConfiguration != nil {
		if err := validateQnAIntentConfiguration(v.QnAIntentConfiguration); err != nil {
			invalidParams.AddNested("QnAIntentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.QInConnectIntentConfiguration != nil {
		if err := validateQInConnectIntentConfiguration(v.QInConnectIntentConfiguration); err != nil {
			invalidParams.AddNested("QInConnectIntentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateSlotInput(v *UpdateSlotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSlotInput"}
	if v.SlotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SlotId"))
	}
	if v.SlotName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SlotName"))
	}
	if v.ValueElicitationSetting == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ValueElicitationSetting"))
	} else if v.ValueElicitationSetting != nil {
		if err := validateSlotValueElicitationSetting(v.ValueElicitationSetting); err != nil {
			invalidParams.AddNested("ValueElicitationSetting", err.(smithy.InvalidParamsError))
		}
	}
	if v.ObfuscationSetting != nil {
		if err := validateObfuscationSetting(v.ObfuscationSetting); err != nil {
			invalidParams.AddNested("ObfuscationSetting", err.(smithy.InvalidParamsError))
		}
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.IntentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntentId"))
	}
	if v.SubSlotSetting != nil {
		if err := validateSubSlotSetting(v.SubSlotSetting); err != nil {
			invalidParams.AddNested("SubSlotSetting", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateSlotTypeInput(v *UpdateSlotTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSlotTypeInput"}
	if v.SlotTypeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SlotTypeId"))
	}
	if v.SlotTypeName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SlotTypeName"))
	}
	if v.SlotTypeValues != nil {
		if err := validateSlotTypeValues(v.SlotTypeValues); err != nil {
			invalidParams.AddNested("SlotTypeValues", err.(smithy.InvalidParamsError))
		}
	}
	if v.ValueSelectionSetting != nil {
		if err := validateSlotValueSelectionSetting(v.ValueSelectionSetting); err != nil {
			invalidParams.AddNested("ValueSelectionSetting", err.(smithy.InvalidParamsError))
		}
	}
	if v.BotId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotId"))
	}
	if v.BotVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotVersion"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if v.ExternalSourceSetting != nil {
		if err := validateExternalSourceSetting(v.ExternalSourceSetting); err != nil {
			invalidParams.AddNested("ExternalSourceSetting", err.(smithy.InvalidParamsError))
		}
	}
	if v.CompositeSlotTypeSetting != nil {
		if err := validateCompositeSlotTypeSetting(v.CompositeSlotTypeSetting); err != nil {
			invalidParams.AddNested("CompositeSlotTypeSetting", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateTestSetInput(v *UpdateTestSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTestSetInput"}
	if v.TestSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TestSetId"))
	}
	if v.TestSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TestSetName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}