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

package bedrockagentcore

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

type validateOpBatchCreateMemoryRecords struct {
}

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

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

type validateOpBatchDeleteMemoryRecords struct {
}

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

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

type validateOpBatchUpdateMemoryRecords struct {
}

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

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

type validateOpCompleteResourceTokenAuth struct {
}

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

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

type validateOpCreateABTest struct {
}

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

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

type validateOpCreateEvent struct {
}

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

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

type validateOpCreatePaymentInstrument struct {
}

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

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

type validateOpCreatePaymentSession struct {
}

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

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

type validateOpDeleteABTest struct {
}

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

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

type validateOpDeleteBatchEvaluation struct {
}

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

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

type validateOpDeleteEvent struct {
}

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

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

type validateOpDeleteMemoryRecord struct {
}

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

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

type validateOpDeletePaymentInstrument struct {
}

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

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

type validateOpDeletePaymentSession struct {
}

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

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

type validateOpDeleteRecommendation struct {
}

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

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

type validateOpEvaluate struct {
}

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

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

type validateOpGetABTest struct {
}

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

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

type validateOpGetAgentCard struct {
}

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

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

type validateOpGetBatchEvaluation struct {
}

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

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

type validateOpGetBrowserSession struct {
}

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

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

type validateOpGetCodeInterpreterSession struct {
}

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

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

type validateOpGetEvent struct {
}

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

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

type validateOpGetMemoryRecord struct {
}

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

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

type validateOpGetPaymentInstrumentBalance struct {
}

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

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

type validateOpGetPaymentInstrument struct {
}

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

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

type validateOpGetPaymentSession struct {
}

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

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

type validateOpGetRecommendation struct {
}

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

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

type validateOpGetResourceApiKey struct {
}

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

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

type validateOpGetResourceOauth2Token struct {
}

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

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

type validateOpGetResourcePaymentToken struct {
}

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

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

type validateOpGetWorkloadAccessTokenForJWT struct {
}

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

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

type validateOpGetWorkloadAccessTokenForUserId struct {
}

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

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

type validateOpGetWorkloadAccessToken struct {
}

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

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

type validateOpInvokeAgentRuntimeCommand struct {
}

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

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

type validateOpInvokeAgentRuntime struct {
}

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

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

type validateOpInvokeBrowser struct {
}

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

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

type validateOpInvokeCodeInterpreter struct {
}

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

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

type validateOpInvokeHarness struct {
}

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

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

type validateOpListActors struct {
}

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

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

type validateOpListBrowserSessions struct {
}

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

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

type validateOpListCodeInterpreterSessions struct {
}

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

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

type validateOpListEvents struct {
}

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

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

type validateOpListMemoryExtractionJobs struct {
}

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

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

type validateOpListMemoryRecords struct {
}

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

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

type validateOpListPaymentInstruments struct {
}

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

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

type validateOpListPaymentSessions struct {
}

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

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

type validateOpListSessions struct {
}

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

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

type validateOpProcessPayment struct {
}

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

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

type validateOpRetrieveMemoryRecords struct {
}

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

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

type validateOpSaveBrowserSessionProfile struct {
}

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

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

type validateOpSearchRegistryRecords struct {
}

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

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

type validateOpStartBatchEvaluation struct {
}

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

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

type validateOpStartBrowserSession struct {
}

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

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

type validateOpStartCodeInterpreterSession struct {
}

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

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

type validateOpStartMemoryExtractionJob struct {
}

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

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

type validateOpStartRecommendation struct {
}

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

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

type validateOpStopBatchEvaluation struct {
}

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

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

type validateOpStopBrowserSession struct {
}

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

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

type validateOpStopCodeInterpreterSession struct {
}

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

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

type validateOpStopRuntimeSession struct {
}

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

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

type validateOpUpdateABTest struct {
}

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

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

