service/qconnect/validators.go

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

package qconnect

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

type validateOpActivateMessageTemplate struct {
}

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

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

type validateOpCreateAIAgent struct {
}

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

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

type validateOpCreateAIAgentVersion struct {
}

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

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

type validateOpCreateAIGuardrail struct {
}

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

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

type validateOpCreateAIGuardrailVersion struct {
}

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

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

type validateOpCreateAIPrompt struct {
}

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

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

type validateOpCreateAIPromptVersion struct {
}

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

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

type validateOpCreateAssistantAssociation struct {
}

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

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

type validateOpCreateAssistant struct {
}

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

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

type validateOpCreateContentAssociation struct {
}

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

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

type validateOpCreateContent struct {
}

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

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

type validateOpCreateKnowledgeBase struct {
}

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

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

type validateOpCreateMessageTemplateAttachment struct {
}

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

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

type validateOpCreateMessageTemplate struct {
}

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

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

type validateOpCreateMessageTemplateVersion struct {
}

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

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

type validateOpCreateQuickResponse struct {
}

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

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

type validateOpCreateSession struct {
}

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

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

type validateOpDeactivateMessageTemplate struct {
}

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

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

type validateOpDeleteAIAgent struct {
}

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

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

type validateOpDeleteAIAgentVersion struct {
}

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

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

type validateOpDeleteAIGuardrail struct {
}

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

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

type validateOpDeleteAIGuardrailVersion struct {
}

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

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

type validateOpDeleteAIPrompt struct {
}

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

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

type validateOpDeleteAIPromptVersion struct {
}

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

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

type validateOpDeleteAssistantAssociation struct {
}

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

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

type validateOpDeleteAssistant struct {
}

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

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

type validateOpDeleteContentAssociation struct {
}

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

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

type validateOpDeleteContent struct {
}

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

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

type validateOpDeleteImportJob struct {
}

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

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

type validateOpDeleteKnowledgeBase struct {
}

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

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

type validateOpDeleteMessageTemplateAttachment struct {
}

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

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

type validateOpDeleteMessageTemplate struct {
}

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

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

type validateOpDeleteQuickResponse struct {
}

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

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

type validateOpGetAIAgent struct {
}

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

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

type validateOpGetAIGuardrail struct {
}

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

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

type validateOpGetAIPrompt struct {
}

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

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

type validateOpGetAssistantAssociation struct {
}

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

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

type validateOpGetAssistant struct {
}

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

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

type validateOpGetContentAssociation struct {
}

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

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

type validateOpGetContent struct {
}

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

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

type validateOpGetContentSummary struct {
}

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

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

type validateOpGetImportJob struct {
}

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

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

type validateOpGetKnowledgeBase struct {
}

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

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

type validateOpGetMessageTemplate struct {
}

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

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

type validateOpGetNextMessage struct {
}

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

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

type validateOpGetQuickResponse struct {
}

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

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

type validateOpGetRecommendations struct {
}

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

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

type validateOpGetSession struct {
}

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

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

type validateOpListAIAgents struct {
}

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

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

type validateOpListAIAgentVersions struct {
}

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

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

type validateOpListAIGuardrails struct {
}

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

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

type validateOpListAIGuardrailVersions struct {
}

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

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

type validateOpListAIPrompts struct {
}

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

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

type validateOpListAIPromptVersions struct {
}

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

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

type validateOpListAssistantAssociations struct {
}

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

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

type validateOpListContentAssociations struct {
}

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

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

type validateOpListContents struct {
}

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

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

type validateOpListImportJobs struct {
}

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

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

type validateOpListMessages struct {
}

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

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

type validateOpListMessageTemplates struct {
}

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

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

type validateOpListMessageTemplateVersions struct {
}

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

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

type validateOpListQuickResponses struct {
}

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

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

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

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

type validateOpPutFeedback struct {
}

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

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

type validateOpQueryAssistant struct {
}

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

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

type validateOpRemoveAssistantAIAgent struct {
}

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

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

type validateOpRemoveKnowledgeBaseTemplateUri struct {
}

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

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

type validateOpRenderMessageTemplate struct {
}

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

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

type validateOpSearchContent struct {
}

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

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

type validateOpSearchMessageTemplates struct {
}

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

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

type validateOpSearchQuickResponses struct {
}

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

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

