service/bedrockagent/validators.go

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

package bedrockagent

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

type validateOpAssociateAgentCollaborator struct {
}

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

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

type validateOpAssociateAgentKnowledgeBase struct {
}

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

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

type validateOpCreateAgentActionGroup struct {
}

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

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

type validateOpCreateAgentAlias struct {
}

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

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

type validateOpCreateAgent struct {
}

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

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

type validateOpCreateDataSource struct {
}

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

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

type validateOpCreateFlowAlias struct {
}

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

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

type validateOpCreateFlow struct {
}

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

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

type validateOpCreateFlowVersion struct {
}

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

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

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

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

type validateOpCreatePromptVersion struct {
}

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

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

type validateOpDeleteAgentActionGroup struct {
}

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

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

type validateOpDeleteAgentAlias struct {
}

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

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

type validateOpDeleteAgent struct {
}

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

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

type validateOpDeleteAgentVersion struct {
}

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

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

type validateOpDeleteDataSource struct {
}

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

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

type validateOpDeleteFlowAlias struct {
}

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

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

type validateOpDeleteFlow struct {
}

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

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

type validateOpDeleteFlowVersion struct {
}

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

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

type validateOpDeleteKnowledgeBaseDocuments struct {
}

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

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

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

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

type validateOpDisassociateAgentCollaborator struct {
}

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

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

type validateOpDisassociateAgentKnowledgeBase struct {
}

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

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

type validateOpGetAgentActionGroup struct {
}

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

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

type validateOpGetAgentAlias struct {
}

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

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

type validateOpGetAgentCollaborator struct {
}

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

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

type validateOpGetAgent struct {
}

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

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

type validateOpGetAgentKnowledgeBase struct {
}

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

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

type validateOpGetAgentVersion struct {
}

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

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

type validateOpGetDataSource struct {
}

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

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

type validateOpGetFlowAlias struct {
}

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

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

type validateOpGetFlow struct {
}

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

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

type validateOpGetFlowVersion struct {
}

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

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

type validateOpGetIngestionJob struct {
}

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

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

type validateOpGetKnowledgeBaseDocuments struct {
}

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

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

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

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

type validateOpIngestKnowledgeBaseDocuments struct {
}

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

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

type validateOpListAgentActionGroups struct {
}

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

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

type validateOpListAgentAliases struct {
}

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

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

type validateOpListAgentCollaborators struct {
}

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

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

type validateOpListAgentKnowledgeBases struct {
}

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

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

type validateOpListAgentVersions struct {
}

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

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

type validateOpListDataSources struct {
}

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

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

type validateOpListFlowAliases struct {
}

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

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

type validateOpListFlowVersions struct {
}

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

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

type validateOpListIngestionJobs struct {
}

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

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

type validateOpListKnowledgeBaseDocuments struct {
}

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

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

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

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

type validateOpPrepareFlow struct {
}

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

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

type validateOpStartIngestionJob struct {
}

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

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

type validateOpStopIngestionJob struct {
}

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

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

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

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

type validateOpUpdateAgentAlias struct {
}

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

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

type validateOpUpdateAgentCollaborator struct {
}

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

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

type validateOpUpdateAgent struct {
}

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

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

type validateOpUpdateAgentKnowledgeBase struct {
}

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

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

type validateOpUpdateDataSource struct {
}

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

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

type validateOpUpdateFlowAlias struct {
}

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

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

type validateOpUpdateFlow struct {
}

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

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

type validateOpUpdateKnowledgeBase struct {
}

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

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

type validateOpUpdatePrompt struct {
}

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

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