type validateOpUpdateBrowserStream struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateABTestEvaluationConfig(v types.ABTestEvaluationConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ABTestEvaluationConfig"}
	switch uv := v.(type) {
	case *types.ABTestEvaluationConfigMemberPerVariantOnlineEvaluationConfig:
		if err := validatePerVariantOnlineEvaluationConfigList(uv.Value); err != nil {
			invalidParams.AddNested("[perVariantOnlineEvaluationConfig]", err.(smithy.InvalidParamsError))
		}

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

func validateAgentTracesConfig(v types.AgentTracesConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AgentTracesConfig"}
	switch uv := v.(type) {
	case *types.AgentTracesConfigMemberBatchEvaluation:
		if err := validateBatchEvaluationTraceConfig(&uv.Value); err != nil {
			invalidParams.AddNested("[batchEvaluation]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

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

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

func validateBrowserAction(v types.BrowserAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BrowserAction"}
	switch uv := v.(type) {
	case *types.BrowserActionMemberKeyPress:
		if err := validateKeyPressArguments(&uv.Value); err != nil {
			invalidParams.AddNested("[keyPress]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

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

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

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

func validateBrowserEnterprisePolicy(v *types.BrowserEnterprisePolicy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BrowserEnterprisePolicy"}
	if v.Location == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Location"))
	} else if v.Location != nil {
		if err := validateResourceLocation(v.Location); err != nil {
			invalidParams.AddNested("Location", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBrowserExtension(v *types.BrowserExtension) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BrowserExtension"}
	if v.Location == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Location"))
	} else if v.Location != nil {
		if err := validateResourceLocation(v.Location); err != nil {
			invalidParams.AddNested("Location", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateCertificate(v *types.Certificate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Certificate"}
	if v.Location == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Location"))
	} else if v.Location != nil {
		if err := validateCertificateLocation(v.Location); err != nil {
			invalidParams.AddNested("Location", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCertificateLocation(v types.CertificateLocation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CertificateLocation"}
	switch uv := v.(type) {
	case *types.CertificateLocationMemberSecretsManager:
		if err := validateSecretsManagerLocation(&uv.Value); err != nil {
			invalidParams.AddNested("[secretsManager]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

func validateCloudWatchLogsRule(v *types.CloudWatchLogsRule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CloudWatchLogsRule"}
	if v.Filters != nil {
		if err := validateCloudWatchLogsFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCloudWatchLogsSource(v *types.CloudWatchLogsSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CloudWatchLogsSource"}
	if v.ServiceNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceNames"))
	}
	if v.LogGroupNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LogGroupNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCloudWatchLogsTraceConfig(v *types.CloudWatchLogsTraceConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CloudWatchLogsTraceConfig"}
	if v.LogGroupArns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LogGroupArns"))
	}
	if v.ServiceNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceNames"))
	}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if v.Rule != nil {
		if err := validateCloudWatchLogsRule(v.Rule); err != nil {
			invalidParams.AddNested("Rule", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCoinbaseCdpTokenRequestInput(v *types.CoinbaseCdpTokenRequestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CoinbaseCdpTokenRequestInput"}
	if len(v.RequestMethod) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RequestMethod"))
	}
	if v.RequestPath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequestPath"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConfigurationBundleRef(v *types.ConfigurationBundleRef) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConfigurationBundleRef"}
	if v.BundleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BundleArn"))
	}
	if v.BundleVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BundleVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConfigurationBundleToolEntry(v *types.ConfigurationBundleToolEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConfigurationBundleToolEntry"}
	if v.ToolName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ToolName"))
	}
	if v.ToolDescriptionJsonPath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ToolDescriptionJsonPath"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateContext(v types.Context) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Context"}
	switch uv := v.(type) {
	case *types.ContextMemberSpanContext:
		if err := validateSpanContext(&uv.Value); err != nil {
			invalidParams.AddNested("[spanContext]", err.(smithy.InvalidParamsError))
		}

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

func validateConversational(v *types.Conversational) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Conversational"}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	}
	if len(v.Role) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Role"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDataSourceConfig(v types.DataSourceConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataSourceConfig"}
	switch uv := v.(type) {
	case *types.DataSourceConfigMemberCloudWatchLogs:
		if err := validateCloudWatchLogsSource(&uv.Value); err != nil {
			invalidParams.AddNested("[cloudWatchLogs]", err.(smithy.InvalidParamsError))
		}

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

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

func validateEmbeddedCryptoWallet(v *types.EmbeddedCryptoWallet) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EmbeddedCryptoWallet"}
	if len(v.Network) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Network"))
	}
	if v.LinkedAccounts == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LinkedAccounts"))
	} else if v.LinkedAccounts != nil {
		if err := validateLinkedAccountList(v.LinkedAccounts); err != nil {
			invalidParams.AddNested("LinkedAccounts", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEvaluationMetadata(v types.EvaluationMetadata) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EvaluationMetadata"}
	switch uv := v.(type) {
	case *types.EvaluationMetadataMemberSessionMetadata:
		if err := validateSessionMetadataList(uv.Value); err != nil {
			invalidParams.AddNested("[sessionMetadata]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

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

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

func validateExternalProxy(v *types.ExternalProxy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExternalProxy"}
	if v.Server == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Server"))
	}
	if v.Port == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Port"))
	}
	if v.Credentials != nil {
		if err := validateProxyCredentials(v.Credentials); err != nil {
			invalidParams.AddNested("Credentials", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateFilterInput(v *types.FilterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilterInput"}
	if v.Branch != nil {
		if err := validateBranchFilter(v.Branch); err != nil {
			invalidParams.AddNested("Branch", err.(smithy.InvalidParamsError))
		}
	}
	if v.EventMetadata != nil {
		if err := validateEventMetadataFilterList(v.EventMetadata); err != nil {
			invalidParams.AddNested("EventMetadata", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateHarnessAgentCoreGatewayConfig(v *types.HarnessAgentCoreGatewayConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HarnessAgentCoreGatewayConfig"}
	if v.GatewayArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayArn"))
	}
	if v.OutboundAuth != nil {
		if err := validateHarnessGatewayOutboundAuth(v.OutboundAuth); err != nil {
			invalidParams.AddNested("OutboundAuth", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateHarnessContentBlock(v types.HarnessContentBlock) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HarnessContentBlock"}
	switch uv := v.(type) {
	case *types.HarnessContentBlockMemberReasoningContent:
		if err := validateHarnessReasoningContentBlock(uv.Value); err != nil {
			invalidParams.AddNested("[reasoningContent]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

func validateHarnessGatewayOutboundAuth(v types.HarnessGatewayOutboundAuth) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HarnessGatewayOutboundAuth"}
	switch uv := v.(type) {
	case *types.HarnessGatewayOutboundAuthMemberOauth:
		if err := validateOAuthCredentialProvider(&uv.Value); err != nil {
			invalidParams.AddNested("[oauth]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

func validateHarnessMessage(v *types.HarnessMessage) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HarnessMessage"}
	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 := validateHarnessContentBlocks(v.Content); err != nil {
			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateHarnessModelConfiguration(v types.HarnessModelConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HarnessModelConfiguration"}
	switch uv := v.(type) {
	case *types.HarnessModelConfigurationMemberBedrockModelConfig:
		if err := validateHarnessBedrockModelConfig(&uv.Value); err != nil {
			invalidParams.AddNested("[bedrockModelConfig]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

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

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

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

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

func validateHarnessSkill(v types.HarnessSkill) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HarnessSkill"}
	switch uv := v.(type) {
	case *types.HarnessSkillMemberGit:
		if err := validateHarnessSkillGitSource(&uv.Value); err != nil {
			invalidParams.AddNested("[git]", err.(smithy.InvalidParamsError))
		}

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

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

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

func validateHarnessSkillGitSource(v *types.HarnessSkillGitSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HarnessSkillGitSource"}
	if v.Url == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Url"))
	}
	if v.Auth != nil {
		if err := validateHarnessSkillGitAuth(v.Auth); err != nil {
			invalidParams.AddNested("Auth", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateHarnessToolConfiguration(v types.HarnessToolConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HarnessToolConfiguration"}
	switch uv := v.(type) {
	case *types.HarnessToolConfigurationMemberAgentCoreGateway:
		if err := validateHarnessAgentCoreGatewayConfig(&uv.Value); err != nil {
			invalidParams.AddNested("[agentCoreGateway]", err.(smithy.InvalidParamsError))
		}

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

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

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

func validateHarnessToolResultBlock(v *types.HarnessToolResultBlock) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HarnessToolResultBlock"}
	if v.ToolUseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ToolUseId"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

func validateLinkedAccount(v types.LinkedAccount) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LinkedAccount"}
	switch uv := v.(type) {
	case *types.LinkedAccountMemberDeveloperJwt:
		if err := validateLinkedAccountDeveloperJwt(&uv.Value); err != nil {
			invalidParams.AddNested("[developerJwt]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

func validateLinkedAccountDeveloperJwt(v *types.LinkedAccountDeveloperJwt) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LinkedAccountDeveloperJwt"}
	if v.Kid == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Kid"))
	}
	if v.Sub == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Sub"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateLinkedAccountOAuth2(v types.LinkedAccountOAuth2) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LinkedAccountOAuth2"}
	switch uv := v.(type) {
	case *types.LinkedAccountOAuth2MemberApple:
		if err := validateOAuth2Authentication(&uv.Value); err != nil {
			invalidParams.AddNested("[apple]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

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

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

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

func validateMemoryRecordCreateInput(v *types.MemoryRecordCreateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MemoryRecordCreateInput"}
	if v.RequestIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequestIdentifier"))
	}
	if v.Namespaces == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespaces"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	}
	if v.Timestamp == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Timestamp"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateMemoryRecordUpdateInput(v *types.MemoryRecordUpdateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MemoryRecordUpdateInput"}
	if v.MemoryRecordId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryRecordId"))
	}
	if v.Timestamp == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Timestamp"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMouseClickArguments(v *types.MouseClickArguments) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MouseClickArguments"}
	if v.X == nil {
		invalidParams.Add(smithy.NewErrParamRequired("X"))
	}
	if v.Y == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Y"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMouseDragArguments(v *types.MouseDragArguments) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MouseDragArguments"}
	if v.EndX == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndX"))
	}
	if v.EndY == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndY"))
	}
	if v.StartX == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartX"))
	}
	if v.StartY == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartY"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMouseMoveArguments(v *types.MouseMoveArguments) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MouseMoveArguments"}
	if v.X == nil {
		invalidParams.Add(smithy.NewErrParamRequired("X"))
	}
	if v.Y == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Y"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMouseScrollArguments(v *types.MouseScrollArguments) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MouseScrollArguments"}
	if v.X == nil {
		invalidParams.Add(smithy.NewErrParamRequired("X"))
	}
	if v.Y == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Y"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOAuthCredentialProvider(v *types.OAuthCredentialProvider) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OAuthCredentialProvider"}
	if v.ProviderArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProviderArn"))
	}
	if v.Scopes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Scopes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validatePayloadType(v types.PayloadType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PayloadType"}
	switch uv := v.(type) {
	case *types.PayloadTypeMemberConversational:
		if err := validateConversational(&uv.Value); err != nil {
			invalidParams.AddNested("[conversational]", err.(smithy.InvalidParamsError))
		}

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

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

func validatePaymentInput(v types.PaymentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PaymentInput"}
	switch uv := v.(type) {
	case *types.PaymentInputMemberCryptoX402:
		if err := validateCryptoX402PaymentInput(&uv.Value); err != nil {
			invalidParams.AddNested("[cryptoX402]", err.(smithy.InvalidParamsError))
		}

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

func validatePaymentInstrumentDetails(v types.PaymentInstrumentDetails) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PaymentInstrumentDetails"}
	switch uv := v.(type) {
	case *types.PaymentInstrumentDetailsMemberEmbeddedCryptoWallet:
		if err := validateEmbeddedCryptoWallet(&uv.Value); err != nil {
			invalidParams.AddNested("[embeddedCryptoWallet]", err.(smithy.InvalidParamsError))
		}

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

func validatePaymentTokenRequestInput(v types.PaymentTokenRequestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PaymentTokenRequestInput"}
	switch uv := v.(type) {
	case *types.PaymentTokenRequestInputMemberCoinbaseCdpTokenRequest:
		if err := validateCoinbaseCdpTokenRequestInput(&uv.Value); err != nil {
			invalidParams.AddNested("[coinbaseCdpTokenRequest]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

func validateProxy(v types.Proxy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Proxy"}
	switch uv := v.(type) {
	case *types.ProxyMemberExternalProxy:
		if err := validateExternalProxy(&uv.Value); err != nil {
			invalidParams.AddNested("[externalProxy]", err.(smithy.InvalidParamsError))
		}

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

func validateProxyConfiguration(v *types.ProxyConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProxyConfiguration"}
	if v.Proxies == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Proxies"))
	} else if v.Proxies != nil {
		if err := validateProxies(v.Proxies); err != nil {
			invalidParams.AddNested("Proxies", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateProxyCredentials(v types.ProxyCredentials) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProxyCredentials"}
	switch uv := v.(type) {
	case *types.ProxyCredentialsMemberBasicAuth:
		if err := validateBasicAuth(&uv.Value); err != nil {
			invalidParams.AddNested("[basicAuth]", err.(smithy.InvalidParamsError))
		}

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

func validateRecommendationConfig(v types.RecommendationConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RecommendationConfig"}
	switch uv := v.(type) {
	case *types.RecommendationConfigMemberSystemPromptRecommendationConfig:
		if err := validateSystemPromptRecommendationConfig(&uv.Value); err != nil {
			invalidParams.AddNested("[systemPromptRecommendationConfig]", err.(smithy.InvalidParamsError))
		}

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

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

func validateRecommendationEvaluationConfig(v *types.RecommendationEvaluationConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RecommendationEvaluationConfig"}
	if v.Evaluators == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Evaluators"))
	} else if v.Evaluators != nil {
		if err := validateRecommendationEvaluatorList(v.Evaluators); err != nil {
			invalidParams.AddNested("Evaluators", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

	}
	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.Bucket == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Bucket"))
	}
	if v.Prefix == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Prefix"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSearchCriteria(v *types.SearchCriteria) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchCriteria"}
	if v.SearchQuery == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SearchQuery"))
	}
	if v.MetadataFilters != nil {
		if err := validateMemoryMetadataFilterList(v.MetadataFilters); err != nil {
			invalidParams.AddNested("MetadataFilters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSessionLimits(v *types.SessionLimits) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SessionLimits"}
	if v.MaxSpendAmount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxSpendAmount"))
	} else if v.MaxSpendAmount != nil {
		if err := validateAmount(v.MaxSpendAmount); err != nil {
			invalidParams.AddNested("MaxSpendAmount", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateStripePrivyTokenRequestInput(v *types.StripePrivyTokenRequestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StripePrivyTokenRequestInput"}
	if v.RequestPath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequestPath"))
	}
	if v.RequestBody == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequestBody"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSystemPromptConfig(v types.SystemPromptConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SystemPromptConfig"}
	switch uv := v.(type) {
	case *types.SystemPromptConfigMemberConfigurationBundle:
		if err := validateSystemPromptConfigurationBundle(&uv.Value); err != nil {
			invalidParams.AddNested("[configurationBundle]", err.(smithy.InvalidParamsError))
		}

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

func validateSystemPromptConfigurationBundle(v *types.SystemPromptConfigurationBundle) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SystemPromptConfigurationBundle"}
	if v.BundleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BundleArn"))
	}
	if v.VersionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VersionId"))
	}
	if v.SystemPromptJsonPath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SystemPromptJsonPath"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSystemPromptRecommendationConfig(v *types.SystemPromptRecommendationConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SystemPromptRecommendationConfig"}
	if v.SystemPrompt == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SystemPrompt"))
	} else if v.SystemPrompt != nil {
		if err := validateSystemPromptConfig(v.SystemPrompt); err != nil {
			invalidParams.AddNested("SystemPrompt", err.(smithy.InvalidParamsError))
		}
	}
	if v.AgentTraces == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentTraces"))
	} else if v.AgentTraces != nil {
		if err := validateAgentTracesConfig(v.AgentTraces); err != nil {
			invalidParams.AddNested("AgentTraces", err.(smithy.InvalidParamsError))
		}
	}
	if v.EvaluationConfig != nil {
		if err := validateRecommendationEvaluationConfig(v.EvaluationConfig); err != nil {
			invalidParams.AddNested("EvaluationConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateToolArguments(v *types.ToolArguments) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ToolArguments"}
	if v.Content != nil {
		if err := validateInputContentBlockList(v.Content); err != nil {
			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateToolDescriptionConfigurationBundle(v *types.ToolDescriptionConfigurationBundle) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ToolDescriptionConfigurationBundle"}
	if v.BundleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BundleArn"))
	}
	if v.VersionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VersionId"))
	}
	if v.Tools == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tools"))
	} else if v.Tools != nil {
		if err := validateConfigurationBundleToolEntryList(v.Tools); err != nil {
			invalidParams.AddNested("Tools", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateToolDescriptionInput(v *types.ToolDescriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ToolDescriptionInput"}
	if v.ToolName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ToolName"))
	}
	if v.ToolDescription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ToolDescription"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateToolDescriptionRecommendationConfig(v *types.ToolDescriptionRecommendationConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ToolDescriptionRecommendationConfig"}
	if v.ToolDescription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ToolDescription"))
	} else if v.ToolDescription != nil {
		if err := validateToolDescriptionSource(v.ToolDescription); err != nil {
			invalidParams.AddNested("ToolDescription", err.(smithy.InvalidParamsError))
		}
	}
	if v.AgentTraces == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentTraces"))
	} else if v.AgentTraces != nil {
		if err := validateAgentTracesConfig(v.AgentTraces); err != nil {
			invalidParams.AddNested("AgentTraces", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateToolDescriptionSource(v types.ToolDescriptionSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ToolDescriptionSource"}
	switch uv := v.(type) {
	case *types.ToolDescriptionSourceMemberConfigurationBundle:
		if err := validateToolDescriptionConfigurationBundle(&uv.Value); err != nil {
			invalidParams.AddNested("[configurationBundle]", err.(smithy.InvalidParamsError))
		}

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

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

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

func validateVariant(v *types.Variant) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Variant"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Weight == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Weight"))
	}
	if v.VariantConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VariantConfiguration"))
	} else if v.VariantConfiguration != nil {
		if err := validateVariantConfiguration(v.VariantConfiguration); err != nil {
			invalidParams.AddNested("VariantConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateVariantConfiguration(v *types.VariantConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VariantConfiguration"}
	if v.ConfigurationBundle != nil {
		if err := validateConfigurationBundleRef(v.ConfigurationBundle); err != nil {
			invalidParams.AddNested("ConfigurationBundle", err.(smithy.InvalidParamsError))
		}
	}
	if v.Target != nil {
		if err := validateTargetRef(v.Target); err != nil {
			invalidParams.AddNested("Target", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateViewPort(v *types.ViewPort) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ViewPort"}
	if v.Width == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Width"))
	}
	if v.Height == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Height"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchCreateMemoryRecordsInput(v *BatchCreateMemoryRecordsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchCreateMemoryRecordsInput"}
	if v.MemoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryId"))
	}
	if v.Records == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Records"))
	} else if v.Records != nil {
		if err := validateMemoryRecordsCreateInputList(v.Records); err != nil {
			invalidParams.AddNested("Records", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchDeleteMemoryRecordsInput(v *BatchDeleteMemoryRecordsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteMemoryRecordsInput"}
	if v.MemoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryId"))
	}
	if v.Records == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Records"))
	} else if v.Records != nil {
		if err := validateMemoryRecordsDeleteInputList(v.Records); err != nil {
			invalidParams.AddNested("Records", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchUpdateMemoryRecordsInput(v *BatchUpdateMemoryRecordsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchUpdateMemoryRecordsInput"}
	if v.MemoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryId"))
	}
	if v.Records == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Records"))
	} else if v.Records != nil {
		if err := validateMemoryRecordsUpdateInputList(v.Records); err != nil {
			invalidParams.AddNested("Records", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCompleteResourceTokenAuthInput(v *CompleteResourceTokenAuthInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CompleteResourceTokenAuthInput"}
	if v.UserIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserIdentifier"))
	}
	if v.SessionUri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionUri"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateABTestInput(v *CreateABTestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateABTestInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.GatewayArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayArn"))
	}
	if v.Variants == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Variants"))
	} else if v.Variants != nil {
		if err := validateVariantList(v.Variants); err != nil {
			invalidParams.AddNested("Variants", err.(smithy.InvalidParamsError))
		}
	}
	if v.EvaluationConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluationConfig"))
	} else if v.EvaluationConfig != nil {
		if err := validateABTestEvaluationConfig(v.EvaluationConfig); err != nil {
			invalidParams.AddNested("EvaluationConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateEventInput(v *CreateEventInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateEventInput"}
	if v.MemoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryId"))
	}
	if v.ActorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActorId"))
	}
	if v.EventTimestamp == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EventTimestamp"))
	}
	if v.Payload == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Payload"))
	} else if v.Payload != nil {
		if err := validatePayloadTypeList(v.Payload); err != nil {
			invalidParams.AddNested("Payload", err.(smithy.InvalidParamsError))
		}
	}
	if v.Branch != nil {
		if err := validateBranch(v.Branch); err != nil {
			invalidParams.AddNested("Branch", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePaymentInstrumentInput(v *CreatePaymentInstrumentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePaymentInstrumentInput"}
	if v.PaymentManagerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentManagerArn"))
	}
	if v.PaymentConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentConnectorId"))
	}
	if len(v.PaymentInstrumentType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentInstrumentType"))
	}
	if v.PaymentInstrumentDetails == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentInstrumentDetails"))
	} else if v.PaymentInstrumentDetails != nil {
		if err := validatePaymentInstrumentDetails(v.PaymentInstrumentDetails); err != nil {
			invalidParams.AddNested("PaymentInstrumentDetails", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePaymentSessionInput(v *CreatePaymentSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePaymentSessionInput"}
	if v.PaymentManagerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentManagerArn"))
	}
	if v.Limits != nil {
		if err := validateSessionLimits(v.Limits); err != nil {
			invalidParams.AddNested("Limits", err.(smithy.InvalidParamsError))
		}
	}
	if v.ExpiryTimeInMinutes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExpiryTimeInMinutes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteEventInput(v *DeleteEventInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteEventInput"}
	if v.MemoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryId"))
	}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if v.EventId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EventId"))
	}
	if v.ActorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActorId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteMemoryRecordInput(v *DeleteMemoryRecordInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteMemoryRecordInput"}
	if v.MemoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryId"))
	}
	if v.MemoryRecordId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryRecordId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeletePaymentInstrumentInput(v *DeletePaymentInstrumentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeletePaymentInstrumentInput"}
	if v.PaymentManagerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentManagerArn"))
	}
	if v.PaymentConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentConnectorId"))
	}
	if v.PaymentInstrumentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentInstrumentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeletePaymentSessionInput(v *DeletePaymentSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeletePaymentSessionInput"}
	if v.PaymentManagerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentManagerArn"))
	}
	if v.PaymentSessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentSessionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpEvaluateInput(v *EvaluateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EvaluateInput"}
	if v.EvaluatorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluatorId"))
	}
	if v.EvaluationInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluationInput"))
	}
	if v.EvaluationReferenceInputs != nil {
		if err := validateEvaluationReferenceInputs(v.EvaluationReferenceInputs); err != nil {
			invalidParams.AddNested("EvaluationReferenceInputs", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpGetEventInput(v *GetEventInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetEventInput"}
	if v.MemoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryId"))
	}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if v.ActorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActorId"))
	}
	if v.EventId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EventId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetMemoryRecordInput(v *GetMemoryRecordInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMemoryRecordInput"}
	if v.MemoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryId"))
	}
	if v.MemoryRecordId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryRecordId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetPaymentInstrumentBalanceInput(v *GetPaymentInstrumentBalanceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPaymentInstrumentBalanceInput"}
	if v.PaymentManagerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentManagerArn"))
	}
	if v.PaymentConnectorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentConnectorId"))
	}
	if v.PaymentInstrumentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentInstrumentId"))
	}
	if len(v.Chain) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Chain"))
	}
	if len(v.Token) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Token"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetPaymentInstrumentInput(v *GetPaymentInstrumentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPaymentInstrumentInput"}
	if v.PaymentManagerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentManagerArn"))
	}
	if v.PaymentInstrumentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentInstrumentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetPaymentSessionInput(v *GetPaymentSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPaymentSessionInput"}
	if v.PaymentManagerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentManagerArn"))
	}
	if v.PaymentSessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentSessionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetResourceApiKeyInput(v *GetResourceApiKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetResourceApiKeyInput"}
	if v.WorkloadIdentityToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadIdentityToken"))
	}
	if v.ResourceCredentialProviderName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceCredentialProviderName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetResourceOauth2TokenInput(v *GetResourceOauth2TokenInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetResourceOauth2TokenInput"}
	if v.WorkloadIdentityToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadIdentityToken"))
	}
	if v.ResourceCredentialProviderName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceCredentialProviderName"))
	}
	if v.Scopes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Scopes"))
	}
	if len(v.Oauth2Flow) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Oauth2Flow"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetResourcePaymentTokenInput(v *GetResourcePaymentTokenInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetResourcePaymentTokenInput"}
	if v.WorkloadIdentityToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadIdentityToken"))
	}
	if v.ResourceCredentialProviderName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceCredentialProviderName"))
	}
	if v.PaymentTokenRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentTokenRequest"))
	} else if v.PaymentTokenRequest != nil {
		if err := validatePaymentTokenRequestInput(v.PaymentTokenRequest); err != nil {
			invalidParams.AddNested("PaymentTokenRequest", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetWorkloadAccessTokenForJWTInput(v *GetWorkloadAccessTokenForJWTInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetWorkloadAccessTokenForJWTInput"}
	if v.WorkloadName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadName"))
	}
	if v.UserToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetWorkloadAccessTokenForUserIdInput(v *GetWorkloadAccessTokenForUserIdInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetWorkloadAccessTokenForUserIdInput"}
	if v.WorkloadName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadName"))
	}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpInvokeAgentRuntimeCommandInput(v *InvokeAgentRuntimeCommandInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InvokeAgentRuntimeCommandInput"}
	if v.AgentRuntimeArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentRuntimeArn"))
	}
	if v.Body == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Body"))
	} else if v.Body != nil {
		if err := validateInvokeAgentRuntimeCommandRequestBody(v.Body); err != nil {
			invalidParams.AddNested("Body", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpInvokeAgentRuntimeInput(v *InvokeAgentRuntimeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InvokeAgentRuntimeInput"}
	if v.AgentRuntimeArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentRuntimeArn"))
	}
	if v.Payload == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Payload"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpInvokeBrowserInput(v *InvokeBrowserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InvokeBrowserInput"}
	if v.BrowserIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BrowserIdentifier"))
	}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if v.Action == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	} else if v.Action != nil {
		if err := validateBrowserAction(v.Action); err != nil {
			invalidParams.AddNested("Action", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpInvokeCodeInterpreterInput(v *InvokeCodeInterpreterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InvokeCodeInterpreterInput"}
	if v.CodeInterpreterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CodeInterpreterIdentifier"))
	}
	if len(v.Name) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Arguments != nil {
		if err := validateToolArguments(v.Arguments); err != nil {
			invalidParams.AddNested("Arguments", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpInvokeHarnessInput(v *InvokeHarnessInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InvokeHarnessInput"}
	if v.HarnessArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HarnessArn"))
	}
	if v.RuntimeSessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuntimeSessionId"))
	}
	if v.Messages == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Messages"))
	} else if v.Messages != nil {
		if err := validateHarnessMessages(v.Messages); err != nil {
			invalidParams.AddNested("Messages", err.(smithy.InvalidParamsError))
		}
	}
	if v.Model != nil {
		if err := validateHarnessModelConfiguration(v.Model); err != nil {
			invalidParams.AddNested("Model", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tools != nil {
		if err := validateHarnessTools(v.Tools); err != nil {
			invalidParams.AddNested("Tools", err.(smithy.InvalidParamsError))
		}
	}
	if v.Skills != nil {
		if err := validateHarnessSkills(v.Skills); err != nil {
			invalidParams.AddNested("Skills", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpListEventsInput(v *ListEventsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListEventsInput"}
	if v.MemoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryId"))
	}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if v.ActorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActorId"))
	}
	if v.Filter != nil {
		if err := validateFilterInput(v.Filter); err != nil {
			invalidParams.AddNested("Filter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListMemoryRecordsInput(v *ListMemoryRecordsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListMemoryRecordsInput"}
	if v.MemoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryId"))
	}
	if v.MetadataFilters != nil {
		if err := validateMemoryMetadataFilterList(v.MetadataFilters); err != nil {
			invalidParams.AddNested("MetadataFilters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListSessionsInput(v *ListSessionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListSessionsInput"}
	if v.MemoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryId"))
	}
	if v.ActorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActorId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpProcessPaymentInput(v *ProcessPaymentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProcessPaymentInput"}
	if v.PaymentManagerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentManagerArn"))
	}
	if v.PaymentSessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentSessionId"))
	}
	if v.PaymentInstrumentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentInstrumentId"))
	}
	if len(v.PaymentType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentType"))
	}
	if v.PaymentInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentInput"))
	} else if v.PaymentInput != nil {
		if err := validatePaymentInput(v.PaymentInput); err != nil {
			invalidParams.AddNested("PaymentInput", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRetrieveMemoryRecordsInput(v *RetrieveMemoryRecordsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RetrieveMemoryRecordsInput"}
	if v.MemoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryId"))
	}
	if v.SearchCriteria == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SearchCriteria"))
	} else if v.SearchCriteria != nil {
		if err := validateSearchCriteria(v.SearchCriteria); err != nil {
			invalidParams.AddNested("SearchCriteria", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSaveBrowserSessionProfileInput(v *SaveBrowserSessionProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SaveBrowserSessionProfileInput"}
	if v.ProfileIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProfileIdentifier"))
	}
	if v.BrowserIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BrowserIdentifier"))
	}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchRegistryRecordsInput(v *SearchRegistryRecordsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchRegistryRecordsInput"}
	if v.SearchQuery == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SearchQuery"))
	}
	if v.RegistryIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RegistryIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartBatchEvaluationInput(v *StartBatchEvaluationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartBatchEvaluationInput"}
	if v.BatchEvaluationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BatchEvaluationName"))
	}
	if v.Evaluators != nil {
		if err := validateEvaluatorList(v.Evaluators); err != nil {
			invalidParams.AddNested("Evaluators", err.(smithy.InvalidParamsError))
		}
	}
	if v.Insights != nil {
		if err := validateInsightList(v.Insights); err != nil {
			invalidParams.AddNested("Insights", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataSourceConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceConfig"))
	} else if v.DataSourceConfig != nil {
		if err := validateDataSourceConfig(v.DataSourceConfig); err != nil {
			invalidParams.AddNested("DataSourceConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.EvaluationMetadata != nil {
		if err := validateEvaluationMetadata(v.EvaluationMetadata); err != nil {
			invalidParams.AddNested("EvaluationMetadata", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartBrowserSessionInput(v *StartBrowserSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartBrowserSessionInput"}
	if v.BrowserIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BrowserIdentifier"))
	}
	if v.ViewPort != nil {
		if err := validateViewPort(v.ViewPort); err != nil {
			invalidParams.AddNested("ViewPort", err.(smithy.InvalidParamsError))
		}
	}
	if v.Extensions != nil {
		if err := validateBrowserExtensions(v.Extensions); err != nil {
			invalidParams.AddNested("Extensions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ProfileConfiguration != nil {
		if err := validateBrowserProfileConfiguration(v.ProfileConfiguration); err != nil {
			invalidParams.AddNested("ProfileConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ProxyConfiguration != nil {
		if err := validateProxyConfiguration(v.ProxyConfiguration); err != nil {
			invalidParams.AddNested("ProxyConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.EnterprisePolicies != nil {
		if err := validateBrowserEnterprisePolicies(v.EnterprisePolicies); err != nil {
			invalidParams.AddNested("EnterprisePolicies", err.(smithy.InvalidParamsError))
		}
	}
	if v.Certificates != nil {
		if err := validateCertificates(v.Certificates); err != nil {
			invalidParams.AddNested("Certificates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartCodeInterpreterSessionInput(v *StartCodeInterpreterSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartCodeInterpreterSessionInput"}
	if v.CodeInterpreterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CodeInterpreterIdentifier"))
	}
	if v.Certificates != nil {
		if err := validateCertificates(v.Certificates); err != nil {
			invalidParams.AddNested("Certificates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartMemoryExtractionJobInput(v *StartMemoryExtractionJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartMemoryExtractionJobInput"}
	if v.MemoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryId"))
	}
	if v.ExtractionJob == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExtractionJob"))
	} else if v.ExtractionJob != nil {
		if err := validateExtractionJob(v.ExtractionJob); err != nil {
			invalidParams.AddNested("ExtractionJob", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartRecommendationInput(v *StartRecommendationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartRecommendationInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.RecommendationConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecommendationConfig"))
	} else if v.RecommendationConfig != nil {
		if err := validateRecommendationConfig(v.RecommendationConfig); err != nil {
			invalidParams.AddNested("RecommendationConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpStopRuntimeSessionInput(v *StopRuntimeSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopRuntimeSessionInput"}
	if v.RuntimeSessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuntimeSessionId"))
	}
	if v.AgentRuntimeArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentRuntimeArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateABTestInput(v *UpdateABTestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateABTestInput"}
	if v.AbTestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AbTestId"))
	}
	if v.Variants != nil {
		if err := validateVariantList(v.Variants); err != nil {
			invalidParams.AddNested("Variants", err.(smithy.InvalidParamsError))
		}
	}
	if v.EvaluationConfig != nil {
		if err := validateABTestEvaluationConfig(v.EvaluationConfig); err != nil {
			invalidParams.AddNested("EvaluationConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateBrowserStreamInput(v *UpdateBrowserStreamInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateBrowserStreamInput"}
	if v.BrowserIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BrowserIdentifier"))
	}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if v.StreamUpdate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StreamUpdate"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}
