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

package kendra

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

type validateOpAssociateEntitiesToExperience struct {
}

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

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

type validateOpAssociatePersonasToEntities struct {
}

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

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

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

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

type validateOpBatchGetDocumentStatus struct {
}

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

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

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

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

type validateOpCreateAccessControlConfiguration struct {
}

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

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

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

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

type validateOpCreateFaq struct {
}

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

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

type validateOpCreateFeaturedResultsSet struct {
}

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

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

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

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

type validateOpCreateThesaurus struct {
}

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

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

type validateOpDeleteAccessControlConfiguration struct {
}

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

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

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

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

type validateOpDeleteFaq struct {
}

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

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

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

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

type validateOpDeleteQuerySuggestionsBlockList struct {
}

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

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

type validateOpDeleteThesaurus struct {
}

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

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

type validateOpDescribeAccessControlConfiguration struct {
}

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

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

type validateOpDescribeDataSource struct {
}

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

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

type validateOpDescribeExperience struct {
}

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

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

type validateOpDescribeFaq struct {
}

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

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

type validateOpDescribeFeaturedResultsSet struct {
}

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

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

type validateOpDescribeIndex struct {
}

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

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

type validateOpDescribePrincipalMapping struct {
}

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

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

type validateOpDescribeQuerySuggestionsBlockList struct {
}

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

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

type validateOpDescribeQuerySuggestionsConfig struct {
}

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

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

type validateOpDescribeThesaurus struct {
}

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

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

type validateOpDisassociateEntitiesFromExperience struct {
}

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

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

type validateOpDisassociatePersonasFromEntities struct {
}

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

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

type validateOpGetQuerySuggestions struct {
}

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

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

type validateOpGetSnapshots struct {
}

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

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

type validateOpListAccessControlConfigurations struct {
}

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

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

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

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

type validateOpListExperienceEntities struct {
}

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

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

type validateOpListExperiences struct {
}

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

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

type validateOpListFaqs struct {
}

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

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

type validateOpListFeaturedResultsSets struct {
}

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

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

type validateOpListGroupsOlderThanOrderingId struct {
}

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

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

type validateOpListQuerySuggestionsBlockLists struct {
}

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

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

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

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

type validateOpPutPrincipalMapping struct {
}

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

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

type validateOpQuery struct {
}

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

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

type validateOpRetrieve struct {
}

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

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

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

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

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

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

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

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

type validateOpUpdateFeaturedResultsSet struct {
}

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

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

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

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

type validateOpUpdateQuerySuggestionsConfig struct {
}

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

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

type validateOpUpdateThesaurus struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpListAccessControlConfigurationsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListAccessControlConfigurations{}, 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 addOpListEntityPersonasValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListEntityPersonas{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

func addOpRetrieveValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRetrieve{}, 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 addOpSubmitFeedbackValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSubmitFeedback{}, 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 addOpUpdateAccessControlConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateAccessControlConfiguration{}, middleware.After)
}

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

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

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

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

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

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

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

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