type validateOpSearchSessions struct {
}

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

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

type validateOpSendMessage struct {
}

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

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

type validateOpStartContentUpload struct {
}

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

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

type validateOpStartImportJob struct {
}

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

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

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

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

type validateOpUpdateAIGuardrail struct {
}

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

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

type validateOpUpdateAIPrompt struct {
}

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

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

type validateOpUpdateAssistantAIAgent struct {
}

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

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

type validateOpUpdateContent struct {
}

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

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

type validateOpUpdateKnowledgeBaseTemplateUri struct {
}

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

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

type validateOpUpdateMessageTemplate struct {
}

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

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

type validateOpUpdateMessageTemplateMetadata struct {
}

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

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

type validateOpUpdateQuickResponse struct {
}

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

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

type validateOpUpdateSessionData struct {
}

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

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

type validateOpUpdateSession struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpStartImportJobValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartImportJob{}, 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 addOpUpdateAIAgentValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateAIAgent{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

func validateAIAgentConfiguration(v types.AIAgentConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AIAgentConfiguration"}
	switch uv := v.(type) {
	case *types.AIAgentConfigurationMemberAnswerRecommendationAIAgentConfiguration:
		if err := validateAnswerRecommendationAIAgentConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[answerRecommendationAIAgentConfiguration]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

func validateAIGuardrailContentPolicyConfig(v *types.AIGuardrailContentPolicyConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AIGuardrailContentPolicyConfig"}
	if v.FiltersConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FiltersConfig"))
	} else if v.FiltersConfig != nil {
		if err := validateGuardrailContentFiltersConfig(v.FiltersConfig); err != nil {
			invalidParams.AddNested("FiltersConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAIGuardrailContextualGroundingPolicyConfig(v *types.AIGuardrailContextualGroundingPolicyConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AIGuardrailContextualGroundingPolicyConfig"}
	if v.FiltersConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FiltersConfig"))
	} else if v.FiltersConfig != nil {
		if err := validateGuardrailContextualGroundingFiltersConfig(v.FiltersConfig); err != nil {
			invalidParams.AddNested("FiltersConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAIGuardrailSensitiveInformationPolicyConfig(v *types.AIGuardrailSensitiveInformationPolicyConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AIGuardrailSensitiveInformationPolicyConfig"}
	if v.PiiEntitiesConfig != nil {
		if err := validateGuardrailPiiEntitiesConfig(v.PiiEntitiesConfig); err != nil {
			invalidParams.AddNested("PiiEntitiesConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.RegexesConfig != nil {
		if err := validateGuardrailRegexesConfig(v.RegexesConfig); err != nil {
			invalidParams.AddNested("RegexesConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAIGuardrailTopicPolicyConfig(v *types.AIGuardrailTopicPolicyConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AIGuardrailTopicPolicyConfig"}
	if v.TopicsConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopicsConfig"))
	} else if v.TopicsConfig != nil {
		if err := validateGuardrailTopicsConfig(v.TopicsConfig); err != nil {
			invalidParams.AddNested("TopicsConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAIGuardrailWordPolicyConfig(v *types.AIGuardrailWordPolicyConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AIGuardrailWordPolicyConfig"}
	if v.WordsConfig != nil {
		if err := validateGuardrailWordsConfig(v.WordsConfig); err != nil {
			invalidParams.AddNested("WordsConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ManagedWordListsConfig != nil {
		if err := validateGuardrailManagedWordListsConfig(v.ManagedWordListsConfig); err != nil {
			invalidParams.AddNested("ManagedWordListsConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAIPromptTemplateConfiguration(v types.AIPromptTemplateConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AIPromptTemplateConfiguration"}
	switch uv := v.(type) {
	case *types.AIPromptTemplateConfigurationMemberTextFullAIPromptEditTemplateConfiguration:
		if err := validateTextFullAIPromptEditTemplateConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[textFullAIPromptEditTemplateConfiguration]", err.(smithy.InvalidParamsError))
		}

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

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

func validateAnswerRecommendationAIAgentConfiguration(v *types.AnswerRecommendationAIAgentConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AnswerRecommendationAIAgentConfiguration"}
	if v.AssociationConfigurations != nil {
		if err := validateAssociationConfigurationList(v.AssociationConfigurations); err != nil {
			invalidParams.AddNested("AssociationConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateAssociationConfiguration(v *types.AssociationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociationConfiguration"}
	if v.AssociationConfigurationData != nil {
		if err := validateAssociationConfigurationData(v.AssociationConfigurationData); err != nil {
			invalidParams.AddNested("AssociationConfigurationData", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAssociationConfigurationData(v types.AssociationConfigurationData) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociationConfigurationData"}
	switch uv := v.(type) {
	case *types.AssociationConfigurationDataMemberKnowledgeBaseAssociationConfigurationData:
		if err := validateKnowledgeBaseAssociationConfigurationData(&uv.Value); err != nil {
			invalidParams.AddNested("[knowledgeBaseAssociationConfigurationData]", err.(smithy.InvalidParamsError))
		}

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

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

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

func validateChunkingConfiguration(v *types.ChunkingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChunkingConfiguration"}
	if len(v.ChunkingStrategy) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ChunkingStrategy"))
	}
	if v.FixedSizeChunkingConfiguration != nil {
		if err := validateFixedSizeChunkingConfiguration(v.FixedSizeChunkingConfiguration); err != nil {
			invalidParams.AddNested("FixedSizeChunkingConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.HierarchicalChunkingConfiguration != nil {
		if err := validateHierarchicalChunkingConfiguration(v.HierarchicalChunkingConfiguration); err != nil {
			invalidParams.AddNested("HierarchicalChunkingConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.SemanticChunkingConfiguration != nil {
		if err := validateSemanticChunkingConfiguration(v.SemanticChunkingConfiguration); err != nil {
			invalidParams.AddNested("SemanticChunkingConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateContentFeedbackData(v types.ContentFeedbackData) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContentFeedbackData"}
	switch uv := v.(type) {
	case *types.ContentFeedbackDataMemberGenerativeContentFeedbackData:
		if err := validateGenerativeContentFeedbackData(&uv.Value); err != nil {
			invalidParams.AddNested("[generativeContentFeedbackData]", err.(smithy.InvalidParamsError))
		}

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

func validateConversationContext(v *types.ConversationContext) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConversationContext"}
	if v.SelfServiceConversationHistory == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SelfServiceConversationHistory"))
	} else if v.SelfServiceConversationHistory != nil {
		if err := validateSelfServiceConversationHistoryList(v.SelfServiceConversationHistory); err != nil {
			invalidParams.AddNested("SelfServiceConversationHistory", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateExternalSourceConfiguration(v *types.ExternalSourceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExternalSourceConfiguration"}
	if len(v.Source) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	}
	if v.Configuration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Configuration"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateFixedSizeChunkingConfiguration(v *types.FixedSizeChunkingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FixedSizeChunkingConfiguration"}
	if v.MaxTokens == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxTokens"))
	}
	if v.OverlapPercentage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OverlapPercentage"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateHierarchicalChunkingConfiguration(v *types.HierarchicalChunkingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HierarchicalChunkingConfiguration"}
	if v.LevelConfigurations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LevelConfigurations"))
	} else if v.LevelConfigurations != nil {
		if err := validateHierarchicalChunkingLevelConfigurations(v.LevelConfigurations); err != nil {
			invalidParams.AddNested("LevelConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.OverlapTokens == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OverlapTokens"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateKnowledgeBaseAssociationConfigurationData(v *types.KnowledgeBaseAssociationConfigurationData) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KnowledgeBaseAssociationConfigurationData"}
	if v.ContentTagFilter != nil {
		if err := validateTagFilter(v.ContentTagFilter); err != nil {
			invalidParams.AddNested("ContentTagFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateManagedSourceConfiguration(v types.ManagedSourceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ManagedSourceConfiguration"}
	switch uv := v.(type) {
	case *types.ManagedSourceConfigurationMemberWebCrawlerConfiguration:
		if err := validateWebCrawlerConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[webCrawlerConfiguration]", err.(smithy.InvalidParamsError))
		}

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

func validateManualSearchAIAgentConfiguration(v *types.ManualSearchAIAgentConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ManualSearchAIAgentConfiguration"}
	if v.AssociationConfigurations != nil {
		if err := validateAssociationConfigurationList(v.AssociationConfigurations); err != nil {
			invalidParams.AddNested("AssociationConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateMessageTemplateQueryField(v *types.MessageTemplateQueryField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MessageTemplateQueryField"}
	if v.Name == nil {
		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 validateMessageTemplateQueryFieldList(v []types.MessageTemplateQueryField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MessageTemplateQueryFieldList"}
	for i := range v {
		if err := validateMessageTemplateQueryField(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMessageTemplateSearchExpression(v *types.MessageTemplateSearchExpression) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MessageTemplateSearchExpression"}
	if v.Queries != nil {
		if err := validateMessageTemplateQueryFieldList(v.Queries); err != nil {
			invalidParams.AddNested("Queries", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filters != nil {
		if err := validateMessageTemplateFilterFieldList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if v.OrderOnField != nil {
		if err := validateMessageTemplateOrderField(v.OrderOnField); err != nil {
			invalidParams.AddNested("OrderOnField", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOrCondition(v types.OrCondition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OrCondition"}
	switch uv := v.(type) {
	case *types.OrConditionMemberAndConditions:
		if err := validateAndConditions(uv.Value); err != nil {
			invalidParams.AddNested("[andConditions]", err.(smithy.InvalidParamsError))
		}

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

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

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

func validateParsingConfiguration(v *types.ParsingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParsingConfiguration"}
	if len(v.ParsingStrategy) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ParsingStrategy"))
	}
	if v.BedrockFoundationModelConfiguration != nil {
		if err := validateBedrockFoundationModelConfigurationForParsing(v.BedrockFoundationModelConfiguration); err != nil {
			invalidParams.AddNested("BedrockFoundationModelConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateQueryCondition(v types.QueryCondition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QueryCondition"}
	switch uv := v.(type) {
	case *types.QueryConditionMemberSingle:
		if err := validateQueryConditionItem(&uv.Value); err != nil {
			invalidParams.AddNested("[single]", err.(smithy.InvalidParamsError))
		}

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

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

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

func validateQueryInputData(v types.QueryInputData) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QueryInputData"}
	switch uv := v.(type) {
	case *types.QueryInputDataMemberIntentInputData:
		if err := validateIntentInputData(&uv.Value); err != nil {
			invalidParams.AddNested("[intentInputData]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

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

func validateQuickResponseQueryField(v *types.QuickResponseQueryField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QuickResponseQueryField"}
	if v.Name == nil {
		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 validateQuickResponseQueryFieldList(v []types.QuickResponseQueryField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QuickResponseQueryFieldList"}
	for i := range v {
		if err := validateQuickResponseQueryField(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateQuickResponseSearchExpression(v *types.QuickResponseSearchExpression) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QuickResponseSearchExpression"}
	if v.Queries != nil {
		if err := validateQuickResponseQueryFieldList(v.Queries); err != nil {
			invalidParams.AddNested("Queries", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filters != nil {
		if err := validateQuickResponseFilterFieldList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if v.OrderOnField != nil {
		if err := validateQuickResponseOrderField(v.OrderOnField); err != nil {
			invalidParams.AddNested("OrderOnField", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateSearchExpression(v *types.SearchExpression) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchExpression"}
	if v.Filters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
	} else if v.Filters != nil {
		if err := validateFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSelfServiceAIAgentConfiguration(v *types.SelfServiceAIAgentConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SelfServiceAIAgentConfiguration"}
	if v.AssociationConfigurations != nil {
		if err := validateAssociationConfigurationList(v.AssociationConfigurations); err != nil {
			invalidParams.AddNested("AssociationConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateSemanticChunkingConfiguration(v *types.SemanticChunkingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SemanticChunkingConfiguration"}
	if v.MaxTokens == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxTokens"))
	}
	if v.BufferSize == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BufferSize"))
	}
	if v.BreakpointPercentileThreshold == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BreakpointPercentileThreshold"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSourceConfiguration(v types.SourceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SourceConfiguration"}
	switch uv := v.(type) {
	case *types.SourceConfigurationMemberAppIntegrations:
		if err := validateAppIntegrationsConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[appIntegrations]", err.(smithy.InvalidParamsError))
		}

	case *types.SourceConfigurationMemberManagedSourceConfiguration:
		if err := validateManagedSourceConfiguration(uv.Value); err != nil {
			invalidParams.AddNested("[managedSourceConfiguration]", err.(smithy.InvalidParamsError))
		}

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

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

func validateTagFilter(v types.TagFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagFilter"}
	switch uv := v.(type) {
	case *types.TagFilterMemberAndConditions:
		if err := validateAndConditions(uv.Value); err != nil {
			invalidParams.AddNested("[andConditions]", err.(smithy.InvalidParamsError))
		}

	case *types.TagFilterMemberOrConditions:
		if err := validateOrConditions(uv.Value); err != nil {
			invalidParams.AddNested("[orConditions]", err.(smithy.InvalidParamsError))
		}

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

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

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

func validateVectorIngestionConfiguration(v *types.VectorIngestionConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VectorIngestionConfiguration"}
	if v.ChunkingConfiguration != nil {
		if err := validateChunkingConfiguration(v.ChunkingConfiguration); err != nil {
			invalidParams.AddNested("ChunkingConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ParsingConfiguration != nil {
		if err := validateParsingConfiguration(v.ParsingConfiguration); err != nil {
			invalidParams.AddNested("ParsingConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpActivateMessageTemplateInput(v *ActivateMessageTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ActivateMessageTemplateInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.MessageTemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageTemplateId"))
	}
	if v.VersionNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VersionNumber"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAIAgentInput(v *CreateAIAgentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAIAgentInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.Configuration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Configuration"))
	} else if v.Configuration != nil {
		if err := validateAIAgentConfiguration(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.VisibilityStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("VisibilityStatus"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAIAgentVersionInput(v *CreateAIAgentVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAIAgentVersionInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.AiAgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AiAgentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAIGuardrailInput(v *CreateAIGuardrailInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAIGuardrailInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.BlockedInputMessaging == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BlockedInputMessaging"))
	}
	if v.BlockedOutputsMessaging == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BlockedOutputsMessaging"))
	}
	if len(v.VisibilityStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("VisibilityStatus"))
	}
	if v.TopicPolicyConfig != nil {
		if err := validateAIGuardrailTopicPolicyConfig(v.TopicPolicyConfig); err != nil {
			invalidParams.AddNested("TopicPolicyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContentPolicyConfig != nil {
		if err := validateAIGuardrailContentPolicyConfig(v.ContentPolicyConfig); err != nil {
			invalidParams.AddNested("ContentPolicyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.WordPolicyConfig != nil {
		if err := validateAIGuardrailWordPolicyConfig(v.WordPolicyConfig); err != nil {
			invalidParams.AddNested("WordPolicyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.SensitiveInformationPolicyConfig != nil {
		if err := validateAIGuardrailSensitiveInformationPolicyConfig(v.SensitiveInformationPolicyConfig); err != nil {
			invalidParams.AddNested("SensitiveInformationPolicyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContextualGroundingPolicyConfig != nil {
		if err := validateAIGuardrailContextualGroundingPolicyConfig(v.ContextualGroundingPolicyConfig); err != nil {
			invalidParams.AddNested("ContextualGroundingPolicyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAIGuardrailVersionInput(v *CreateAIGuardrailVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAIGuardrailVersionInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.AiGuardrailId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AiGuardrailId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAIPromptInput(v *CreateAIPromptInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAIPromptInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.TemplateConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateConfiguration"))
	} else if v.TemplateConfiguration != nil {
		if err := validateAIPromptTemplateConfiguration(v.TemplateConfiguration); err != nil {
			invalidParams.AddNested("TemplateConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.VisibilityStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("VisibilityStatus"))
	}
	if len(v.TemplateType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateType"))
	}
	if v.ModelId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelId"))
	}
	if len(v.ApiFormat) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ApiFormat"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAIPromptVersionInput(v *CreateAIPromptVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAIPromptVersionInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.AiPromptId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AiPromptId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAssistantAssociationInput(v *CreateAssistantAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAssistantAssociationInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if len(v.AssociationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AssociationType"))
	}
	if v.Association == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Association"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateContentAssociationInput(v *CreateContentAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateContentAssociationInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.ContentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContentId"))
	}
	if len(v.AssociationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AssociationType"))
	}
	if v.Association == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Association"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateKnowledgeBaseInput(v *CreateKnowledgeBaseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateKnowledgeBaseInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.KnowledgeBaseType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseType"))
	}
	if v.SourceConfiguration != nil {
		if err := validateSourceConfiguration(v.SourceConfiguration); err != nil {
			invalidParams.AddNested("SourceConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.VectorIngestionConfiguration != nil {
		if err := validateVectorIngestionConfiguration(v.VectorIngestionConfiguration); err != nil {
			invalidParams.AddNested("VectorIngestionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMessageTemplateAttachmentInput(v *CreateMessageTemplateAttachmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMessageTemplateAttachmentInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.MessageTemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageTemplateId"))
	}
	if len(v.ContentDisposition) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ContentDisposition"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Body == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Body"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMessageTemplateInput(v *CreateMessageTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMessageTemplateInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	}
	if len(v.ChannelSubtype) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelSubtype"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMessageTemplateVersionInput(v *CreateMessageTemplateVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMessageTemplateVersionInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.MessageTemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageTemplateId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateSessionInput(v *CreateSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSessionInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.TagFilter != nil {
		if err := validateTagFilter(v.TagFilter); err != nil {
			invalidParams.AddNested("TagFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.AiAgentConfiguration != nil {
		if err := validateAIAgentConfigurationMap(v.AiAgentConfiguration); err != nil {
			invalidParams.AddNested("AiAgentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeactivateMessageTemplateInput(v *DeactivateMessageTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeactivateMessageTemplateInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.MessageTemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageTemplateId"))
	}
	if v.VersionNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VersionNumber"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteAIAgentInput(v *DeleteAIAgentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAIAgentInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.AiAgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AiAgentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteAIAgentVersionInput(v *DeleteAIAgentVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAIAgentVersionInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.AiAgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AiAgentId"))
	}
	if v.VersionNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VersionNumber"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteAIGuardrailInput(v *DeleteAIGuardrailInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAIGuardrailInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.AiGuardrailId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AiGuardrailId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteAIGuardrailVersionInput(v *DeleteAIGuardrailVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAIGuardrailVersionInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.AiGuardrailId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AiGuardrailId"))
	}
	if v.VersionNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VersionNumber"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteAIPromptInput(v *DeleteAIPromptInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAIPromptInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.AiPromptId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AiPromptId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteAIPromptVersionInput(v *DeleteAIPromptVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAIPromptVersionInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.AiPromptId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AiPromptId"))
	}
	if v.VersionNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VersionNumber"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteAssistantAssociationInput(v *DeleteAssistantAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAssistantAssociationInput"}
	if v.AssistantAssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantAssociationId"))
	}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteContentAssociationInput(v *DeleteContentAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteContentAssociationInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.ContentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContentId"))
	}
	if v.ContentAssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContentAssociationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteContentInput(v *DeleteContentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteContentInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.ContentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteImportJobInput(v *DeleteImportJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteImportJobInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.ImportJobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImportJobId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteMessageTemplateAttachmentInput(v *DeleteMessageTemplateAttachmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteMessageTemplateAttachmentInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.MessageTemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageTemplateId"))
	}
	if v.AttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttachmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteMessageTemplateInput(v *DeleteMessageTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteMessageTemplateInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.MessageTemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageTemplateId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteQuickResponseInput(v *DeleteQuickResponseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteQuickResponseInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.QuickResponseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QuickResponseId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAIAgentInput(v *GetAIAgentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAIAgentInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.AiAgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AiAgentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAIGuardrailInput(v *GetAIGuardrailInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAIGuardrailInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.AiGuardrailId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AiGuardrailId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAIPromptInput(v *GetAIPromptInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAIPromptInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.AiPromptId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AiPromptId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAssistantAssociationInput(v *GetAssistantAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAssistantAssociationInput"}
	if v.AssistantAssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantAssociationId"))
	}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetContentAssociationInput(v *GetContentAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetContentAssociationInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.ContentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContentId"))
	}
	if v.ContentAssociationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContentAssociationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetContentInput(v *GetContentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetContentInput"}
	if v.ContentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContentId"))
	}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetContentSummaryInput(v *GetContentSummaryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetContentSummaryInput"}
	if v.ContentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContentId"))
	}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetImportJobInput(v *GetImportJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetImportJobInput"}
	if v.ImportJobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImportJobId"))
	}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetMessageTemplateInput(v *GetMessageTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMessageTemplateInput"}
	if v.MessageTemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageTemplateId"))
	}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetNextMessageInput(v *GetNextMessageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetNextMessageInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if v.NextMessageToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NextMessageToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetQuickResponseInput(v *GetQuickResponseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetQuickResponseInput"}
	if v.QuickResponseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QuickResponseId"))
	}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetRecommendationsInput(v *GetRecommendationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRecommendationsInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSessionInput(v *GetSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSessionInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListAIAgentVersionsInput(v *ListAIAgentVersionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAIAgentVersionsInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.AiAgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AiAgentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListAIGuardrailVersionsInput(v *ListAIGuardrailVersionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAIGuardrailVersionsInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.AiGuardrailId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AiGuardrailId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListAIPromptVersionsInput(v *ListAIPromptVersionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAIPromptVersionsInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.AiPromptId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AiPromptId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListContentAssociationsInput(v *ListContentAssociationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListContentAssociationsInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.ContentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListMessagesInput(v *ListMessagesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListMessagesInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListMessageTemplateVersionsInput(v *ListMessageTemplateVersionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListMessageTemplateVersionsInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.MessageTemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageTemplateId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListQuickResponsesInput(v *ListQuickResponsesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListQuickResponsesInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	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 validateOpNotifyRecommendationsReceivedInput(v *NotifyRecommendationsReceivedInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NotifyRecommendationsReceivedInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if v.RecommendationIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecommendationIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutFeedbackInput(v *PutFeedbackInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutFeedbackInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.TargetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetId"))
	}
	if len(v.TargetType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TargetType"))
	}
	if v.ContentFeedback == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContentFeedback"))
	} else if v.ContentFeedback != nil {
		if err := validateContentFeedbackData(v.ContentFeedback); err != nil {
			invalidParams.AddNested("ContentFeedback", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpQueryAssistantInput(v *QueryAssistantInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QueryAssistantInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.QueryCondition != nil {
		if err := validateQueryConditionExpression(v.QueryCondition); err != nil {
			invalidParams.AddNested("QueryCondition", err.(smithy.InvalidParamsError))
		}
	}
	if v.QueryInputData != nil {
		if err := validateQueryInputData(v.QueryInputData); err != nil {
			invalidParams.AddNested("QueryInputData", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRemoveAssistantAIAgentInput(v *RemoveAssistantAIAgentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveAssistantAIAgentInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if len(v.AiAgentType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AiAgentType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpRenderMessageTemplateInput(v *RenderMessageTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RenderMessageTemplateInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.MessageTemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageTemplateId"))
	}
	if v.Attributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Attributes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchContentInput(v *SearchContentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchContentInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.SearchExpression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SearchExpression"))
	} else if v.SearchExpression != nil {
		if err := validateSearchExpression(v.SearchExpression); err != nil {
			invalidParams.AddNested("SearchExpression", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchMessageTemplatesInput(v *SearchMessageTemplatesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchMessageTemplatesInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.SearchExpression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SearchExpression"))
	} else if v.SearchExpression != nil {
		if err := validateMessageTemplateSearchExpression(v.SearchExpression); err != nil {
			invalidParams.AddNested("SearchExpression", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchQuickResponsesInput(v *SearchQuickResponsesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchQuickResponsesInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.SearchExpression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SearchExpression"))
	} else if v.SearchExpression != nil {
		if err := validateQuickResponseSearchExpression(v.SearchExpression); err != nil {
			invalidParams.AddNested("SearchExpression", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchSessionsInput(v *SearchSessionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchSessionsInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.SearchExpression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SearchExpression"))
	} else if v.SearchExpression != nil {
		if err := validateSearchExpression(v.SearchExpression); err != nil {
			invalidParams.AddNested("SearchExpression", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSendMessageInput(v *SendMessageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SendMessageInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.Message == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Message"))
	} else if v.Message != nil {
		if err := validateMessageInput(v.Message); err != nil {
			invalidParams.AddNested("Message", err.(smithy.InvalidParamsError))
		}
	}
	if v.ConversationContext != nil {
		if err := validateConversationContext(v.ConversationContext); err != nil {
			invalidParams.AddNested("ConversationContext", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartContentUploadInput(v *StartContentUploadInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartContentUploadInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.ContentType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContentType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartImportJobInput(v *StartImportJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartImportJobInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if len(v.ImportJobType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ImportJobType"))
	}
	if v.UploadId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UploadId"))
	}
	if v.ExternalSourceConfiguration != nil {
		if err := validateExternalSourceConfiguration(v.ExternalSourceConfiguration); err != nil {
			invalidParams.AddNested("ExternalSourceConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTagResourceInput(v *TagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	}
	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 validateOpUpdateAIAgentInput(v *UpdateAIAgentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAIAgentInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.AiAgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AiAgentId"))
	}
	if len(v.VisibilityStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("VisibilityStatus"))
	}
	if v.Configuration != nil {
		if err := validateAIAgentConfiguration(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAIGuardrailInput(v *UpdateAIGuardrailInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAIGuardrailInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.AiGuardrailId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AiGuardrailId"))
	}
	if len(v.VisibilityStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("VisibilityStatus"))
	}
	if v.BlockedInputMessaging == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BlockedInputMessaging"))
	}
	if v.BlockedOutputsMessaging == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BlockedOutputsMessaging"))
	}
	if v.TopicPolicyConfig != nil {
		if err := validateAIGuardrailTopicPolicyConfig(v.TopicPolicyConfig); err != nil {
			invalidParams.AddNested("TopicPolicyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContentPolicyConfig != nil {
		if err := validateAIGuardrailContentPolicyConfig(v.ContentPolicyConfig); err != nil {
			invalidParams.AddNested("ContentPolicyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.WordPolicyConfig != nil {
		if err := validateAIGuardrailWordPolicyConfig(v.WordPolicyConfig); err != nil {
			invalidParams.AddNested("WordPolicyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.SensitiveInformationPolicyConfig != nil {
		if err := validateAIGuardrailSensitiveInformationPolicyConfig(v.SensitiveInformationPolicyConfig); err != nil {
			invalidParams.AddNested("SensitiveInformationPolicyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContextualGroundingPolicyConfig != nil {
		if err := validateAIGuardrailContextualGroundingPolicyConfig(v.ContextualGroundingPolicyConfig); err != nil {
			invalidParams.AddNested("ContextualGroundingPolicyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAIPromptInput(v *UpdateAIPromptInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAIPromptInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.AiPromptId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AiPromptId"))
	}
	if len(v.VisibilityStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("VisibilityStatus"))
	}
	if v.TemplateConfiguration != nil {
		if err := validateAIPromptTemplateConfiguration(v.TemplateConfiguration); err != nil {
			invalidParams.AddNested("TemplateConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAssistantAIAgentInput(v *UpdateAssistantAIAgentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAssistantAIAgentInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if len(v.AiAgentType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AiAgentType"))
	}
	if v.Configuration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Configuration"))
	} else if v.Configuration != nil {
		if err := validateAIAgentConfigurationData(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateContentInput(v *UpdateContentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateContentInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.ContentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateKnowledgeBaseTemplateUriInput(v *UpdateKnowledgeBaseTemplateUriInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateKnowledgeBaseTemplateUriInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.TemplateUri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateUri"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateMessageTemplateInput(v *UpdateMessageTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateMessageTemplateInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.MessageTemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageTemplateId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateMessageTemplateMetadataInput(v *UpdateMessageTemplateMetadataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateMessageTemplateMetadataInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.MessageTemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageTemplateId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateQuickResponseInput(v *UpdateQuickResponseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateQuickResponseInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.QuickResponseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QuickResponseId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateSessionDataInput(v *UpdateSessionDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSessionDataInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if v.Data == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Data"))
	} else if v.Data != nil {
		if err := validateRuntimeSessionDataList(v.Data); err != nil {
			invalidParams.AddNested("Data", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateSessionInput(v *UpdateSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSessionInput"}
	if v.AssistantId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssistantId"))
	}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if v.TagFilter != nil {
		if err := validateTagFilter(v.TagFilter); err != nil {
			invalidParams.AddNested("TagFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.AiAgentConfiguration != nil {
		if err := validateAIAgentConfigurationMap(v.AiAgentConfiguration); err != nil {
			invalidParams.AddNested("AiAgentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}