type validateOpValidateFlowDefinition struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpStopIngestionJobValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStopIngestionJob{}, 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 addOpUpdateAgentActionGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateAgentActionGroup{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

func validateBedrockFoundationModelConfiguration(v *types.BedrockFoundationModelConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BedrockFoundationModelConfiguration"}
	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 validateBedrockFoundationModelContextEnrichmentConfiguration(v *types.BedrockFoundationModelContextEnrichmentConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BedrockFoundationModelContextEnrichmentConfiguration"}
	if v.EnrichmentStrategyConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnrichmentStrategyConfiguration"))
	} else if v.EnrichmentStrategyConfiguration != nil {
		if err := validateEnrichmentStrategyConfiguration(v.EnrichmentStrategyConfiguration); err != nil {
			invalidParams.AddNested("EnrichmentStrategyConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ModelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateByteContentDoc(v *types.ByteContentDoc) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ByteContentDoc"}
	if v.MimeType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MimeType"))
	}
	if v.Data == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Data"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateChatPromptTemplateConfiguration(v *types.ChatPromptTemplateConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChatPromptTemplateConfiguration"}
	if v.Messages == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Messages"))
	} else if v.Messages != nil {
		if err := validateMessages(v.Messages); err != nil {
			invalidParams.AddNested("Messages", err.(smithy.InvalidParamsError))
		}
	}
	if v.System != nil {
		if err := validateSystemContentBlocks(v.System); err != nil {
			invalidParams.AddNested("System", err.(smithy.InvalidParamsError))
		}
	}
	if v.ToolConfiguration != nil {
		if err := validateToolConfiguration(v.ToolConfiguration); err != nil {
			invalidParams.AddNested("ToolConfiguration", 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 validateConditionFlowNodeConfiguration(v *types.ConditionFlowNodeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConditionFlowNodeConfiguration"}
	if v.Conditions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Conditions"))
	} else if v.Conditions != nil {
		if err := validateFlowConditions(v.Conditions); err != nil {
			invalidParams.AddNested("Conditions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConfluenceCrawlerConfiguration(v *types.ConfluenceCrawlerConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConfluenceCrawlerConfiguration"}
	if v.FilterConfiguration != nil {
		if err := validateCrawlFilterConfiguration(v.FilterConfiguration); err != nil {
			invalidParams.AddNested("FilterConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConfluenceDataSourceConfiguration(v *types.ConfluenceDataSourceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConfluenceDataSourceConfiguration"}
	if v.SourceConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceConfiguration"))
	} else if v.SourceConfiguration != nil {
		if err := validateConfluenceSourceConfiguration(v.SourceConfiguration); err != nil {
			invalidParams.AddNested("SourceConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CrawlerConfiguration != nil {
		if err := validateConfluenceCrawlerConfiguration(v.CrawlerConfiguration); err != nil {
			invalidParams.AddNested("CrawlerConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConfluenceSourceConfiguration(v *types.ConfluenceSourceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConfluenceSourceConfiguration"}
	if v.HostUrl == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HostUrl"))
	}
	if len(v.HostType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("HostType"))
	}
	if len(v.AuthType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AuthType"))
	}
	if v.CredentialsSecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CredentialsSecretArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateContentBlock(v types.ContentBlock) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContentBlock"}
	switch uv := v.(type) {
	case *types.ContentBlockMemberCachePoint:
		if err := validateCachePointBlock(&uv.Value); err != nil {
			invalidParams.AddNested("[cachePoint]", err.(smithy.InvalidParamsError))
		}

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

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

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

func validateCrawlFilterConfiguration(v *types.CrawlFilterConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CrawlFilterConfiguration"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.PatternObjectFilter != nil {
		if err := validatePatternObjectFilterConfiguration(v.PatternObjectFilter); err != nil {
			invalidParams.AddNested("PatternObjectFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCuratedQuery(v *types.CuratedQuery) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CuratedQuery"}
	if v.NaturalLanguage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NaturalLanguage"))
	}
	if v.Sql == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Sql"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomContent(v *types.CustomContent) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomContent"}
	if v.CustomDocumentIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CustomDocumentIdentifier"))
	} else if v.CustomDocumentIdentifier != nil {
		if err := validateCustomDocumentIdentifier(v.CustomDocumentIdentifier); err != nil {
			invalidParams.AddNested("CustomDocumentIdentifier", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.SourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SourceType"))
	}
	if v.S3Location != nil {
		if err := validateCustomS3Location(v.S3Location); err != nil {
			invalidParams.AddNested("S3Location", err.(smithy.InvalidParamsError))
		}
	}
	if v.InlineContent != nil {
		if err := validateInlineContent(v.InlineContent); err != nil {
			invalidParams.AddNested("InlineContent", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateCustomTransformationConfiguration(v *types.CustomTransformationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomTransformationConfiguration"}
	if v.IntermediateStorage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntermediateStorage"))
	} else if v.IntermediateStorage != nil {
		if err := validateIntermediateStorage(v.IntermediateStorage); err != nil {
			invalidParams.AddNested("IntermediateStorage", err.(smithy.InvalidParamsError))
		}
	}
	if v.Transformations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Transformations"))
	} else if v.Transformations != nil {
		if err := validateTransformations(v.Transformations); err != nil {
			invalidParams.AddNested("Transformations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDataSourceConfiguration(v *types.DataSourceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataSourceConfiguration"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.S3Configuration != nil {
		if err := validateS3DataSourceConfiguration(v.S3Configuration); err != nil {
			invalidParams.AddNested("S3Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if v.WebConfiguration != nil {
		if err := validateWebDataSourceConfiguration(v.WebConfiguration); err != nil {
			invalidParams.AddNested("WebConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ConfluenceConfiguration != nil {
		if err := validateConfluenceDataSourceConfiguration(v.ConfluenceConfiguration); err != nil {
			invalidParams.AddNested("ConfluenceConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.SalesforceConfiguration != nil {
		if err := validateSalesforceDataSourceConfiguration(v.SalesforceConfiguration); err != nil {
			invalidParams.AddNested("SalesforceConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.SharePointConfiguration != nil {
		if err := validateSharePointDataSourceConfiguration(v.SharePointConfiguration); err != nil {
			invalidParams.AddNested("SharePointConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDocumentContent(v *types.DocumentContent) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DocumentContent"}
	if len(v.DataSourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceType"))
	}
	if v.Custom != nil {
		if err := validateCustomContent(v.Custom); err != nil {
			invalidParams.AddNested("Custom", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3 != nil {
		if err := validateS3Content(v.S3); err != nil {
			invalidParams.AddNested("S3", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDocumentIdentifier(v *types.DocumentIdentifier) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DocumentIdentifier"}
	if len(v.DataSourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceType"))
	}
	if v.S3 != nil {
		if err := validateS3Location(v.S3); err != nil {
			invalidParams.AddNested("S3", err.(smithy.InvalidParamsError))
		}
	}
	if v.Custom != nil {
		if err := validateCustomDocumentIdentifier(v.Custom); err != nil {
			invalidParams.AddNested("Custom", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDocumentMetadata(v *types.DocumentMetadata) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DocumentMetadata"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.InlineAttributes != nil {
		if err := validateMetadataAttributes(v.InlineAttributes); err != nil {
			invalidParams.AddNested("InlineAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3Location != nil {
		if err := validateCustomS3Location(v.S3Location); err != nil {
			invalidParams.AddNested("S3Location", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEnrichmentStrategyConfiguration(v *types.EnrichmentStrategyConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnrichmentStrategyConfiguration"}
	if len(v.Method) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Method"))
	}
	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 validateFlowCondition(v *types.FlowCondition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FlowCondition"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateFlowConnection(v *types.FlowConnection) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FlowConnection"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	}
	if v.Target == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Target"))
	}
	if v.Configuration != nil {
		if err := validateFlowConnectionConfiguration(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFlowConnectionConfiguration(v types.FlowConnectionConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FlowConnectionConfiguration"}
	switch uv := v.(type) {
	case *types.FlowConnectionConfigurationMemberConditional:
		if err := validateFlowConditionalConnectionConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[conditional]", err.(smithy.InvalidParamsError))
		}

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

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

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

func validateFlowDataConnectionConfiguration(v *types.FlowDataConnectionConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FlowDataConnectionConfiguration"}
	if v.SourceOutput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceOutput"))
	}
	if v.TargetInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetInput"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFlowDefinition(v *types.FlowDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FlowDefinition"}
	if v.Nodes != nil {
		if err := validateFlowNodes(v.Nodes); err != nil {
			invalidParams.AddNested("Nodes", err.(smithy.InvalidParamsError))
		}
	}
	if v.Connections != nil {
		if err := validateFlowConnections(v.Connections); err != nil {
			invalidParams.AddNested("Connections", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFlowNode(v *types.FlowNode) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FlowNode"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.Configuration != nil {
		if err := validateFlowNodeConfiguration(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Inputs != nil {
		if err := validateFlowNodeInputs(v.Inputs); err != nil {
			invalidParams.AddNested("Inputs", err.(smithy.InvalidParamsError))
		}
	}
	if v.Outputs != nil {
		if err := validateFlowNodeOutputs(v.Outputs); err != nil {
			invalidParams.AddNested("Outputs", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFlowNodeConfiguration(v types.FlowNodeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FlowNodeConfiguration"}
	switch uv := v.(type) {
	case *types.FlowNodeConfigurationMemberAgent:
		if err := validateAgentFlowNodeConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[agent]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateFunction(v *types.Function) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Function"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Parameters != nil {
		if err := validateParameterMap(v.Parameters); err != nil {
			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateFunctionSchema(v types.FunctionSchema) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FunctionSchema"}
	switch uv := v.(type) {
	case *types.FunctionSchemaMemberFunctions:
		if err := validateFunctions(uv.Value); err != nil {
			invalidParams.AddNested("[functions]", 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 validateIngestionJobFilter(v *types.IngestionJobFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IngestionJobFilter"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if len(v.Operator) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Operator"))
	}
	if v.Values == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Values"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateInlineCodeFlowNodeConfiguration(v *types.InlineCodeFlowNodeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InlineCodeFlowNodeConfiguration"}
	if v.Code == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Code"))
	}
	if len(v.Language) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Language"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInlineContent(v *types.InlineContent) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InlineContent"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.ByteContent != nil {
		if err := validateByteContentDoc(v.ByteContent); err != nil {
			invalidParams.AddNested("ByteContent", err.(smithy.InvalidParamsError))
		}
	}
	if v.TextContent != nil {
		if err := validateTextContentDoc(v.TextContent); err != nil {
			invalidParams.AddNested("TextContent", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateIntermediateStorage(v *types.IntermediateStorage) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IntermediateStorage"}
	if v.S3Location == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3Location"))
	} else if v.S3Location != nil {
		if err := validateS3Location(v.S3Location); err != nil {
			invalidParams.AddNested("S3Location", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateKnowledgeBaseConfiguration(v *types.KnowledgeBaseConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KnowledgeBaseConfiguration"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.VectorKnowledgeBaseConfiguration != nil {
		if err := validateVectorKnowledgeBaseConfiguration(v.VectorKnowledgeBaseConfiguration); err != nil {
			invalidParams.AddNested("VectorKnowledgeBaseConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.KendraKnowledgeBaseConfiguration != nil {
		if err := validateKendraKnowledgeBaseConfiguration(v.KendraKnowledgeBaseConfiguration); err != nil {
			invalidParams.AddNested("KendraKnowledgeBaseConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.SqlKnowledgeBaseConfiguration != nil {
		if err := validateSqlKnowledgeBaseConfiguration(v.SqlKnowledgeBaseConfiguration); err != nil {
			invalidParams.AddNested("SqlKnowledgeBaseConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateKnowledgeBaseDocument(v *types.KnowledgeBaseDocument) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KnowledgeBaseDocument"}
	if v.Metadata != nil {
		if err := validateDocumentMetadata(v.Metadata); err != nil {
			invalidParams.AddNested("Metadata", err.(smithy.InvalidParamsError))
		}
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	} else if v.Content != nil {
		if err := validateDocumentContent(v.Content); err != nil {
			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateLexFlowNodeConfiguration(v *types.LexFlowNodeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LexFlowNodeConfiguration"}
	if v.BotAliasArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BotAliasArn"))
	}
	if v.LocaleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocaleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateMetadataAttribute(v *types.MetadataAttribute) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MetadataAttribute"}
	if v.Key == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Key"))
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	} else if v.Value != nil {
		if err := validateMetadataAttributeValue(v.Value); err != nil {
			invalidParams.AddNested("Value", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateMongoDbAtlasConfiguration(v *types.MongoDbAtlasConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MongoDbAtlasConfiguration"}
	if v.Endpoint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Endpoint"))
	}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.CollectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollectionName"))
	}
	if v.VectorIndexName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VectorIndexName"))
	}
	if v.CredentialsSecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CredentialsSecretArn"))
	}
	if v.FieldMapping == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldMapping"))
	} else if v.FieldMapping != nil {
		if err := validateMongoDbAtlasFieldMapping(v.FieldMapping); err != nil {
			invalidParams.AddNested("FieldMapping", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMongoDbAtlasFieldMapping(v *types.MongoDbAtlasFieldMapping) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MongoDbAtlasFieldMapping"}
	if v.VectorField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VectorField"))
	}
	if v.TextField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextField"))
	}
	if v.MetadataField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetadataField"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNeptuneAnalyticsConfiguration(v *types.NeptuneAnalyticsConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NeptuneAnalyticsConfiguration"}
	if v.GraphArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GraphArn"))
	}
	if v.FieldMapping == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldMapping"))
	} else if v.FieldMapping != nil {
		if err := validateNeptuneAnalyticsFieldMapping(v.FieldMapping); err != nil {
			invalidParams.AddNested("FieldMapping", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNeptuneAnalyticsFieldMapping(v *types.NeptuneAnalyticsFieldMapping) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NeptuneAnalyticsFieldMapping"}
	if v.TextField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextField"))
	}
	if v.MetadataField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetadataField"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpenSearchManagedClusterConfiguration(v *types.OpenSearchManagedClusterConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OpenSearchManagedClusterConfiguration"}
	if v.DomainEndpoint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainEndpoint"))
	}
	if v.DomainArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainArn"))
	}
	if v.VectorIndexName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VectorIndexName"))
	}
	if v.FieldMapping == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldMapping"))
	} else if v.FieldMapping != nil {
		if err := validateOpenSearchManagedClusterFieldMapping(v.FieldMapping); err != nil {
			invalidParams.AddNested("FieldMapping", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpenSearchManagedClusterFieldMapping(v *types.OpenSearchManagedClusterFieldMapping) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OpenSearchManagedClusterFieldMapping"}
	if v.VectorField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VectorField"))
	}
	if v.TextField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextField"))
	}
	if v.MetadataField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetadataField"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpenSearchServerlessConfiguration(v *types.OpenSearchServerlessConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OpenSearchServerlessConfiguration"}
	if v.CollectionArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollectionArn"))
	}
	if v.VectorIndexName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VectorIndexName"))
	}
	if v.FieldMapping == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldMapping"))
	} else if v.FieldMapping != nil {
		if err := validateOpenSearchServerlessFieldMapping(v.FieldMapping); err != nil {
			invalidParams.AddNested("FieldMapping", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpenSearchServerlessFieldMapping(v *types.OpenSearchServerlessFieldMapping) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OpenSearchServerlessFieldMapping"}
	if v.VectorField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VectorField"))
	}
	if v.TextField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextField"))
	}
	if v.MetadataField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetadataField"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateParameterMap(v map[string]types.ParameterDetail) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParameterMap"}
	for key := range v {
		value := v[key]
		if err := validateParameterDetail(&value); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%q]", key), 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 := validateBedrockFoundationModelConfiguration(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 validatePatternObjectFilter(v *types.PatternObjectFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PatternObjectFilter"}
	if v.ObjectType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validatePineconeConfiguration(v *types.PineconeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PineconeConfiguration"}
	if v.ConnectionString == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionString"))
	}
	if v.CredentialsSecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CredentialsSecretArn"))
	}
	if v.FieldMapping == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldMapping"))
	} else if v.FieldMapping != nil {
		if err := validatePineconeFieldMapping(v.FieldMapping); err != nil {
			invalidParams.AddNested("FieldMapping", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePineconeFieldMapping(v *types.PineconeFieldMapping) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PineconeFieldMapping"}
	if v.TextField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextField"))
	}
	if v.MetadataField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetadataField"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validatePromptFlowNodeConfiguration(v *types.PromptFlowNodeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PromptFlowNodeConfiguration"}
	if v.SourceConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceConfiguration"))
	} else if v.SourceConfiguration != nil {
		if err := validatePromptFlowNodeSourceConfiguration(v.SourceConfiguration); err != nil {
			invalidParams.AddNested("SourceConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePromptFlowNodeInlineConfiguration(v *types.PromptFlowNodeInlineConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PromptFlowNodeInlineConfiguration"}
	if len(v.TemplateType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateType"))
	}
	if v.TemplateConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateConfiguration"))
	} else if v.TemplateConfiguration != nil {
		if err := validatePromptTemplateConfiguration(v.TemplateConfiguration); err != nil {
			invalidParams.AddNested("TemplateConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ModelId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validatePromptFlowNodeSourceConfiguration(v types.PromptFlowNodeSourceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PromptFlowNodeSourceConfiguration"}
	switch uv := v.(type) {
	case *types.PromptFlowNodeSourceConfigurationMemberInline:
		if err := validatePromptFlowNodeInlineConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[inline]", err.(smithy.InvalidParamsError))
		}

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

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

func validatePromptGenAiResource(v types.PromptGenAiResource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PromptGenAiResource"}
	switch uv := v.(type) {
	case *types.PromptGenAiResourceMemberAgent:
		if err := validatePromptAgentResource(&uv.Value); err != nil {
			invalidParams.AddNested("[agent]", err.(smithy.InvalidParamsError))
		}

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

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

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

func validatePromptTemplateConfiguration(v types.PromptTemplateConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PromptTemplateConfiguration"}
	switch uv := v.(type) {
	case *types.PromptTemplateConfigurationMemberChat:
		if err := validateChatPromptTemplateConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[chat]", err.(smithy.InvalidParamsError))
		}

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

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

func validatePromptVariant(v *types.PromptVariant) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PromptVariant"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.TemplateType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateType"))
	}
	if v.TemplateConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateConfiguration"))
	} else if v.TemplateConfiguration != nil {
		if err := validatePromptTemplateConfiguration(v.TemplateConfiguration); err != nil {
			invalidParams.AddNested("TemplateConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Metadata != nil {
		if err := validatePromptMetadataList(v.Metadata); err != nil {
			invalidParams.AddNested("Metadata", err.(smithy.InvalidParamsError))
		}
	}
	if v.GenAiResource != nil {
		if err := validatePromptGenAiResource(v.GenAiResource); err != nil {
			invalidParams.AddNested("GenAiResource", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateQueryGenerationConfiguration(v *types.QueryGenerationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QueryGenerationConfiguration"}
	if v.GenerationContext != nil {
		if err := validateQueryGenerationContext(v.GenerationContext); err != nil {
			invalidParams.AddNested("GenerationContext", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateQueryGenerationContext(v *types.QueryGenerationContext) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QueryGenerationContext"}
	if v.Tables != nil {
		if err := validateQueryGenerationTables(v.Tables); err != nil {
			invalidParams.AddNested("Tables", err.(smithy.InvalidParamsError))
		}
	}
	if v.CuratedQueries != nil {
		if err := validateCuratedQueries(v.CuratedQueries); err != nil {
			invalidParams.AddNested("CuratedQueries", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateRdsConfiguration(v *types.RdsConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RdsConfiguration"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if v.CredentialsSecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CredentialsSecretArn"))
	}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.FieldMapping == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldMapping"))
	} else if v.FieldMapping != nil {
		if err := validateRdsFieldMapping(v.FieldMapping); err != nil {
			invalidParams.AddNested("FieldMapping", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRdsFieldMapping(v *types.RdsFieldMapping) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RdsFieldMapping"}
	if v.PrimaryKeyField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrimaryKeyField"))
	}
	if v.VectorField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VectorField"))
	}
	if v.TextField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextField"))
	}
	if v.MetadataField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetadataField"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRedisEnterpriseCloudConfiguration(v *types.RedisEnterpriseCloudConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RedisEnterpriseCloudConfiguration"}
	if v.Endpoint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Endpoint"))
	}
	if v.VectorIndexName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VectorIndexName"))
	}
	if v.CredentialsSecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CredentialsSecretArn"))
	}
	if v.FieldMapping == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldMapping"))
	} else if v.FieldMapping != nil {
		if err := validateRedisEnterpriseCloudFieldMapping(v.FieldMapping); err != nil {
			invalidParams.AddNested("FieldMapping", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRedisEnterpriseCloudFieldMapping(v *types.RedisEnterpriseCloudFieldMapping) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RedisEnterpriseCloudFieldMapping"}
	if v.VectorField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VectorField"))
	}
	if v.TextField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextField"))
	}
	if v.MetadataField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetadataField"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRedshiftConfiguration(v *types.RedshiftConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RedshiftConfiguration"}
	if v.StorageConfigurations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StorageConfigurations"))
	} else if v.StorageConfigurations != nil {
		if err := validateRedshiftQueryEngineStorageConfigurations(v.StorageConfigurations); err != nil {
			invalidParams.AddNested("StorageConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.QueryEngineConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryEngineConfiguration"))
	} else if v.QueryEngineConfiguration != nil {
		if err := validateRedshiftQueryEngineConfiguration(v.QueryEngineConfiguration); err != nil {
			invalidParams.AddNested("QueryEngineConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.QueryGenerationConfiguration != nil {
		if err := validateQueryGenerationConfiguration(v.QueryGenerationConfiguration); err != nil {
			invalidParams.AddNested("QueryGenerationConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRedshiftProvisionedConfiguration(v *types.RedshiftProvisionedConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RedshiftProvisionedConfiguration"}
	if v.ClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
	}
	if v.AuthConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthConfiguration"))
	} else if v.AuthConfiguration != nil {
		if err := validateRedshiftProvisionedAuthConfiguration(v.AuthConfiguration); err != nil {
			invalidParams.AddNested("AuthConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRedshiftQueryEngineConfiguration(v *types.RedshiftQueryEngineConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RedshiftQueryEngineConfiguration"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.ServerlessConfiguration != nil {
		if err := validateRedshiftServerlessConfiguration(v.ServerlessConfiguration); err != nil {
			invalidParams.AddNested("ServerlessConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ProvisionedConfiguration != nil {
		if err := validateRedshiftProvisionedConfiguration(v.ProvisionedConfiguration); err != nil {
			invalidParams.AddNested("ProvisionedConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRedshiftQueryEngineStorageConfiguration(v *types.RedshiftQueryEngineStorageConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RedshiftQueryEngineStorageConfiguration"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.AwsDataCatalogConfiguration != nil {
		if err := validateRedshiftQueryEngineAwsDataCatalogStorageConfiguration(v.AwsDataCatalogConfiguration); err != nil {
			invalidParams.AddNested("AwsDataCatalogConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.RedshiftConfiguration != nil {
		if err := validateRedshiftQueryEngineRedshiftStorageConfiguration(v.RedshiftConfiguration); err != nil {
			invalidParams.AddNested("RedshiftConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateRedshiftServerlessConfiguration(v *types.RedshiftServerlessConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RedshiftServerlessConfiguration"}
	if v.WorkgroupArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkgroupArn"))
	}
	if v.AuthConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthConfiguration"))
	} else if v.AuthConfiguration != nil {
		if err := validateRedshiftServerlessAuthConfiguration(v.AuthConfiguration); err != nil {
			invalidParams.AddNested("AuthConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRetrievalFlowNodeConfiguration(v *types.RetrievalFlowNodeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RetrievalFlowNodeConfiguration"}
	if v.ServiceConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceConfiguration"))
	} else if v.ServiceConfiguration != nil {
		if err := validateRetrievalFlowNodeServiceConfiguration(v.ServiceConfiguration); err != nil {
			invalidParams.AddNested("ServiceConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRetrievalFlowNodeServiceConfiguration(v types.RetrievalFlowNodeServiceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RetrievalFlowNodeServiceConfiguration"}
	switch uv := v.(type) {
	case *types.RetrievalFlowNodeServiceConfigurationMemberS3:
		if err := validateRetrievalFlowNodeS3Configuration(&uv.Value); err != nil {
			invalidParams.AddNested("[s3]", err.(smithy.InvalidParamsError))
		}

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

func validateS3Content(v *types.S3Content) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3Content"}
	if v.S3Location == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3Location"))
	} else if v.S3Location != nil {
		if err := validateS3Location(v.S3Location); err != nil {
			invalidParams.AddNested("S3Location", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateSalesforceCrawlerConfiguration(v *types.SalesforceCrawlerConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SalesforceCrawlerConfiguration"}
	if v.FilterConfiguration != nil {
		if err := validateCrawlFilterConfiguration(v.FilterConfiguration); err != nil {
			invalidParams.AddNested("FilterConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSalesforceDataSourceConfiguration(v *types.SalesforceDataSourceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SalesforceDataSourceConfiguration"}
	if v.SourceConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceConfiguration"))
	} else if v.SourceConfiguration != nil {
		if err := validateSalesforceSourceConfiguration(v.SourceConfiguration); err != nil {
			invalidParams.AddNested("SourceConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CrawlerConfiguration != nil {
		if err := validateSalesforceCrawlerConfiguration(v.CrawlerConfiguration); err != nil {
			invalidParams.AddNested("CrawlerConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSalesforceSourceConfiguration(v *types.SalesforceSourceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SalesforceSourceConfiguration"}
	if v.HostUrl == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HostUrl"))
	}
	if len(v.AuthType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AuthType"))
	}
	if v.CredentialsSecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CredentialsSecretArn"))
	}
	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 validateSharePointCrawlerConfiguration(v *types.SharePointCrawlerConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SharePointCrawlerConfiguration"}
	if v.FilterConfiguration != nil {
		if err := validateCrawlFilterConfiguration(v.FilterConfiguration); err != nil {
			invalidParams.AddNested("FilterConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSharePointDataSourceConfiguration(v *types.SharePointDataSourceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SharePointDataSourceConfiguration"}
	if v.SourceConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceConfiguration"))
	} else if v.SourceConfiguration != nil {
		if err := validateSharePointSourceConfiguration(v.SourceConfiguration); err != nil {
			invalidParams.AddNested("SourceConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CrawlerConfiguration != nil {
		if err := validateSharePointCrawlerConfiguration(v.CrawlerConfiguration); err != nil {
			invalidParams.AddNested("CrawlerConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSharePointSourceConfiguration(v *types.SharePointSourceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SharePointSourceConfiguration"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.SiteUrls == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SiteUrls"))
	}
	if len(v.HostType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("HostType"))
	}
	if len(v.AuthType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AuthType"))
	}
	if v.CredentialsSecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CredentialsSecretArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSqlKnowledgeBaseConfiguration(v *types.SqlKnowledgeBaseConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SqlKnowledgeBaseConfiguration"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.RedshiftConfiguration != nil {
		if err := validateRedshiftConfiguration(v.RedshiftConfiguration); err != nil {
			invalidParams.AddNested("RedshiftConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateStorageConfiguration(v *types.StorageConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StorageConfiguration"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.OpensearchServerlessConfiguration != nil {
		if err := validateOpenSearchServerlessConfiguration(v.OpensearchServerlessConfiguration); err != nil {
			invalidParams.AddNested("OpensearchServerlessConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.OpensearchManagedClusterConfiguration != nil {
		if err := validateOpenSearchManagedClusterConfiguration(v.OpensearchManagedClusterConfiguration); err != nil {
			invalidParams.AddNested("OpensearchManagedClusterConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.PineconeConfiguration != nil {
		if err := validatePineconeConfiguration(v.PineconeConfiguration); err != nil {
			invalidParams.AddNested("PineconeConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.RedisEnterpriseCloudConfiguration != nil {
		if err := validateRedisEnterpriseCloudConfiguration(v.RedisEnterpriseCloudConfiguration); err != nil {
			invalidParams.AddNested("RedisEnterpriseCloudConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.RdsConfiguration != nil {
		if err := validateRdsConfiguration(v.RdsConfiguration); err != nil {
			invalidParams.AddNested("RdsConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.MongoDbAtlasConfiguration != nil {
		if err := validateMongoDbAtlasConfiguration(v.MongoDbAtlasConfiguration); err != nil {
			invalidParams.AddNested("MongoDbAtlasConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.NeptuneAnalyticsConfiguration != nil {
		if err := validateNeptuneAnalyticsConfiguration(v.NeptuneAnalyticsConfiguration); err != nil {
			invalidParams.AddNested("NeptuneAnalyticsConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateStorageFlowNodeConfiguration(v *types.StorageFlowNodeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StorageFlowNodeConfiguration"}
	if v.ServiceConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceConfiguration"))
	} else if v.ServiceConfiguration != nil {
		if err := validateStorageFlowNodeServiceConfiguration(v.ServiceConfiguration); err != nil {
			invalidParams.AddNested("ServiceConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateStorageFlowNodeServiceConfiguration(v types.StorageFlowNodeServiceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StorageFlowNodeServiceConfiguration"}
	switch uv := v.(type) {
	case *types.StorageFlowNodeServiceConfigurationMemberS3:
		if err := validateStorageFlowNodeS3Configuration(&uv.Value); err != nil {
			invalidParams.AddNested("[s3]", err.(smithy.InvalidParamsError))
		}

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

func validateSupplementalDataStorageConfiguration(v *types.SupplementalDataStorageConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SupplementalDataStorageConfiguration"}
	if v.StorageLocations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StorageLocations"))
	} else if v.StorageLocations != nil {
		if err := validateSupplementalDataStorageLocations(v.StorageLocations); err != nil {
			invalidParams.AddNested("StorageLocations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSupplementalDataStorageLocation(v *types.SupplementalDataStorageLocation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SupplementalDataStorageLocation"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.S3Location != nil {
		if err := validateS3Location(v.S3Location); err != nil {
			invalidParams.AddNested("S3Location", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSystemContentBlock(v types.SystemContentBlock) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SystemContentBlock"}
	switch uv := v.(type) {
	case *types.SystemContentBlockMemberCachePoint:
		if err := validateCachePointBlock(&uv.Value); err != nil {
			invalidParams.AddNested("[cachePoint]", err.(smithy.InvalidParamsError))
		}

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

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

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

func validateTextPromptTemplateConfiguration(v *types.TextPromptTemplateConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TextPromptTemplateConfiguration"}
	if v.Text == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Text"))
	}
	if v.CachePoint != nil {
		if err := validateCachePointBlock(v.CachePoint); err != nil {
			invalidParams.AddNested("CachePoint", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTool(v types.Tool) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Tool"}
	switch uv := v.(type) {
	case *types.ToolMemberCachePoint:
		if err := validateCachePointBlock(&uv.Value); err != nil {
			invalidParams.AddNested("[cachePoint]", err.(smithy.InvalidParamsError))
		}

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

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

func validateToolChoice(v types.ToolChoice) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ToolChoice"}
	switch uv := v.(type) {
	case *types.ToolChoiceMemberTool:
		if err := validateSpecificToolChoice(&uv.Value); err != nil {
			invalidParams.AddNested("[tool]", err.(smithy.InvalidParamsError))
		}

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

func validateToolConfiguration(v *types.ToolConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ToolConfiguration"}
	if v.Tools == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tools"))
	} else if v.Tools != nil {
		if err := validateTools(v.Tools); err != nil {
			invalidParams.AddNested("Tools", err.(smithy.InvalidParamsError))
		}
	}
	if v.ToolChoice != nil {
		if err := validateToolChoice(v.ToolChoice); err != nil {
			invalidParams.AddNested("ToolChoice", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateTransformation(v *types.Transformation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Transformation"}
	if v.TransformationFunction == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransformationFunction"))
	} else if v.TransformationFunction != nil {
		if err := validateTransformationFunction(v.TransformationFunction); err != nil {
			invalidParams.AddNested("TransformationFunction", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.StepToApply) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("StepToApply"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTransformationFunction(v *types.TransformationFunction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TransformationFunction"}
	if v.TransformationLambdaConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransformationLambdaConfiguration"))
	} else if v.TransformationLambdaConfiguration != nil {
		if err := validateTransformationLambdaConfiguration(v.TransformationLambdaConfiguration); err != nil {
			invalidParams.AddNested("TransformationLambdaConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTransformations(v []types.Transformation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Transformations"}
	for i := range v {
		if err := validateTransformation(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	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.CustomTransformationConfiguration != nil {
		if err := validateCustomTransformationConfiguration(v.CustomTransformationConfiguration); err != nil {
			invalidParams.AddNested("CustomTransformationConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ParsingConfiguration != nil {
		if err := validateParsingConfiguration(v.ParsingConfiguration); err != nil {
			invalidParams.AddNested("ParsingConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContextEnrichmentConfiguration != nil {
		if err := validateContextEnrichmentConfiguration(v.ContextEnrichmentConfiguration); err != nil {
			invalidParams.AddNested("ContextEnrichmentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateVectorKnowledgeBaseConfiguration(v *types.VectorKnowledgeBaseConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VectorKnowledgeBaseConfiguration"}
	if v.EmbeddingModelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EmbeddingModelArn"))
	}
	if v.SupplementalDataStorageConfiguration != nil {
		if err := validateSupplementalDataStorageConfiguration(v.SupplementalDataStorageConfiguration); err != nil {
			invalidParams.AddNested("SupplementalDataStorageConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWebDataSourceConfiguration(v *types.WebDataSourceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WebDataSourceConfiguration"}
	if v.SourceConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceConfiguration"))
	} else if v.SourceConfiguration != nil {
		if err := validateWebSourceConfiguration(v.SourceConfiguration); err != nil {
			invalidParams.AddNested("SourceConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpAssociateAgentCollaboratorInput(v *AssociateAgentCollaboratorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateAgentCollaboratorInput"}
	if v.AgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentId"))
	}
	if v.AgentVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentVersion"))
	}
	if v.AgentDescriptor == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentDescriptor"))
	}
	if v.CollaboratorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaboratorName"))
	}
	if v.CollaborationInstruction == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaborationInstruction"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateAgentKnowledgeBaseInput(v *AssociateAgentKnowledgeBaseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateAgentKnowledgeBaseInput"}
	if v.AgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentId"))
	}
	if v.AgentVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentVersion"))
	}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.Description == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Description"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAgentActionGroupInput(v *CreateAgentActionGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAgentActionGroupInput"}
	if v.AgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentId"))
	}
	if v.AgentVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentVersion"))
	}
	if v.ActionGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActionGroupName"))
	}
	if v.FunctionSchema != nil {
		if err := validateFunctionSchema(v.FunctionSchema); err != nil {
			invalidParams.AddNested("FunctionSchema", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAgentAliasInput(v *CreateAgentAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAgentAliasInput"}
	if v.AgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentId"))
	}
	if v.AgentAliasName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentAliasName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAgentInput(v *CreateAgentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAgentInput"}
	if v.AgentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentName"))
	}
	if v.PromptOverrideConfiguration != nil {
		if err := validatePromptOverrideConfiguration(v.PromptOverrideConfiguration); err != nil {
			invalidParams.AddNested("PromptOverrideConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.MemoryConfiguration != nil {
		if err := validateMemoryConfiguration(v.MemoryConfiguration); err != nil {
			invalidParams.AddNested("MemoryConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDataSourceInput(v *CreateDataSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDataSourceInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.DataSourceConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceConfiguration"))
	} else if v.DataSourceConfiguration != nil {
		if err := validateDataSourceConfiguration(v.DataSourceConfiguration); err != nil {
			invalidParams.AddNested("DataSourceConfiguration", 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 validateOpCreateFlowAliasInput(v *CreateFlowAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFlowAliasInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.RoutingConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoutingConfiguration"))
	}
	if v.FlowIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFlowInput(v *CreateFlowInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFlowInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ExecutionRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExecutionRoleArn"))
	}
	if v.Definition != nil {
		if err := validateFlowDefinition(v.Definition); err != nil {
			invalidParams.AddNested("Definition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFlowVersionInput(v *CreateFlowVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFlowVersionInput"}
	if v.FlowIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowIdentifier"))
	}
	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 v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.KnowledgeBaseConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseConfiguration"))
	} else if v.KnowledgeBaseConfiguration != nil {
		if err := validateKnowledgeBaseConfiguration(v.KnowledgeBaseConfiguration); err != nil {
			invalidParams.AddNested("KnowledgeBaseConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.StorageConfiguration != nil {
		if err := validateStorageConfiguration(v.StorageConfiguration); err != nil {
			invalidParams.AddNested("StorageConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePromptInput(v *CreatePromptInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePromptInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Variants != nil {
		if err := validatePromptVariantList(v.Variants); err != nil {
			invalidParams.AddNested("Variants", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteAgentActionGroupInput(v *DeleteAgentActionGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAgentActionGroupInput"}
	if v.AgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentId"))
	}
	if v.AgentVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentVersion"))
	}
	if v.ActionGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActionGroupId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteAgentAliasInput(v *DeleteAgentAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAgentAliasInput"}
	if v.AgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentId"))
	}
	if v.AgentAliasId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentAliasId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteAgentVersionInput(v *DeleteAgentVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAgentVersionInput"}
	if v.AgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentId"))
	}
	if v.AgentVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteFlowAliasInput(v *DeleteFlowAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteFlowAliasInput"}
	if v.FlowIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowIdentifier"))
	}
	if v.AliasIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AliasIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteFlowVersionInput(v *DeleteFlowVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteFlowVersionInput"}
	if v.FlowIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowIdentifier"))
	}
	if v.FlowVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteKnowledgeBaseDocumentsInput(v *DeleteKnowledgeBaseDocumentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteKnowledgeBaseDocumentsInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.DataSourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
	}
	if v.DocumentIdentifiers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentIdentifiers"))
	} else if v.DocumentIdentifiers != nil {
		if err := validateDocumentIdentifiers(v.DocumentIdentifiers); err != nil {
			invalidParams.AddNested("DocumentIdentifiers", err.(smithy.InvalidParamsError))
		}
	}
	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 validateOpDeletePromptInput(v *DeletePromptInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeletePromptInput"}
	if v.PromptIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PromptIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateAgentCollaboratorInput(v *DisassociateAgentCollaboratorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateAgentCollaboratorInput"}
	if v.AgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentId"))
	}
	if v.AgentVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentVersion"))
	}
	if v.CollaboratorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaboratorId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetAgentActionGroupInput(v *GetAgentActionGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAgentActionGroupInput"}
	if v.AgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentId"))
	}
	if v.AgentVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentVersion"))
	}
	if v.ActionGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActionGroupId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAgentAliasInput(v *GetAgentAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAgentAliasInput"}
	if v.AgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentId"))
	}
	if v.AgentAliasId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentAliasId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAgentCollaboratorInput(v *GetAgentCollaboratorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAgentCollaboratorInput"}
	if v.AgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentId"))
	}
	if v.AgentVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentVersion"))
	}
	if v.CollaboratorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaboratorId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpGetAgentVersionInput(v *GetAgentVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAgentVersionInput"}
	if v.AgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentId"))
	}
	if v.AgentVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetFlowAliasInput(v *GetFlowAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetFlowAliasInput"}
	if v.FlowIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowIdentifier"))
	}
	if v.AliasIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AliasIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetFlowVersionInput(v *GetFlowVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetFlowVersionInput"}
	if v.FlowIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowIdentifier"))
	}
	if v.FlowVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetKnowledgeBaseDocumentsInput(v *GetKnowledgeBaseDocumentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetKnowledgeBaseDocumentsInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.DataSourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
	}
	if v.DocumentIdentifiers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentIdentifiers"))
	} else if v.DocumentIdentifiers != nil {
		if err := validateDocumentIdentifiers(v.DocumentIdentifiers); err != nil {
			invalidParams.AddNested("DocumentIdentifiers", err.(smithy.InvalidParamsError))
		}
	}
	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 validateOpGetPromptInput(v *GetPromptInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPromptInput"}
	if v.PromptIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PromptIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpIngestKnowledgeBaseDocumentsInput(v *IngestKnowledgeBaseDocumentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IngestKnowledgeBaseDocumentsInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.DataSourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
	}
	if v.Documents == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Documents"))
	} else if v.Documents != nil {
		if err := validateKnowledgeBaseDocuments(v.Documents); err != nil {
			invalidParams.AddNested("Documents", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListAgentActionGroupsInput(v *ListAgentActionGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAgentActionGroupsInput"}
	if v.AgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentId"))
	}
	if v.AgentVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListAgentCollaboratorsInput(v *ListAgentCollaboratorsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAgentCollaboratorsInput"}
	if v.AgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentId"))
	}
	if v.AgentVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListAgentKnowledgeBasesInput(v *ListAgentKnowledgeBasesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAgentKnowledgeBasesInput"}
	if v.AgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentId"))
	}
	if v.AgentVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpListIngestionJobsInput(v *ListIngestionJobsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListIngestionJobsInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.DataSourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
	}
	if v.Filters != nil {
		if err := validateIngestionJobFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortBy != nil {
		if err := validateIngestionJobSortBy(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListKnowledgeBaseDocumentsInput(v *ListKnowledgeBaseDocumentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListKnowledgeBaseDocumentsInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.DataSourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
	}
	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 validateOpPrepareAgentInput(v *PrepareAgentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PrepareAgentInput"}
	if v.AgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpStopIngestionJobInput(v *StopIngestionJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopIngestionJobInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.DataSourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
	}
	if v.IngestionJobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IngestionJobId"))
	}
	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 validateOpUpdateAgentActionGroupInput(v *UpdateAgentActionGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAgentActionGroupInput"}
	if v.AgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentId"))
	}
	if v.AgentVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentVersion"))
	}
	if v.ActionGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActionGroupId"))
	}
	if v.ActionGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActionGroupName"))
	}
	if v.FunctionSchema != nil {
		if err := validateFunctionSchema(v.FunctionSchema); err != nil {
			invalidParams.AddNested("FunctionSchema", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAgentAliasInput(v *UpdateAgentAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAgentAliasInput"}
	if v.AgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentId"))
	}
	if v.AgentAliasId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentAliasId"))
	}
	if v.AgentAliasName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentAliasName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAgentCollaboratorInput(v *UpdateAgentCollaboratorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAgentCollaboratorInput"}
	if v.AgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentId"))
	}
	if v.AgentVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentVersion"))
	}
	if v.CollaboratorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaboratorId"))
	}
	if v.AgentDescriptor == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentDescriptor"))
	}
	if v.CollaboratorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaboratorName"))
	}
	if v.CollaborationInstruction == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaborationInstruction"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAgentInput(v *UpdateAgentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAgentInput"}
	if v.AgentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentId"))
	}
	if v.AgentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentName"))
	}
	if v.FoundationModel == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FoundationModel"))
	}
	if v.AgentResourceRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentResourceRoleArn"))
	}
	if v.PromptOverrideConfiguration != nil {
		if err := validatePromptOverrideConfiguration(v.PromptOverrideConfiguration); err != nil {
			invalidParams.AddNested("PromptOverrideConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.MemoryConfiguration != nil {
		if err := validateMemoryConfiguration(v.MemoryConfiguration); err != nil {
			invalidParams.AddNested("MemoryConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateDataSourceInput(v *UpdateDataSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDataSourceInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.DataSourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.DataSourceConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceConfiguration"))
	} else if v.DataSourceConfiguration != nil {
		if err := validateDataSourceConfiguration(v.DataSourceConfiguration); err != nil {
			invalidParams.AddNested("DataSourceConfiguration", 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 validateOpUpdateFlowAliasInput(v *UpdateFlowAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFlowAliasInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.RoutingConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoutingConfiguration"))
	}
	if v.FlowIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowIdentifier"))
	}
	if v.AliasIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AliasIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateFlowInput(v *UpdateFlowInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFlowInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ExecutionRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExecutionRoleArn"))
	}
	if v.Definition != nil {
		if err := validateFlowDefinition(v.Definition); err != nil {
			invalidParams.AddNested("Definition", err.(smithy.InvalidParamsError))
		}
	}
	if v.FlowIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateKnowledgeBaseInput(v *UpdateKnowledgeBaseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateKnowledgeBaseInput"}
	if v.KnowledgeBaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.KnowledgeBaseConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KnowledgeBaseConfiguration"))
	} else if v.KnowledgeBaseConfiguration != nil {
		if err := validateKnowledgeBaseConfiguration(v.KnowledgeBaseConfiguration); err != nil {
			invalidParams.AddNested("KnowledgeBaseConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.StorageConfiguration != nil {
		if err := validateStorageConfiguration(v.StorageConfiguration); err != nil {
			invalidParams.AddNested("StorageConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdatePromptInput(v *UpdatePromptInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePromptInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Variants != nil {
		if err := validatePromptVariantList(v.Variants); err != nil {
			invalidParams.AddNested("Variants", err.(smithy.InvalidParamsError))
		}
	}
	if v.PromptIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PromptIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpValidateFlowDefinitionInput(v *ValidateFlowDefinitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ValidateFlowDefinitionInput"}
	if v.Definition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Definition"))
	} else if v.Definition != nil {
		if err := validateFlowDefinition(v.Definition); err != nil {
			invalidParams.AddNested("Definition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}