func validateAlfrescoConfiguration(v *types.AlfrescoConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AlfrescoConfiguration"}
	if v.SiteUrl == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SiteUrl"))
	}
	if v.SiteId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SiteId"))
	}
	if v.SecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecretArn"))
	}
	if v.SslCertificateS3Path == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SslCertificateS3Path"))
	} else if v.SslCertificateS3Path != nil {
		if err := validateS3Path(v.SslCertificateS3Path); err != nil {
			invalidParams.AddNested("SslCertificateS3Path", err.(smithy.InvalidParamsError))
		}
	}
	if v.DocumentLibraryFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.DocumentLibraryFieldMappings); err != nil {
			invalidParams.AddNested("DocumentLibraryFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.BlogFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.BlogFieldMappings); err != nil {
			invalidParams.AddNested("BlogFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.WikiFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.WikiFieldMappings); err != nil {
			invalidParams.AddNested("WikiFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.VpcConfiguration != nil {
		if err := validateDataSourceVpcConfiguration(v.VpcConfiguration); err != nil {
			invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAssociateEntityList(v []types.EntityConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateEntityList"}
	for i := range v {
		if err := validateEntityConfiguration(&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 := validateAttributeFilterList(v.AndAllFilters); err != nil {
			invalidParams.AddNested("AndAllFilters", err.(smithy.InvalidParamsError))
		}
	}
	if v.OrAllFilters != nil {
		if err := validateAttributeFilterList(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 validateAttributeFilterList(v []types.AttributeFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttributeFilterList"}
	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 validateAttributeSuggestionsGetConfig(v *types.AttributeSuggestionsGetConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttributeSuggestionsGetConfig"}
	if v.AttributeFilter != nil {
		if err := validateAttributeFilter(v.AttributeFilter); err != nil {
			invalidParams.AddNested("AttributeFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.UserContext != nil {
		if err := validateUserContext(v.UserContext); err != nil {
			invalidParams.AddNested("UserContext", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAuthenticationConfiguration(v *types.AuthenticationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AuthenticationConfiguration"}
	if v.BasicAuthentication != nil {
		if err := validateBasicAuthenticationConfigurationList(v.BasicAuthentication); err != nil {
			invalidParams.AddNested("BasicAuthentication", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBasicAuthenticationConfiguration(v *types.BasicAuthenticationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BasicAuthenticationConfiguration"}
	if v.Host == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Host"))
	}
	if v.Port == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Port"))
	}
	if v.Credentials == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Credentials"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateBoxConfiguration(v *types.BoxConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BoxConfiguration"}
	if v.EnterpriseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnterpriseId"))
	}
	if v.SecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecretArn"))
	}
	if v.FileFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.FileFieldMappings); err != nil {
			invalidParams.AddNested("FileFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.TaskFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.TaskFieldMappings); err != nil {
			invalidParams.AddNested("TaskFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.CommentFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.CommentFieldMappings); err != nil {
			invalidParams.AddNested("CommentFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.WebLinkFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.WebLinkFieldMappings); err != nil {
			invalidParams.AddNested("WebLinkFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.VpcConfiguration != nil {
		if err := validateDataSourceVpcConfiguration(v.VpcConfiguration); err != nil {
			invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCapacityUnitsConfiguration(v *types.CapacityUnitsConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CapacityUnitsConfiguration"}
	if v.StorageCapacityUnits == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StorageCapacityUnits"))
	}
	if v.QueryCapacityUnits == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryCapacityUnits"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateClickFeedback(v *types.ClickFeedback) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ClickFeedback"}
	if v.ResultId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResultId"))
	}
	if v.ClickTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClickTime"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateColumnConfiguration(v *types.ColumnConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ColumnConfiguration"}
	if v.DocumentIdColumnName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentIdColumnName"))
	}
	if v.DocumentDataColumnName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentDataColumnName"))
	}
	if v.FieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil {
			invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.ChangeDetectingColumns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeDetectingColumns"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConfluenceConfiguration(v *types.ConfluenceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConfluenceConfiguration"}
	if v.ServerUrl == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServerUrl"))
	}
	if v.SecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecretArn"))
	}
	if len(v.Version) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Version"))
	}
	if v.VpcConfiguration != nil {
		if err := validateDataSourceVpcConfiguration(v.VpcConfiguration); err != nil {
			invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ProxyConfiguration != nil {
		if err := validateProxyConfiguration(v.ProxyConfiguration); err != nil {
			invalidParams.AddNested("ProxyConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConnectionConfiguration(v *types.ConnectionConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConnectionConfiguration"}
	if v.DatabaseHost == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseHost"))
	}
	if v.DatabasePort == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabasePort"))
	}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.SecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecretArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomDocumentEnrichmentConfiguration(v *types.CustomDocumentEnrichmentConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomDocumentEnrichmentConfiguration"}
	if v.InlineConfigurations != nil {
		if err := validateInlineCustomDocumentEnrichmentConfigurationList(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 validateDatabaseConfiguration(v *types.DatabaseConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DatabaseConfiguration"}
	if len(v.DatabaseEngineType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseEngineType"))
	}
	if v.ConnectionConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionConfiguration"))
	} else if v.ConnectionConfiguration != nil {
		if err := validateConnectionConfiguration(v.ConnectionConfiguration); err != nil {
			invalidParams.AddNested("ConnectionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.VpcConfiguration != nil {
		if err := validateDataSourceVpcConfiguration(v.VpcConfiguration); err != nil {
			invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnConfiguration"))
	} else if v.ColumnConfiguration != nil {
		if err := validateColumnConfiguration(v.ColumnConfiguration); err != nil {
			invalidParams.AddNested("ColumnConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.AclConfiguration != nil {
		if err := validateAclConfiguration(v.AclConfiguration); err != nil {
			invalidParams.AddNested("AclConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDataSourceConfiguration(v *types.DataSourceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataSourceConfiguration"}
	if v.S3Configuration != nil {
		if err := validateS3DataSourceConfiguration(v.S3Configuration); err != nil {
			invalidParams.AddNested("S3Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if v.SharePointConfiguration != nil {
		if err := validateSharePointConfiguration(v.SharePointConfiguration); err != nil {
			invalidParams.AddNested("SharePointConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.DatabaseConfiguration != nil {
		if err := validateDatabaseConfiguration(v.DatabaseConfiguration); err != nil {
			invalidParams.AddNested("DatabaseConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.SalesforceConfiguration != nil {
		if err := validateSalesforceConfiguration(v.SalesforceConfiguration); err != nil {
			invalidParams.AddNested("SalesforceConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.OneDriveConfiguration != nil {
		if err := validateOneDriveConfiguration(v.OneDriveConfiguration); err != nil {
			invalidParams.AddNested("OneDriveConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ServiceNowConfiguration != nil {
		if err := validateServiceNowConfiguration(v.ServiceNowConfiguration); err != nil {
			invalidParams.AddNested("ServiceNowConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ConfluenceConfiguration != nil {
		if err := validateConfluenceConfiguration(v.ConfluenceConfiguration); err != nil {
			invalidParams.AddNested("ConfluenceConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.GoogleDriveConfiguration != nil {
		if err := validateGoogleDriveConfiguration(v.GoogleDriveConfiguration); err != nil {
			invalidParams.AddNested("GoogleDriveConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.WebCrawlerConfiguration != nil {
		if err := validateWebCrawlerConfiguration(v.WebCrawlerConfiguration); err != nil {
			invalidParams.AddNested("WebCrawlerConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.WorkDocsConfiguration != nil {
		if err := validateWorkDocsConfiguration(v.WorkDocsConfiguration); err != nil {
			invalidParams.AddNested("WorkDocsConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.FsxConfiguration != nil {
		if err := validateFsxConfiguration(v.FsxConfiguration); err != nil {
			invalidParams.AddNested("FsxConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.SlackConfiguration != nil {
		if err := validateSlackConfiguration(v.SlackConfiguration); err != nil {
			invalidParams.AddNested("SlackConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.BoxConfiguration != nil {
		if err := validateBoxConfiguration(v.BoxConfiguration); err != nil {
			invalidParams.AddNested("BoxConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.QuipConfiguration != nil {
		if err := validateQuipConfiguration(v.QuipConfiguration); err != nil {
			invalidParams.AddNested("QuipConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.JiraConfiguration != nil {
		if err := validateJiraConfiguration(v.JiraConfiguration); err != nil {
			invalidParams.AddNested("JiraConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.GitHubConfiguration != nil {
		if err := validateGitHubConfiguration(v.GitHubConfiguration); err != nil {
			invalidParams.AddNested("GitHubConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.AlfrescoConfiguration != nil {
		if err := validateAlfrescoConfiguration(v.AlfrescoConfiguration); err != nil {
			invalidParams.AddNested("AlfrescoConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDataSourceGroup(v *types.DataSourceGroup) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataSourceGroup"}
	if v.GroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
	}
	if v.DataSourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateDataSourceToIndexFieldMapping(v *types.DataSourceToIndexFieldMapping) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataSourceToIndexFieldMapping"}
	if v.DataSourceFieldName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceFieldName"))
	}
	if v.IndexFieldName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexFieldName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDataSourceToIndexFieldMappingList(v []types.DataSourceToIndexFieldMapping) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataSourceToIndexFieldMappingList"}
	for i := range v {
		if err := validateDataSourceToIndexFieldMapping(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), 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 validateDisassociateEntityList(v []types.EntityConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateEntityList"}
	for i := range v {
		if err := validateEntityConfiguration(&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.S3Path != nil {
		if err := validateS3Path(v.S3Path); err != nil {
			invalidParams.AddNested("S3Path", err.(smithy.InvalidParamsError))
		}
	}
	if v.Attributes != nil {
		if err := validateDocumentAttributeList(v.Attributes); err != nil {
			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.AccessControlList != nil {
		if err := validatePrincipalList(v.AccessControlList); err != nil {
			invalidParams.AddNested("AccessControlList", err.(smithy.InvalidParamsError))
		}
	}
	if v.HierarchicalAccessControlList != nil {
		if err := validateHierarchicalPrincipalList(v.HierarchicalAccessControlList); err != nil {
			invalidParams.AddNested("HierarchicalAccessControlList", 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.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 validateDocumentAttributeCondition(v *types.DocumentAttributeCondition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DocumentAttributeCondition"}
	if v.ConditionDocumentAttributeKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConditionDocumentAttributeKey"))
	}
	if len(v.Operator) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Operator"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDocumentAttributeList(v []types.DocumentAttribute) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DocumentAttributeList"}
	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 validateDocumentInfo(v *types.DocumentInfo) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DocumentInfo"}
	if v.DocumentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentId"))
	}
	if v.Attributes != nil {
		if err := validateDocumentAttributeList(v.Attributes); err != nil {
			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDocumentList(v []types.Document) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DocumentList"}
	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 validateDocumentMetadataConfiguration(v *types.DocumentMetadataConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DocumentMetadataConfiguration"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateEntityConfiguration(v *types.EntityConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EntityConfiguration"}
	if v.EntityId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityId"))
	}
	if len(v.EntityType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EntityType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEntityPersonaConfiguration(v *types.EntityPersonaConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EntityPersonaConfiguration"}
	if v.EntityId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityId"))
	}
	if len(v.Persona) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Persona"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateFsxConfiguration(v *types.FsxConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FsxConfiguration"}
	if v.FileSystemId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FileSystemId"))
	}
	if len(v.FileSystemType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("FileSystemType"))
	}
	if v.VpcConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcConfiguration"))
	} else if v.VpcConfiguration != nil {
		if err := validateDataSourceVpcConfiguration(v.VpcConfiguration); err != nil {
			invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.FieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil {
			invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGitHubConfiguration(v *types.GitHubConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GitHubConfiguration"}
	if v.SaaSConfiguration != nil {
		if err := validateSaaSConfiguration(v.SaaSConfiguration); err != nil {
			invalidParams.AddNested("SaaSConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.OnPremiseConfiguration != nil {
		if err := validateOnPremiseConfiguration(v.OnPremiseConfiguration); err != nil {
			invalidParams.AddNested("OnPremiseConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.SecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecretArn"))
	}
	if v.VpcConfiguration != nil {
		if err := validateDataSourceVpcConfiguration(v.VpcConfiguration); err != nil {
			invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.GitHubRepositoryConfigurationFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.GitHubRepositoryConfigurationFieldMappings); err != nil {
			invalidParams.AddNested("GitHubRepositoryConfigurationFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.GitHubCommitConfigurationFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.GitHubCommitConfigurationFieldMappings); err != nil {
			invalidParams.AddNested("GitHubCommitConfigurationFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.GitHubIssueDocumentConfigurationFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.GitHubIssueDocumentConfigurationFieldMappings); err != nil {
			invalidParams.AddNested("GitHubIssueDocumentConfigurationFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.GitHubIssueCommentConfigurationFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.GitHubIssueCommentConfigurationFieldMappings); err != nil {
			invalidParams.AddNested("GitHubIssueCommentConfigurationFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.GitHubIssueAttachmentConfigurationFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.GitHubIssueAttachmentConfigurationFieldMappings); err != nil {
			invalidParams.AddNested("GitHubIssueAttachmentConfigurationFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.GitHubPullRequestCommentConfigurationFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.GitHubPullRequestCommentConfigurationFieldMappings); err != nil {
			invalidParams.AddNested("GitHubPullRequestCommentConfigurationFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.GitHubPullRequestDocumentConfigurationFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.GitHubPullRequestDocumentConfigurationFieldMappings); err != nil {
			invalidParams.AddNested("GitHubPullRequestDocumentConfigurationFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.GitHubPullRequestDocumentAttachmentConfigurationFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.GitHubPullRequestDocumentAttachmentConfigurationFieldMappings); err != nil {
			invalidParams.AddNested("GitHubPullRequestDocumentAttachmentConfigurationFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGoogleDriveConfiguration(v *types.GoogleDriveConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GoogleDriveConfiguration"}
	if v.SecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecretArn"))
	}
	if v.FieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil {
			invalidParams.AddNested("FieldMappings", 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 := validateS3Path(v.S3PathforGroupMembers); err != nil {
			invalidParams.AddNested("S3PathforGroupMembers", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateHierarchicalPrincipalList(v []types.HierarchicalPrincipal) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HierarchicalPrincipalList"}
	for i := range v {
		if err := validateHierarchicalPrincipal(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), 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 v.LambdaArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LambdaArn"))
	}
	if v.S3Bucket == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3Bucket"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateJiraConfiguration(v *types.JiraConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "JiraConfiguration"}
	if v.JiraAccountUrl == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JiraAccountUrl"))
	}
	if v.SecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecretArn"))
	}
	if v.AttachmentFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.AttachmentFieldMappings); err != nil {
			invalidParams.AddNested("AttachmentFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.CommentFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.CommentFieldMappings); err != nil {
			invalidParams.AddNested("CommentFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.IssueFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.IssueFieldMappings); err != nil {
			invalidParams.AddNested("IssueFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.ProjectFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.ProjectFieldMappings); err != nil {
			invalidParams.AddNested("ProjectFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.WorkLogFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.WorkLogFieldMappings); err != nil {
			invalidParams.AddNested("WorkLogFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.VpcConfiguration != nil {
		if err := validateDataSourceVpcConfiguration(v.VpcConfiguration); err != nil {
			invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateJsonTokenTypeConfiguration(v *types.JsonTokenTypeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "JsonTokenTypeConfiguration"}
	if v.UserNameAttributeField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserNameAttributeField"))
	}
	if v.GroupAttributeField == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupAttributeField"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateJwtTokenTypeConfiguration(v *types.JwtTokenTypeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "JwtTokenTypeConfiguration"}
	if len(v.KeyLocation) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("KeyLocation"))
	}
	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.GroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
	}
	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 validateOneDriveConfiguration(v *types.OneDriveConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OneDriveConfiguration"}
	if v.TenantDomain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TenantDomain"))
	}
	if v.SecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecretArn"))
	}
	if v.OneDriveUsers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OneDriveUsers"))
	} else if v.OneDriveUsers != nil {
		if err := validateOneDriveUsers(v.OneDriveUsers); err != nil {
			invalidParams.AddNested("OneDriveUsers", err.(smithy.InvalidParamsError))
		}
	}
	if v.FieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil {
			invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOneDriveUsers(v *types.OneDriveUsers) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OneDriveUsers"}
	if v.OneDriveUserS3Path != nil {
		if err := validateS3Path(v.OneDriveUserS3Path); err != nil {
			invalidParams.AddNested("OneDriveUserS3Path", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOnPremiseConfiguration(v *types.OnPremiseConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OnPremiseConfiguration"}
	if v.HostUrl == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HostUrl"))
	}
	if v.OrganizationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OrganizationName"))
	}
	if v.SslCertificateS3Path == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SslCertificateS3Path"))
	} else if v.SslCertificateS3Path != nil {
		if err := validateS3Path(v.SslCertificateS3Path); err != nil {
			invalidParams.AddNested("SslCertificateS3Path", err.(smithy.InvalidParamsError))
		}
	}
	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"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if len(v.Access) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Access"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePrincipalList(v []types.Principal) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PrincipalList"}
	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 validateProxyConfiguration(v *types.ProxyConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProxyConfiguration"}
	if v.Host == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Host"))
	}
	if v.Port == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Port"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateQuipConfiguration(v *types.QuipConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QuipConfiguration"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.SecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecretArn"))
	}
	if v.ThreadFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.ThreadFieldMappings); err != nil {
			invalidParams.AddNested("ThreadFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.MessageFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.MessageFieldMappings); err != nil {
			invalidParams.AddNested("MessageFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.AttachmentFieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.AttachmentFieldMappings); err != nil {
			invalidParams.AddNested("AttachmentFieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.VpcConfiguration != nil {
		if err := validateDataSourceVpcConfiguration(v.VpcConfiguration); err != nil {
			invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRelevanceFeedback(v *types.RelevanceFeedback) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RelevanceFeedback"}
	if v.ResultId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResultId"))
	}
	if len(v.RelevanceValue) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RelevanceValue"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateS3Path(v *types.S3Path) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3Path"}
	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 validateSaaSConfiguration(v *types.SaaSConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SaaSConfiguration"}
	if v.OrganizationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OrganizationName"))
	}
	if v.HostUrl == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HostUrl"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSalesforceChatterFeedConfiguration(v *types.SalesforceChatterFeedConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SalesforceChatterFeedConfiguration"}
	if v.DocumentDataFieldName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentDataFieldName"))
	}
	if v.FieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil {
			invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSalesforceConfiguration(v *types.SalesforceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SalesforceConfiguration"}
	if v.ServerUrl == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServerUrl"))
	}
	if v.SecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecretArn"))
	}
	if v.StandardObjectConfigurations != nil {
		if err := validateSalesforceStandardObjectConfigurationList(v.StandardObjectConfigurations); err != nil {
			invalidParams.AddNested("StandardObjectConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.KnowledgeArticleConfiguration != nil {
		if err := validateSalesforceKnowledgeArticleConfiguration(v.KnowledgeArticleConfiguration); err != nil {
			invalidParams.AddNested("KnowledgeArticleConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ChatterFeedConfiguration != nil {
		if err := validateSalesforceChatterFeedConfiguration(v.ChatterFeedConfiguration); err != nil {
			invalidParams.AddNested("ChatterFeedConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.StandardObjectAttachmentConfiguration != nil {
		if err := validateSalesforceStandardObjectAttachmentConfiguration(v.StandardObjectAttachmentConfiguration); err != nil {
			invalidParams.AddNested("StandardObjectAttachmentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSalesforceCustomKnowledgeArticleTypeConfiguration(v *types.SalesforceCustomKnowledgeArticleTypeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SalesforceCustomKnowledgeArticleTypeConfiguration"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.DocumentDataFieldName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentDataFieldName"))
	}
	if v.FieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil {
			invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSalesforceKnowledgeArticleConfiguration(v *types.SalesforceKnowledgeArticleConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SalesforceKnowledgeArticleConfiguration"}
	if v.IncludedStates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IncludedStates"))
	}
	if v.StandardKnowledgeArticleTypeConfiguration != nil {
		if err := validateSalesforceStandardKnowledgeArticleTypeConfiguration(v.StandardKnowledgeArticleTypeConfiguration); err != nil {
			invalidParams.AddNested("StandardKnowledgeArticleTypeConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomKnowledgeArticleTypeConfigurations != nil {
		if err := validateSalesforceCustomKnowledgeArticleTypeConfigurationList(v.CustomKnowledgeArticleTypeConfigurations); err != nil {
			invalidParams.AddNested("CustomKnowledgeArticleTypeConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSalesforceStandardKnowledgeArticleTypeConfiguration(v *types.SalesforceStandardKnowledgeArticleTypeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SalesforceStandardKnowledgeArticleTypeConfiguration"}
	if v.DocumentDataFieldName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentDataFieldName"))
	}
	if v.FieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil {
			invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSalesforceStandardObjectAttachmentConfiguration(v *types.SalesforceStandardObjectAttachmentConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SalesforceStandardObjectAttachmentConfiguration"}
	if v.FieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil {
			invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSalesforceStandardObjectConfiguration(v *types.SalesforceStandardObjectConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SalesforceStandardObjectConfiguration"}
	if len(v.Name) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.DocumentDataFieldName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentDataFieldName"))
	}
	if v.FieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil {
			invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateServiceNowConfiguration(v *types.ServiceNowConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ServiceNowConfiguration"}
	if v.HostUrl == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HostUrl"))
	}
	if v.SecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecretArn"))
	}
	if len(v.ServiceNowBuildVersion) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceNowBuildVersion"))
	}
	if v.KnowledgeArticleConfiguration != nil {
		if err := validateServiceNowKnowledgeArticleConfiguration(v.KnowledgeArticleConfiguration); err != nil {
			invalidParams.AddNested("KnowledgeArticleConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ServiceCatalogConfiguration != nil {
		if err := validateServiceNowServiceCatalogConfiguration(v.ServiceCatalogConfiguration); err != nil {
			invalidParams.AddNested("ServiceCatalogConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateServiceNowKnowledgeArticleConfiguration(v *types.ServiceNowKnowledgeArticleConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ServiceNowKnowledgeArticleConfiguration"}
	if v.DocumentDataFieldName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentDataFieldName"))
	}
	if v.FieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil {
			invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateServiceNowServiceCatalogConfiguration(v *types.ServiceNowServiceCatalogConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ServiceNowServiceCatalogConfiguration"}
	if v.DocumentDataFieldName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentDataFieldName"))
	}
	if v.FieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil {
			invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSharePointConfiguration(v *types.SharePointConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SharePointConfiguration"}
	if len(v.SharePointVersion) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SharePointVersion"))
	}
	if v.Urls == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Urls"))
	}
	if v.SecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecretArn"))
	}
	if v.VpcConfiguration != nil {
		if err := validateDataSourceVpcConfiguration(v.VpcConfiguration); err != nil {
			invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.FieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil {
			invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.SslCertificateS3Path != nil {
		if err := validateS3Path(v.SslCertificateS3Path); err != nil {
			invalidParams.AddNested("SslCertificateS3Path", err.(smithy.InvalidParamsError))
		}
	}
	if v.ProxyConfiguration != nil {
		if err := validateProxyConfiguration(v.ProxyConfiguration); err != nil {
			invalidParams.AddNested("ProxyConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSlackConfiguration(v *types.SlackConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SlackConfiguration"}
	if v.TeamId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TeamId"))
	}
	if v.SecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecretArn"))
	}
	if v.VpcConfiguration != nil {
		if err := validateDataSourceVpcConfiguration(v.VpcConfiguration); err != nil {
			invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.SlackEntityList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SlackEntityList"))
	}
	if v.SinceCrawlDate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SinceCrawlDate"))
	}
	if v.FieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil {
			invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSortingConfiguration(v *types.SortingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SortingConfiguration"}
	if v.DocumentAttributeKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentAttributeKey"))
	}
	if len(v.SortOrder) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SortOrder"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSpellCorrectionConfiguration(v *types.SpellCorrectionConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SpellCorrectionConfiguration"}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateUrls(v *types.Urls) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Urls"}
	if v.SeedUrlConfiguration != nil {
		if err := validateSeedUrlConfiguration(v.SeedUrlConfiguration); err != nil {
			invalidParams.AddNested("SeedUrlConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.SiteMapsConfiguration != nil {
		if err := validateSiteMapsConfiguration(v.SiteMapsConfiguration); err != nil {
			invalidParams.AddNested("SiteMapsConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateUserContext(v *types.UserContext) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UserContext"}
	if v.DataSourceGroups != nil {
		if err := validateDataSourceGroups(v.DataSourceGroups); err != nil {
			invalidParams.AddNested("DataSourceGroups", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateUserTokenConfiguration(v *types.UserTokenConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UserTokenConfiguration"}
	if v.JwtTokenTypeConfiguration != nil {
		if err := validateJwtTokenTypeConfiguration(v.JwtTokenTypeConfiguration); err != nil {
			invalidParams.AddNested("JwtTokenTypeConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.JsonTokenTypeConfiguration != nil {
		if err := validateJsonTokenTypeConfiguration(v.JsonTokenTypeConfiguration); err != nil {
			invalidParams.AddNested("JsonTokenTypeConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateWorkDocsConfiguration(v *types.WorkDocsConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WorkDocsConfiguration"}
	if v.OrganizationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OrganizationId"))
	}
	if v.FieldMappings != nil {
		if err := validateDataSourceToIndexFieldMappingList(v.FieldMappings); err != nil {
			invalidParams.AddNested("FieldMappings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateEntitiesToExperienceInput(v *AssociateEntitiesToExperienceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateEntitiesToExperienceInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.EntityList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityList"))
	} else if v.EntityList != nil {
		if err := validateAssociateEntityList(v.EntityList); err != nil {
			invalidParams.AddNested("EntityList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociatePersonasToEntitiesInput(v *AssociatePersonasToEntitiesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociatePersonasToEntitiesInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.Personas == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Personas"))
	} else if v.Personas != nil {
		if err := validateEntityPersonaConfigurationList(v.Personas); err != nil {
			invalidParams.AddNested("Personas", err.(smithy.InvalidParamsError))
		}
	}
	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.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.DocumentIdList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentIdList"))
	}
	if v.DataSourceSyncJobMetricTarget != nil {
		if err := validateDataSourceSyncJobMetricTarget(v.DataSourceSyncJobMetricTarget); err != nil {
			invalidParams.AddNested("DataSourceSyncJobMetricTarget", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpBatchGetDocumentStatusInput(v *BatchGetDocumentStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetDocumentStatusInput"}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.DocumentInfoList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DocumentInfoList"))
	} else if v.DocumentInfoList != nil {
		if err := validateDocumentInfoList(v.DocumentInfoList); err != nil {
			invalidParams.AddNested("DocumentInfoList", 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.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.Documents == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Documents"))
	} else if v.Documents != nil {
		if err := validateDocumentList(v.Documents); err != nil {
			invalidParams.AddNested("Documents", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomDocumentEnrichmentConfiguration != nil {
		if err := validateCustomDocumentEnrichmentConfiguration(v.CustomDocumentEnrichmentConfiguration); err != nil {
			invalidParams.AddNested("CustomDocumentEnrichmentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateAccessControlConfigurationInput(v *CreateAccessControlConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAccessControlConfigurationInput"}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.AccessControlList != nil {
		if err := validatePrincipalList(v.AccessControlList); err != nil {
			invalidParams.AddNested("AccessControlList", err.(smithy.InvalidParamsError))
		}
	}
	if v.HierarchicalAccessControlList != nil {
		if err := validateHierarchicalPrincipalList(v.HierarchicalAccessControlList); err != nil {
			invalidParams.AddNested("HierarchicalAccessControlList", 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.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.Configuration != nil {
		if err := validateDataSourceConfiguration(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if v.VpcConfiguration != nil {
		if err := validateDataSourceVpcConfiguration(v.VpcConfiguration); err != nil {
			invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomDocumentEnrichmentConfiguration != nil {
		if err := validateCustomDocumentEnrichmentConfiguration(v.CustomDocumentEnrichmentConfiguration); err != nil {
			invalidParams.AddNested("CustomDocumentEnrichmentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateFaqInput(v *CreateFaqInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFaqInput"}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.S3Path == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3Path"))
	} else if v.S3Path != nil {
		if err := validateS3Path(v.S3Path); err != nil {
			invalidParams.AddNested("S3Path", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFeaturedResultsSetInput(v *CreateFeaturedResultsSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFeaturedResultsSetInput"}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.FeaturedResultsSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FeaturedResultsSetName"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateIndexInput(v *CreateIndexInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateIndexInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.UserTokenConfigurations != nil {
		if err := validateUserTokenConfigurationList(v.UserTokenConfigurations); err != nil {
			invalidParams.AddNested("UserTokenConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.UserGroupResolutionConfiguration != nil {
		if err := validateUserGroupResolutionConfiguration(v.UserGroupResolutionConfiguration); err != nil {
			invalidParams.AddNested("UserGroupResolutionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateQuerySuggestionsBlockListInput(v *CreateQuerySuggestionsBlockListInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateQuerySuggestionsBlockListInput"}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.SourceS3Path == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceS3Path"))
	} else if v.SourceS3Path != nil {
		if err := validateS3Path(v.SourceS3Path); err != nil {
			invalidParams.AddNested("SourceS3Path", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateThesaurusInput(v *CreateThesaurusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateThesaurusInput"}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.SourceS3Path == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceS3Path"))
	} else if v.SourceS3Path != nil {
		if err := validateS3Path(v.SourceS3Path); err != nil {
			invalidParams.AddNested("SourceS3Path", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteAccessControlConfigurationInput(v *DeleteAccessControlConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAccessControlConfigurationInput"}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	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.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteFaqInput(v *DeleteFaqInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteFaqInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	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.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpDisassociateEntitiesFromExperienceInput(v *DisassociateEntitiesFromExperienceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateEntitiesFromExperienceInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.EntityList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityList"))
	} else if v.EntityList != nil {
		if err := validateDisassociateEntityList(v.EntityList); err != nil {
			invalidParams.AddNested("EntityList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociatePersonasFromEntitiesInput(v *DisassociatePersonasFromEntitiesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociatePersonasFromEntitiesInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.EntityIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetQuerySuggestionsInput(v *GetQuerySuggestionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetQuerySuggestionsInput"}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.QueryText == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryText"))
	}
	if v.AttributeSuggestionsConfig != nil {
		if err := validateAttributeSuggestionsGetConfig(v.AttributeSuggestionsConfig); err != nil {
			invalidParams.AddNested("AttributeSuggestionsConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSnapshotsInput(v *GetSnapshotsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSnapshotsInput"}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if len(v.Interval) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Interval"))
	}
	if len(v.MetricType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MetricType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListAccessControlConfigurationsInput(v *ListAccessControlConfigurationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAccessControlConfigurationsInput"}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	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.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.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateOpListQuerySuggestionsBlockListsInput(v *ListQuerySuggestionsBlockListsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListQuerySuggestionsBlockListsInput"}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	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 validateOpListThesauriInput(v *ListThesauriInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListThesauriInput"}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutPrincipalMappingInput(v *PutPrincipalMappingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutPrincipalMappingInput"}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.GroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupId"))
	}
	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 validateOpQueryInput(v *QueryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QueryInput"}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.AttributeFilter != nil {
		if err := validateAttributeFilter(v.AttributeFilter); err != nil {
			invalidParams.AddNested("AttributeFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.DocumentRelevanceOverrideConfigurations != nil {
		if err := validateDocumentRelevanceOverrideConfigurationList(v.DocumentRelevanceOverrideConfigurations); err != nil {
			invalidParams.AddNested("DocumentRelevanceOverrideConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortingConfiguration != nil {
		if err := validateSortingConfiguration(v.SortingConfiguration); err != nil {
			invalidParams.AddNested("SortingConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.UserContext != nil {
		if err := validateUserContext(v.UserContext); err != nil {
			invalidParams.AddNested("UserContext", err.(smithy.InvalidParamsError))
		}
	}
	if v.SpellCorrectionConfiguration != nil {
		if err := validateSpellCorrectionConfiguration(v.SpellCorrectionConfiguration); err != nil {
			invalidParams.AddNested("SpellCorrectionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRetrieveInput(v *RetrieveInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RetrieveInput"}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.QueryText == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryText"))
	}
	if v.AttributeFilter != nil {
		if err := validateAttributeFilter(v.AttributeFilter); err != nil {
			invalidParams.AddNested("AttributeFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.DocumentRelevanceOverrideConfigurations != nil {
		if err := validateDocumentRelevanceOverrideConfigurationList(v.DocumentRelevanceOverrideConfigurations); err != nil {
			invalidParams.AddNested("DocumentRelevanceOverrideConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.UserContext != nil {
		if err := validateUserContext(v.UserContext); err != nil {
			invalidParams.AddNested("UserContext", 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.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	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.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSubmitFeedbackInput(v *SubmitFeedbackInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SubmitFeedbackInput"}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.QueryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryId"))
	}
	if v.ClickFeedbackItems != nil {
		if err := validateClickFeedbackList(v.ClickFeedbackItems); err != nil {
			invalidParams.AddNested("ClickFeedbackItems", err.(smithy.InvalidParamsError))
		}
	}
	if v.RelevanceFeedbackItems != nil {
		if err := validateRelevanceFeedbackList(v.RelevanceFeedbackItems); err != nil {
			invalidParams.AddNested("RelevanceFeedbackItems", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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 validateOpUpdateAccessControlConfigurationInput(v *UpdateAccessControlConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAccessControlConfigurationInput"}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.AccessControlList != nil {
		if err := validatePrincipalList(v.AccessControlList); err != nil {
			invalidParams.AddNested("AccessControlList", err.(smithy.InvalidParamsError))
		}
	}
	if v.HierarchicalAccessControlList != nil {
		if err := validateHierarchicalPrincipalList(v.HierarchicalAccessControlList); err != nil {
			invalidParams.AddNested("HierarchicalAccessControlList", 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.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.Configuration != nil {
		if err := validateDataSourceConfiguration(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if v.VpcConfiguration != nil {
		if err := validateDataSourceVpcConfiguration(v.VpcConfiguration); err != nil {
			invalidParams.AddNested("VpcConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomDocumentEnrichmentConfiguration != nil {
		if err := validateCustomDocumentEnrichmentConfiguration(v.CustomDocumentEnrichmentConfiguration); err != nil {
			invalidParams.AddNested("CustomDocumentEnrichmentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateFeaturedResultsSetInput(v *UpdateFeaturedResultsSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFeaturedResultsSetInput"}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.FeaturedResultsSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FeaturedResultsSetId"))
	}
	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.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.DocumentMetadataConfigurationUpdates != nil {
		if err := validateDocumentMetadataConfigurationList(v.DocumentMetadataConfigurationUpdates); err != nil {
			invalidParams.AddNested("DocumentMetadataConfigurationUpdates", err.(smithy.InvalidParamsError))
		}
	}
	if v.CapacityUnits != nil {
		if err := validateCapacityUnitsConfiguration(v.CapacityUnits); err != nil {
			invalidParams.AddNested("CapacityUnits", err.(smithy.InvalidParamsError))
		}
	}
	if v.UserTokenConfigurations != nil {
		if err := validateUserTokenConfigurationList(v.UserTokenConfigurations); err != nil {
			invalidParams.AddNested("UserTokenConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.UserGroupResolutionConfiguration != nil {
		if err := validateUserGroupResolutionConfiguration(v.UserGroupResolutionConfiguration); err != nil {
			invalidParams.AddNested("UserGroupResolutionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateQuerySuggestionsBlockListInput(v *UpdateQuerySuggestionsBlockListInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateQuerySuggestionsBlockListInput"}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.SourceS3Path != nil {
		if err := validateS3Path(v.SourceS3Path); err != nil {
			invalidParams.AddNested("SourceS3Path", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateThesaurusInput(v *UpdateThesaurusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateThesaurusInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.IndexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexId"))
	}
	if v.SourceS3Path != nil {
		if err := validateS3Path(v.SourceS3Path); err != nil {
			invalidParams.AddNested("SourceS3Path", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}