service/qbusiness/validators.go

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

package qbusiness

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

type validateOpAssociatePermission struct {
}

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

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

type validateOpBatchDeleteDocument struct {
}

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

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

type validateOpBatchPutDocument struct {
}

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

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

type validateOpCancelSubscription struct {
}

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

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

type validateOpChat struct {
}

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

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

type validateOpChatSync struct {
}

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

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

type validateOpCheckDocumentAccess struct {
}

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

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

type validateOpCreateAnonymousWebExperienceUrl struct {
}

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

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

type validateOpCreateApplication struct {
}

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

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

type validateOpCreateDataAccessor struct {
}

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

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

type validateOpCreateDataSource struct {
}

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

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

type validateOpCreateIndex struct {
}

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

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

type validateOpCreatePlugin struct {
}

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

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

type validateOpCreateRetriever struct {
}

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

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

type validateOpCreateSubscription struct {
}

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

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

type validateOpCreateUser struct {
}

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

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

type validateOpCreateWebExperience struct {
}

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

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

type validateOpDeleteApplication struct {
}

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

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

type validateOpDeleteAttachment struct {
}

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

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

type validateOpDeleteChatControlsConfiguration struct {
}

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

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

type validateOpDeleteConversation struct {
}

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

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

type validateOpDeleteDataAccessor struct {
}

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

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

type validateOpDeleteDataSource struct {
}

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

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

type validateOpDeleteGroup struct {
}

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

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

type validateOpDeleteIndex struct {
}

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

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

type validateOpDeletePlugin struct {
}

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

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

type validateOpDeleteRetriever struct {
}

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

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

type validateOpDeleteUser struct {
}

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

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

type validateOpDeleteWebExperience struct {
}

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

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

type validateOpDisassociatePermission struct {
}

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

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

type validateOpGetApplication struct {
}

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

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

type validateOpGetChatControlsConfiguration struct {
}

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

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

type validateOpGetDataAccessor struct {
}

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

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

type validateOpGetDataSource struct {
}

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

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

type validateOpGetGroup struct {
}

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

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

type validateOpGetIndex struct {
}

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

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

type validateOpGetMedia struct {
}

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

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

type validateOpGetPlugin struct {
}

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

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

type validateOpGetPolicy struct {
}

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

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

type validateOpGetRetriever struct {
}

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

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

type validateOpGetUser struct {
}

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

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

type validateOpGetWebExperience struct {
}

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

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

type validateOpListAttachments struct {
}

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

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

type validateOpListConversations struct {
}

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

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

type validateOpListDataAccessors struct {
}

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

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

type validateOpListDataSources struct {
}

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

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

type validateOpListDataSourceSyncJobs struct {
}

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

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

type validateOpListDocuments struct {
}

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

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

type validateOpListGroups struct {
}

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

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

type validateOpListIndices struct {
}

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

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

type validateOpListMessages struct {
}

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

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

type validateOpListPluginActions struct {
}

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

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

type validateOpListPlugins struct {
}

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

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

type validateOpListPluginTypeActions struct {
}

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

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

type validateOpListRetrievers struct {
}

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

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

type validateOpListSubscriptions struct {
}

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

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

type validateOpListTagsForResource struct {
}

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

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

type validateOpListWebExperiences struct {
}

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

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

type validateOpPutFeedback struct {
}

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

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

type validateOpPutGroup struct {
}

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

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

type validateOpSearchRelevantContent struct {
}

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

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

type validateOpStartDataSourceSyncJob struct {
}

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

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

type validateOpStopDataSourceSyncJob struct {
}

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

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

type validateOpTagResource struct {
}

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

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

type validateOpUntagResource struct {
}

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

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

type validateOpUpdateApplication struct {
}

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

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

type validateOpUpdateChatControlsConfiguration struct {
}

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

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

type validateOpUpdateDataAccessor struct {
}

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

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

type validateOpUpdateDataSource struct {
}

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

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

type validateOpUpdateIndex struct {
}

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

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

