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

package bedrockruntime

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

type validateOpApplyGuardrail struct {
}

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

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

type validateOpConverse struct {
}

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

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

type validateOpConverseStream struct {
}

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

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

type validateOpCountTokens struct {
}

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

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

type validateOpGetAsyncInvoke struct {
}

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

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

type validateOpInvokeModel struct {
}

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

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

type validateOpInvokeModelWithBidirectionalStream struct {
}

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

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

type validateOpInvokeModelWithResponseStream struct {
}

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

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

type validateOpStartAsyncInvoke struct {
}

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

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

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

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

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

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

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

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

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

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

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

func validateAsyncInvokeOutputDataConfig(v types.AsyncInvokeOutputDataConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AsyncInvokeOutputDataConfig"}
	switch uv := v.(type) {
	case *types.AsyncInvokeOutputDataConfigMemberS3OutputDataConfig:
		if err := validateAsyncInvokeS3OutputDataConfig(&uv.Value); err != nil {
			invalidParams.AddNested("[s3OutputDataConfig]", err.(smithy.InvalidParamsError))
		}

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

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

func validateAudioBlock(v *types.AudioBlock) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AudioBlock"}
	if len(v.Format) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Format"))
	}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	} else if v.Source != nil {
		if err := validateAudioSource(v.Source); err != nil {
			invalidParams.AddNested("Source", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAudioSource(v types.AudioSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AudioSource"}
	switch uv := v.(type) {
	case *types.AudioSourceMemberS3Location:
		if err := validateS3Location(&uv.Value); err != nil {
			invalidParams.AddNested("[s3Location]", err.(smithy.InvalidParamsError))
		}

	}
	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 validateCitationsConfig(v *types.CitationsConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CitationsConfig"}
	if v.Enabled == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Enabled"))
	}
	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.ContentBlockMemberAudio:
		if err := validateAudioBlock(&uv.Value); err != nil {
			invalidParams.AddNested("[audio]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

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

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

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

	case *types.ContentBlockMemberVideo:
		if err := validateVideoBlock(&uv.Value); err != nil {
			invalidParams.AddNested("[video]", 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 validateConverseTokensRequest(v *types.ConverseTokensRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConverseTokensRequest"}
	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.ToolConfig != nil {
		if err := validateToolConfiguration(v.ToolConfig); err != nil {
			invalidParams.AddNested("ToolConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCountTokensInput(v types.CountTokensInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CountTokensInput"}
	switch uv := v.(type) {
	case *types.CountTokensInputMemberConverse:
		if err := validateConverseTokensRequest(&uv.Value); err != nil {
			invalidParams.AddNested("[converse]", err.(smithy.InvalidParamsError))
		}

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

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

func validateDocumentBlock(v *types.DocumentBlock) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DocumentBlock"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	} else if v.Source != nil {
		if err := validateDocumentSource(v.Source); err != nil {
			invalidParams.AddNested("Source", err.(smithy.InvalidParamsError))
		}
	}
	if v.Citations != nil {
		if err := validateCitationsConfig(v.Citations); err != nil {
			invalidParams.AddNested("Citations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDocumentSource(v types.DocumentSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DocumentSource"}
	switch uv := v.(type) {
	case *types.DocumentSourceMemberS3Location:
		if err := validateS3Location(&uv.Value); err != nil {
			invalidParams.AddNested("[s3Location]", err.(smithy.InvalidParamsError))
		}

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

func validateGuardrailContentBlock(v types.GuardrailContentBlock) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GuardrailContentBlock"}
	switch uv := v.(type) {
	case *types.GuardrailContentBlockMemberImage:
		if err := validateGuardrailImageBlock(&uv.Value); err != nil {
			invalidParams.AddNested("[image]", err.(smithy.InvalidParamsError))
		}

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

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

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

func validateGuardrailConverseContentBlock(v types.GuardrailConverseContentBlock) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GuardrailConverseContentBlock"}
	switch uv := v.(type) {
	case *types.GuardrailConverseContentBlockMemberImage:
		if err := validateGuardrailConverseImageBlock(&uv.Value); err != nil {
			invalidParams.AddNested("[image]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

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

func validateImageBlock(v *types.ImageBlock) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImageBlock"}
	if len(v.Format) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Format"))
	}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	} else if v.Source != nil {
		if err := validateImageSource(v.Source); err != nil {
			invalidParams.AddNested("Source", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateImageSource(v types.ImageSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImageSource"}
	switch uv := v.(type) {
	case *types.ImageSourceMemberS3Location:
		if err := validateS3Location(&uv.Value); err != nil {
			invalidParams.AddNested("[s3Location]", err.(smithy.InvalidParamsError))
		}

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

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

func validateJsonSchemaDefinition(v *types.JsonSchemaDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "JsonSchemaDefinition"}
	if v.Schema == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Schema"))
	}
	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 validateOutputConfig(v *types.OutputConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OutputConfig"}
	if v.TextFormat != nil {
		if err := validateOutputFormat(v.TextFormat); err != nil {
			invalidParams.AddNested("TextFormat", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOutputFormatStructure(v types.OutputFormatStructure) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OutputFormatStructure"}
	switch uv := v.(type) {
	case *types.OutputFormatStructureMemberJsonSchema:
		if err := validateJsonSchemaDefinition(&uv.Value); err != nil {
			invalidParams.AddNested("[jsonSchema]", err.(smithy.InvalidParamsError))
		}

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

func validateReasoningContentBlock(v types.ReasoningContentBlock) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReasoningContentBlock"}
	switch uv := v.(type) {
	case *types.ReasoningContentBlockMemberReasoningText:
		if err := validateReasoningTextBlock(&uv.Value); err != nil {
			invalidParams.AddNested("[reasoningText]", err.(smithy.InvalidParamsError))
		}

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

func validateReasoningTextBlock(v *types.ReasoningTextBlock) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReasoningTextBlock"}
	if v.Text == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Text"))
	}
	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 validateSearchResultBlock(v *types.SearchResultBlock) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchResultBlock"}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	} else if v.Content != nil {
		if err := validateSearchResultContentBlocks(v.Content); err != nil {
			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
		}
	}
	if v.Citations != nil {
		if err := validateCitationsConfig(v.Citations); err != nil {
			invalidParams.AddNested("Citations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateServiceTier(v *types.ServiceTier) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ServiceTier"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	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 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))
		}

	case *types.SystemContentBlockMemberGuardContent:
		if err := validateGuardrailConverseContentBlock(uv.Value); err != nil {
			invalidParams.AddNested("[guardContent]", 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 validateSystemTool(v *types.SystemTool) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SystemTool"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func 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.ToolMemberSystemTool:
		if err := validateSystemTool(&uv.Value); err != nil {
			invalidParams.AddNested("[systemTool]", 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 validateToolResultBlock(v *types.ToolResultBlock) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ToolResultBlock"}
	if v.ToolUseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ToolUseId"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	} else if v.Content != nil {
		if err := validateToolResultContentBlocks(v.Content); err != nil {
			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateToolResultContentBlock(v types.ToolResultContentBlock) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ToolResultContentBlock"}
	switch uv := v.(type) {
	case *types.ToolResultContentBlockMemberDocument:
		if err := validateDocumentBlock(&uv.Value); err != nil {
			invalidParams.AddNested("[document]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

func validateToolResultContentBlocks(v []types.ToolResultContentBlock) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ToolResultContentBlocks"}
	for i := range v {
		if err := validateToolResultContentBlock(v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), 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 validateToolUseBlock(v *types.ToolUseBlock) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ToolUseBlock"}
	if v.ToolUseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ToolUseId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Input == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Input"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateVideoBlock(v *types.VideoBlock) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VideoBlock"}
	if len(v.Format) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Format"))
	}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	} else if v.Source != nil {
		if err := validateVideoSource(v.Source); err != nil {
			invalidParams.AddNested("Source", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateVideoSource(v types.VideoSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VideoSource"}
	switch uv := v.(type) {
	case *types.VideoSourceMemberS3Location:
		if err := validateS3Location(&uv.Value); err != nil {
			invalidParams.AddNested("[s3Location]", err.(smithy.InvalidParamsError))
		}

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

func validateOpApplyGuardrailInput(v *ApplyGuardrailInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ApplyGuardrailInput"}
	if v.GuardrailIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GuardrailIdentifier"))
	}
	if v.GuardrailVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GuardrailVersion"))
	}
	if len(v.Source) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	} else if v.Content != nil {
		if err := validateGuardrailContentBlockList(v.Content); err != nil {
			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpConverseInput(v *ConverseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConverseInput"}
	if v.ModelId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelId"))
	}
	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.ToolConfig != nil {
		if err := validateToolConfiguration(v.ToolConfig); err != nil {
			invalidParams.AddNested("ToolConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ServiceTier != nil {
		if err := validateServiceTier(v.ServiceTier); err != nil {
			invalidParams.AddNested("ServiceTier", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputConfig != nil {
		if err := validateOutputConfig(v.OutputConfig); err != nil {
			invalidParams.AddNested("OutputConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpConverseStreamInput(v *ConverseStreamInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConverseStreamInput"}
	if v.ModelId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelId"))
	}
	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.ToolConfig != nil {
		if err := validateToolConfiguration(v.ToolConfig); err != nil {
			invalidParams.AddNested("ToolConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ServiceTier != nil {
		if err := validateServiceTier(v.ServiceTier); err != nil {
			invalidParams.AddNested("ServiceTier", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputConfig != nil {
		if err := validateOutputConfig(v.OutputConfig); err != nil {
			invalidParams.AddNested("OutputConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCountTokensInput(v *CountTokensInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CountTokensInput"}
	if v.ModelId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelId"))
	}
	if v.Input == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Input"))
	} else if v.Input != nil {
		if err := validateCountTokensInput(v.Input); err != nil {
			invalidParams.AddNested("Input", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpStartAsyncInvokeInput(v *StartAsyncInvokeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartAsyncInvokeInput"}
	if v.ModelId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelId"))
	}
	if v.ModelInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelInput"))
	}
	if v.OutputDataConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputDataConfig"))
	} else if v.OutputDataConfig != nil {
		if err := validateAsyncInvokeOutputDataConfig(v.OutputDataConfig); err != nil {
			invalidParams.AddNested("OutputDataConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}