type validateOpUpdatePlugin struct {
}

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

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

type validateOpUpdateRetriever struct {
}

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

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

type validateOpUpdateSubscription struct {
}

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

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

type validateOpUpdateUser struct {
}

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

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

type validateOpUpdateWebExperience struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateActionConfiguration(v *types.ActionConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ActionConfiguration"}
	if v.Action == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if v.FilterConfiguration != nil {
		if err := validateActionFilterConfiguration(v.FilterConfiguration); err != nil {
			invalidParams.AddNested("FilterConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateActionExecution(v *types.ActionExecution) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ActionExecution"}
	if v.PluginId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PluginId"))
	}
	if v.Payload == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Payload"))
	} else if v.Payload != nil {
		if err := validateActionExecutionPayload(v.Payload); err != nil {
			invalidParams.AddNested("Payload", err.(smithy.InvalidParamsError))
		}
	}
	if v.PayloadFieldNameSeparator == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PayloadFieldNameSeparator"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateActionExecutionEvent(v *types.ActionExecutionEvent) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ActionExecutionEvent"}
	if v.PluginId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PluginId"))
	}
	if v.Payload == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Payload"))
	} else if v.Payload != nil {
		if err := validateActionExecutionPayload(v.Payload); err != nil {
			invalidParams.AddNested("Payload", err.(smithy.InvalidParamsError))
		}
	}
	if v.PayloadFieldNameSeparator == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PayloadFieldNameSeparator"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateAttachmentInput(v *types.AttachmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachmentInput"}
	if v.CopyFrom != nil {
		if err := validateCopyFromSource(v.CopyFrom); err != nil {
			invalidParams.AddNested("CopyFrom", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAttachmentInputEvent(v *types.AttachmentInputEvent) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachmentInputEvent"}
	if v.Attachment != nil {
		if err := validateAttachmentInput(v.Attachment); err != nil {
			invalidParams.AddNested("Attachment", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateAttributeFilter(v *types.AttributeFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttributeFilter"}
	if v.AndAllFilters != nil {
		if err := validateAttributeFilters(v.AndAllFilters); err != nil {
			invalidParams.AddNested("AndAllFilters", err.(smithy.InvalidParamsError))
		}
	}
	if v.OrAllFilters != nil {
		if err := validateAttributeFilters(v.OrAllFilters); err != nil {
			invalidParams.AddNested("OrAllFilters", err.(smithy.InvalidParamsError))
		}
	}
	if v.NotFilter != nil {
		if err := validateAttributeFilter(v.NotFilter); err != nil {
			invalidParams.AddNested("NotFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.EqualsTo != nil {
		if err := validateDocumentAttribute(v.EqualsTo); err != nil {
			invalidParams.AddNested("EqualsTo", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContainsAll != nil {
		if err := validateDocumentAttribute(v.ContainsAll); err != nil {
			invalidParams.AddNested("ContainsAll", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContainsAny != nil {
		if err := validateDocumentAttribute(v.ContainsAny); err != nil {
			invalidParams.AddNested("ContainsAny", err.(smithy.InvalidParamsError))
		}
	}
	if v.GreaterThan != nil {
		if err := validateDocumentAttribute(v.GreaterThan); err != nil {
			invalidParams.AddNested("GreaterThan", err.(smithy.InvalidParamsError))
		}
	}
	if v.GreaterThanOrEquals != nil {
		if err := validateDocumentAttribute(v.GreaterThanOrEquals); err != nil {
			invalidParams.AddNested("GreaterThanOrEquals", err.(smithy.InvalidParamsError))
		}
	}
	if v.LessThan != nil {
		if err := validateDocumentAttribute(v.LessThan); err != nil {
			invalidParams.AddNested("LessThan", err.(smithy.InvalidParamsError))
		}
	}
	if v.LessThanOrEquals != nil {
		if err := validateDocumentAttribute(v.LessThanOrEquals); err != nil {
			invalidParams.AddNested("LessThanOrEquals", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

func validateChatInputStream(v types.ChatInputStream) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChatInputStream"}
	switch uv := v.(type) {
	case *types.ChatInputStreamMemberActionExecutionEvent:
		if err := validateActionExecutionEvent(&uv.Value); err != nil {
			invalidParams.AddNested("[actionExecutionEvent]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

func validateChatModeConfiguration(v types.ChatModeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChatModeConfiguration"}
	switch uv := v.(type) {
	case *types.ChatModeConfigurationMemberPluginConfiguration:
		if err := validatePluginConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[pluginConfiguration]", err.(smithy.InvalidParamsError))
		}

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

func validateConfigurationEvent(v *types.ConfigurationEvent) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConfigurationEvent"}
	if v.ChatModeConfiguration != nil {
		if err := validateChatModeConfiguration(v.ChatModeConfiguration); err != nil {
			invalidParams.AddNested("ChatModeConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.AttributeFilter != nil {
		if err := validateAttributeFilter(v.AttributeFilter); err != nil {
			invalidParams.AddNested("AttributeFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateContentSource(v types.ContentSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContentSource"}
	switch uv := v.(type) {
	case *types.ContentSourceMemberRetriever:
		if err := validateRetrieverContentSource(&uv.Value); err != nil {
			invalidParams.AddNested("[retriever]", err.(smithy.InvalidParamsError))
		}

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

func validateConversationSource(v *types.ConversationSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConversationSource"}
	if v.ConversationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConversationId"))
	}
	if v.AttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttachmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCopyFromSource(v types.CopyFromSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CopyFromSource"}
	switch uv := v.(type) {
	case *types.CopyFromSourceMemberConversation:
		if err := validateConversationSource(&uv.Value); err != nil {
			invalidParams.AddNested("[conversation]", err.(smithy.InvalidParamsError))
		}

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

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

func validateCustomPluginConfiguration(v *types.CustomPluginConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomPluginConfiguration"}
	if v.Description == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Description"))
	}
	if len(v.ApiSchemaType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ApiSchemaType"))
	}
	if v.ApiSchema == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiSchema"))
	} else if v.ApiSchema != nil {
		if err := validateAPISchema(v.ApiSchema); err != nil {
			invalidParams.AddNested("ApiSchema", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDataSourceVpcConfiguration(v *types.DataSourceVpcConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataSourceVpcConfiguration"}
	if v.SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
	}
	if v.SecurityGroupIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateDocument(v *types.Document) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Document"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.Attributes != nil {
		if err := validateDocumentAttributes(v.Attributes); err != nil {
			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.Content != nil {
		if err := validateDocumentContent(v.Content); err != nil {
			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
		}
	}
	if v.AccessConfiguration != nil {
		if err := validateAccessConfiguration(v.AccessConfiguration); err != nil {
			invalidParams.AddNested("AccessConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.DocumentEnrichmentConfiguration != nil {
		if err := validateDocumentEnrichmentConfiguration(v.DocumentEnrichmentConfiguration); err != nil {
			invalidParams.AddNested("DocumentEnrichmentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.MediaExtractionConfiguration != nil {
		if err := validateMediaExtractionConfiguration(v.MediaExtractionConfiguration); err != nil {
			invalidParams.AddNested("MediaExtractionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDocumentAttributeBoostingConfiguration(v types.DocumentAttributeBoostingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DocumentAttributeBoostingConfiguration"}
	switch uv := v.(type) {
	case *types.DocumentAttributeBoostingConfigurationMemberDateConfiguration:
		if err := validateDateAttributeBoostingConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[dateConfiguration]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

func validateDocumentAttributeBoostingOverrideMap(v map[string]types.DocumentAttributeBoostingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DocumentAttributeBoostingOverrideMap"}
	for key := range v {
		if err := validateDocumentAttributeBoostingConfiguration(v[key]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateDocumentEnrichmentConfiguration(v *types.DocumentEnrichmentConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DocumentEnrichmentConfiguration"}
	if v.InlineConfigurations != nil {
		if err := validateInlineDocumentEnrichmentConfigurations(v.InlineConfigurations); err != nil {
			invalidParams.AddNested("InlineConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.PreExtractionHookConfiguration != nil {
		if err := validateHookConfiguration(v.PreExtractionHookConfiguration); err != nil {
			invalidParams.AddNested("PreExtractionHookConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.PostExtractionHookConfiguration != nil {
		if err := validateHookConfiguration(v.PostExtractionHookConfiguration); err != nil {
			invalidParams.AddNested("PostExtractionHookConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateGroupMembers(v *types.GroupMembers) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GroupMembers"}
	if v.MemberGroups != nil {
		if err := validateMemberGroups(v.MemberGroups); err != nil {
			invalidParams.AddNested("MemberGroups", err.(smithy.InvalidParamsError))
		}
	}
	if v.MemberUsers != nil {
		if err := validateMemberUsers(v.MemberUsers); err != nil {
			invalidParams.AddNested("MemberUsers", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3PathForGroupMembers != nil {
		if err := validateS3(v.S3PathForGroupMembers); err != nil {
			invalidParams.AddNested("S3PathForGroupMembers", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateHookConfiguration(v *types.HookConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HookConfiguration"}
	if v.InvocationCondition != nil {
		if err := validateDocumentAttributeCondition(v.InvocationCondition); err != nil {
			invalidParams.AddNested("InvocationCondition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateIdcAuthConfiguration(v *types.IdcAuthConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IdcAuthConfiguration"}
	if v.IdcApplicationArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdcApplicationArn"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateIdentityProviderConfiguration(v types.IdentityProviderConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IdentityProviderConfiguration"}
	switch uv := v.(type) {
	case *types.IdentityProviderConfigurationMemberOpenIDConnectConfiguration:
		if err := validateOpenIDConnectProviderConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[openIDConnectConfiguration]", err.(smithy.InvalidParamsError))
		}

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

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

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

func validateInlineDocumentEnrichmentConfiguration(v *types.InlineDocumentEnrichmentConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InlineDocumentEnrichmentConfiguration"}
	if v.Condition != nil {
		if err := validateDocumentAttributeCondition(v.Condition); err != nil {
			invalidParams.AddNested("Condition", err.(smithy.InvalidParamsError))
		}
	}
	if v.Target != nil {
		if err := validateDocumentAttributeTarget(v.Target); err != nil {
			invalidParams.AddNested("Target", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateMediaExtractionConfiguration(v *types.MediaExtractionConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MediaExtractionConfiguration"}
	if v.ImageExtractionConfiguration != nil {
		if err := validateImageExtractionConfiguration(v.ImageExtractionConfiguration); err != nil {
			invalidParams.AddNested("ImageExtractionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.AudioExtractionConfiguration != nil {
		if err := validateAudioExtractionConfiguration(v.AudioExtractionConfiguration); err != nil {
			invalidParams.AddNested("AudioExtractionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.VideoExtractionConfiguration != nil {
		if err := validateVideoExtractionConfiguration(v.VideoExtractionConfiguration); err != nil {
			invalidParams.AddNested("VideoExtractionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateMessageUsefulnessFeedback(v *types.MessageUsefulnessFeedback) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MessageUsefulnessFeedback"}
	if len(v.Usefulness) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Usefulness"))
	}
	if v.SubmittedAt == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubmittedAt"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNativeIndexConfiguration(v *types.NativeIndexConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NativeIndexConfiguration"}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.BoostingOverride != nil {
		if err := validateDocumentAttributeBoostingOverrideMap(v.BoostingOverride); err != nil {
			invalidParams.AddNested("BoostingOverride", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpenIDConnectProviderConfiguration(v *types.OpenIDConnectProviderConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OpenIDConnectProviderConfiguration"}
	if v.SecretsArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecretsArn"))
	}
	if v.SecretsRole == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecretsRole"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validatePluginAuthConfiguration(v types.PluginAuthConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PluginAuthConfiguration"}
	switch uv := v.(type) {
	case *types.PluginAuthConfigurationMemberBasicAuthConfiguration:
		if err := validateBasicAuthConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[basicAuthConfiguration]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

func validatePrincipal(v types.Principal) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Principal"}
	switch uv := v.(type) {
	case *types.PrincipalMemberGroup:
		if err := validatePrincipalGroup(&uv.Value); err != nil {
			invalidParams.AddNested("[group]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

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

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

func validateRetrieverConfiguration(v types.RetrieverConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RetrieverConfiguration"}
	switch uv := v.(type) {
	case *types.RetrieverConfigurationMemberKendraIndexConfiguration:
		if err := validateKendraIndexConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[kendraIndexConfiguration]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

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

func validateSamlConfiguration(v *types.SamlConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SamlConfiguration"}
	if v.MetadataXML == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetadataXML"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.UserIdAttribute == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserIdAttribute"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

func validateWebExperienceAuthConfiguration(v types.WebExperienceAuthConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WebExperienceAuthConfiguration"}
	switch uv := v.(type) {
	case *types.WebExperienceAuthConfigurationMemberSamlConfiguration:
		if err := validateSamlConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[samlConfiguration]", err.(smithy.InvalidParamsError))
		}

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

func validateOpAssociatePermissionInput(v *AssociatePermissionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociatePermissionInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.StatementId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StatementId"))
	}
	if v.Actions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Actions"))
	}
	if v.Principal == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Principal"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchDeleteDocumentInput(v *BatchDeleteDocumentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteDocumentInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.Documents == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Documents"))
	} else if v.Documents != nil {
		if err := validateDeleteDocuments(v.Documents); err != nil {
			invalidParams.AddNested("Documents", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchPutDocumentInput(v *BatchPutDocumentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchPutDocumentInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.Documents == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Documents"))
	} else if v.Documents != nil {
		if err := validateDocuments(v.Documents); err != nil {
			invalidParams.AddNested("Documents", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCancelSubscriptionInput(v *CancelSubscriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelSubscriptionInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.SubscriptionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubscriptionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpChatSyncInput(v *ChatSyncInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChatSyncInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.Attachments != nil {
		if err := validateAttachmentsInput(v.Attachments); err != nil {
			invalidParams.AddNested("Attachments", err.(smithy.InvalidParamsError))
		}
	}
	if v.ActionExecution != nil {
		if err := validateActionExecution(v.ActionExecution); err != nil {
			invalidParams.AddNested("ActionExecution", err.(smithy.InvalidParamsError))
		}
	}
	if v.AuthChallengeResponse != nil {
		if err := validateAuthChallengeResponse(v.AuthChallengeResponse); err != nil {
			invalidParams.AddNested("AuthChallengeResponse", err.(smithy.InvalidParamsError))
		}
	}
	if v.AttributeFilter != nil {
		if err := validateAttributeFilter(v.AttributeFilter); err != nil {
			invalidParams.AddNested("AttributeFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.ChatModeConfiguration != nil {
		if err := validateChatModeConfiguration(v.ChatModeConfiguration); err != nil {
			invalidParams.AddNested("ChatModeConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCheckDocumentAccessInput(v *CheckDocumentAccessInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CheckDocumentAccessInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if v.DocumentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAnonymousWebExperienceUrlInput(v *CreateAnonymousWebExperienceUrlInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAnonymousWebExperienceUrlInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.WebExperienceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WebExperienceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateApplicationInput(v *CreateApplicationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateApplicationInput"}
	if v.DisplayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DisplayName"))
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.AttachmentsConfiguration != nil {
		if err := validateAttachmentsConfiguration(v.AttachmentsConfiguration); err != nil {
			invalidParams.AddNested("AttachmentsConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.QAppsConfiguration != nil {
		if err := validateQAppsConfiguration(v.QAppsConfiguration); err != nil {
			invalidParams.AddNested("QAppsConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.PersonalizationConfiguration != nil {
		if err := validatePersonalizationConfiguration(v.PersonalizationConfiguration); err != nil {
			invalidParams.AddNested("PersonalizationConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.QuickSightConfiguration != nil {
		if err := validateQuickSightConfiguration(v.QuickSightConfiguration); err != nil {
			invalidParams.AddNested("QuickSightConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDataAccessorInput(v *CreateDataAccessorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDataAccessorInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.Principal == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Principal"))
	}
	if v.ActionConfigurations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActionConfigurations"))
	} else if v.ActionConfigurations != nil {
		if err := validateActionConfigurationList(v.ActionConfigurations); err != nil {
			invalidParams.AddNested("ActionConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.DisplayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DisplayName"))
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDataSourceInput(v *CreateDataSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDataSourceInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.DisplayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DisplayName"))
	}
	if v.Configuration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Configuration"))
	}
	if v.VpcConfiguration != nil {
		if err := validateDataSourceVpcConfiguration(v.VpcConfiguration); err != nil {
			invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.DocumentEnrichmentConfiguration != nil {
		if err := validateDocumentEnrichmentConfiguration(v.DocumentEnrichmentConfiguration); err != nil {
			invalidParams.AddNested("DocumentEnrichmentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.MediaExtractionConfiguration != nil {
		if err := validateMediaExtractionConfiguration(v.MediaExtractionConfiguration); err != nil {
			invalidParams.AddNested("MediaExtractionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateIndexInput(v *CreateIndexInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateIndexInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.DisplayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DisplayName"))
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePluginInput(v *CreatePluginInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePluginInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.DisplayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DisplayName"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.AuthConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthConfiguration"))
	} else if v.AuthConfiguration != nil {
		if err := validatePluginAuthConfiguration(v.AuthConfiguration); err != nil {
			invalidParams.AddNested("AuthConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomPluginConfiguration != nil {
		if err := validateCustomPluginConfiguration(v.CustomPluginConfiguration); err != nil {
			invalidParams.AddNested("CustomPluginConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRetrieverInput(v *CreateRetrieverInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRetrieverInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.DisplayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DisplayName"))
	}
	if v.Configuration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Configuration"))
	} else if v.Configuration != nil {
		if err := validateRetrieverConfiguration(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSubscriptionInput(v *CreateSubscriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSubscriptionInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.Principal == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Principal"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateUserInput(v *CreateUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateUserInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if v.UserAliases != nil {
		if err := validateUserAliases(v.UserAliases); err != nil {
			invalidParams.AddNested("UserAliases", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateWebExperienceInput(v *CreateWebExperienceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateWebExperienceInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.IdentityProviderConfiguration != nil {
		if err := validateIdentityProviderConfiguration(v.IdentityProviderConfiguration); err != nil {
			invalidParams.AddNested("IdentityProviderConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.BrowserExtensionConfiguration != nil {
		if err := validateBrowserExtensionConfiguration(v.BrowserExtensionConfiguration); err != nil {
			invalidParams.AddNested("BrowserExtensionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteAttachmentInput(v *DeleteAttachmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAttachmentInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.ConversationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConversationId"))
	}
	if v.AttachmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttachmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteConversationInput(v *DeleteConversationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteConversationInput"}
	if v.ConversationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConversationId"))
	}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteDataAccessorInput(v *DeleteDataAccessorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDataAccessorInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.DataAccessorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataAccessorId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteGroupInput(v *DeleteGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteGroupInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteIndexInput(v *DeleteIndexInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIndexInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeletePluginInput(v *DeletePluginInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeletePluginInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.PluginId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PluginId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRetrieverInput(v *DeleteRetrieverInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRetrieverInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.RetrieverId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RetrieverId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteWebExperienceInput(v *DeleteWebExperienceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteWebExperienceInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.WebExperienceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WebExperienceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpGetDataAccessorInput(v *GetDataAccessorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDataAccessorInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.DataAccessorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataAccessorId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetGroupInput(v *GetGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetGroupInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIndexInput(v *GetIndexInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIndexInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetMediaInput(v *GetMediaInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMediaInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.ConversationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConversationId"))
	}
	if v.MessageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageId"))
	}
	if v.MediaId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MediaId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetPluginInput(v *GetPluginInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPluginInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.PluginId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PluginId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetRetrieverInput(v *GetRetrieverInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRetrieverInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.RetrieverId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RetrieverId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetWebExperienceInput(v *GetWebExperienceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetWebExperienceInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.WebExperienceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WebExperienceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpListDataSourceSyncJobsInput(v *ListDataSourceSyncJobsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDataSourceSyncJobsInput"}
	if v.DataSourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
	}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDocumentsInput(v *ListDocumentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDocumentsInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListGroupsInput(v *ListGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListGroupsInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.UpdatedEarlierThan == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UpdatedEarlierThan"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListPluginActionsInput(v *ListPluginActionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListPluginActionsInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.PluginId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PluginId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListPluginTypeActionsInput(v *ListPluginTypeActionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListPluginTypeActionsInput"}
	if len(v.PluginType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PluginType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpPutFeedbackInput(v *PutFeedbackInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutFeedbackInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.ConversationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConversationId"))
	}
	if v.MessageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageId"))
	}
	if v.MessageUsefulness != nil {
		if err := validateMessageUsefulnessFeedback(v.MessageUsefulness); err != nil {
			invalidParams.AddNested("MessageUsefulness", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutGroupInput(v *PutGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutGroupInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.GroupMembers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupMembers"))
	} else if v.GroupMembers != nil {
		if err := validateGroupMembers(v.GroupMembers); err != nil {
			invalidParams.AddNested("GroupMembers", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchRelevantContentInput(v *SearchRelevantContentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchRelevantContentInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.QueryText == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryText"))
	}
	if v.ContentSource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContentSource"))
	} else if v.ContentSource != nil {
		if err := validateContentSource(v.ContentSource); err != nil {
			invalidParams.AddNested("ContentSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.AttributeFilter != nil {
		if err := validateAttributeFilter(v.AttributeFilter); err != nil {
			invalidParams.AddNested("AttributeFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartDataSourceSyncJobInput(v *StartDataSourceSyncJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartDataSourceSyncJobInput"}
	if v.DataSourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
	}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopDataSourceSyncJobInput(v *StopDataSourceSyncJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopDataSourceSyncJobInput"}
	if v.DataSourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
	}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTagResourceInput(v *TagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
	if v.ResourceARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	} else if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateApplicationInput(v *UpdateApplicationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateApplicationInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.AttachmentsConfiguration != nil {
		if err := validateAttachmentsConfiguration(v.AttachmentsConfiguration); err != nil {
			invalidParams.AddNested("AttachmentsConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.QAppsConfiguration != nil {
		if err := validateQAppsConfiguration(v.QAppsConfiguration); err != nil {
			invalidParams.AddNested("QAppsConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.PersonalizationConfiguration != nil {
		if err := validatePersonalizationConfiguration(v.PersonalizationConfiguration); err != nil {
			invalidParams.AddNested("PersonalizationConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.AutoSubscriptionConfiguration != nil {
		if err := validateAutoSubscriptionConfiguration(v.AutoSubscriptionConfiguration); err != nil {
			invalidParams.AddNested("AutoSubscriptionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateChatControlsConfigurationInput(v *UpdateChatControlsConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateChatControlsConfigurationInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.OrchestrationConfiguration != nil {
		if err := validateOrchestrationConfiguration(v.OrchestrationConfiguration); err != nil {
			invalidParams.AddNested("OrchestrationConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.TopicConfigurationsToCreateOrUpdate != nil {
		if err := validateTopicConfigurations(v.TopicConfigurationsToCreateOrUpdate); err != nil {
			invalidParams.AddNested("TopicConfigurationsToCreateOrUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if v.TopicConfigurationsToDelete != nil {
		if err := validateTopicConfigurations(v.TopicConfigurationsToDelete); err != nil {
			invalidParams.AddNested("TopicConfigurationsToDelete", err.(smithy.InvalidParamsError))
		}
	}
	if v.CreatorModeConfiguration != nil {
		if err := validateCreatorModeConfiguration(v.CreatorModeConfiguration); err != nil {
			invalidParams.AddNested("CreatorModeConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDataAccessorInput(v *UpdateDataAccessorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDataAccessorInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.DataAccessorId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataAccessorId"))
	}
	if v.ActionConfigurations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActionConfigurations"))
	} else if v.ActionConfigurations != nil {
		if err := validateActionConfigurationList(v.ActionConfigurations); err != nil {
			invalidParams.AddNested("ActionConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDataSourceInput(v *UpdateDataSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDataSourceInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.DataSourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
	}
	if v.VpcConfiguration != nil {
		if err := validateDataSourceVpcConfiguration(v.VpcConfiguration); err != nil {
			invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.DocumentEnrichmentConfiguration != nil {
		if err := validateDocumentEnrichmentConfiguration(v.DocumentEnrichmentConfiguration); err != nil {
			invalidParams.AddNested("DocumentEnrichmentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.MediaExtractionConfiguration != nil {
		if err := validateMediaExtractionConfiguration(v.MediaExtractionConfiguration); err != nil {
			invalidParams.AddNested("MediaExtractionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateIndexInput(v *UpdateIndexInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateIndexInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdatePluginInput(v *UpdatePluginInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePluginInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.PluginId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PluginId"))
	}
	if v.CustomPluginConfiguration != nil {
		if err := validateCustomPluginConfiguration(v.CustomPluginConfiguration); err != nil {
			invalidParams.AddNested("CustomPluginConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.AuthConfiguration != nil {
		if err := validatePluginAuthConfiguration(v.AuthConfiguration); err != nil {
			invalidParams.AddNested("AuthConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRetrieverInput(v *UpdateRetrieverInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRetrieverInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.RetrieverId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RetrieverId"))
	}
	if v.Configuration != nil {
		if err := validateRetrieverConfiguration(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateSubscriptionInput(v *UpdateSubscriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSubscriptionInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.SubscriptionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubscriptionId"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateUserInput(v *UpdateUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if v.UserAliasesToUpdate != nil {
		if err := validateUserAliases(v.UserAliasesToUpdate); err != nil {
			invalidParams.AddNested("UserAliasesToUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if v.UserAliasesToDelete != nil {
		if err := validateUserAliases(v.UserAliasesToDelete); err != nil {
			invalidParams.AddNested("UserAliasesToDelete", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateWebExperienceInput(v *UpdateWebExperienceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateWebExperienceInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.WebExperienceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WebExperienceId"))
	}
	if v.AuthenticationConfiguration != nil {
		if err := validateWebExperienceAuthConfiguration(v.AuthenticationConfiguration); err != nil {
			invalidParams.AddNested("AuthenticationConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.IdentityProviderConfiguration != nil {
		if err := validateIdentityProviderConfiguration(v.IdentityProviderConfiguration); err != nil {
			invalidParams.AddNested("IdentityProviderConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.BrowserExtensionConfiguration != nil {
		if err := validateBrowserExtensionConfiguration(v.BrowserExtensionConfiguration); err != nil {
			invalidParams.AddNested("BrowserExtensionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}