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

package bedrockdataautomation

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

type validateOpCopyBlueprintStage struct {
}

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

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

type validateOpCreateBlueprint struct {
}

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

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

type validateOpCreateBlueprintVersion struct {
}

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

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

type validateOpCreateDataAutomationLibrary struct {
}

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

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

type validateOpCreateDataAutomationProject struct {
}

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

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

type validateOpDeleteBlueprint struct {
}

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

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

type validateOpDeleteDataAutomationLibrary struct {
}

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

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

type validateOpDeleteDataAutomationProject struct {
}

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

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

type validateOpGetBlueprint struct {
}

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

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

type validateOpGetBlueprintOptimizationStatus struct {
}

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

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

type validateOpGetDataAutomationLibraryEntity struct {
}

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

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

type validateOpGetDataAutomationLibraryIngestionJob struct {
}

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

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

type validateOpGetDataAutomationLibrary struct {
}

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

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

type validateOpGetDataAutomationProject struct {
}

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

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

type validateOpInvokeBlueprintOptimizationAsync struct {
}

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

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

type validateOpInvokeDataAutomationLibraryIngestionJob struct {
}

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

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

type validateOpListBlueprints struct {
}

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

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

type validateOpListDataAutomationLibraries struct {
}

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

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

type validateOpListDataAutomationLibraryEntities struct {
}

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

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

type validateOpListDataAutomationLibraryIngestionJobs struct {
}

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

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

type validateOpListDataAutomationProjects struct {
}

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

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

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

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

type validateOpUpdateDataAutomationLibrary struct {
}

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

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

type validateOpUpdateDataAutomationProject struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListTagsForResource{}, 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 addOpUpdateBlueprintValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateBlueprint{}, middleware.After)
}

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

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

func validateAudioExtractionCategory(v *types.AudioExtractionCategory) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AudioExtractionCategory"}
	if len(v.State) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("State"))
	}
	if v.TypeConfiguration != nil {
		if err := validateAudioExtractionCategoryTypeConfiguration(v.TypeConfiguration); err != nil {
			invalidParams.AddNested("TypeConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAudioExtractionCategoryTypeConfiguration(v *types.AudioExtractionCategoryTypeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AudioExtractionCategoryTypeConfiguration"}
	if v.Transcript != nil {
		if err := validateTranscriptConfiguration(v.Transcript); err != nil {
			invalidParams.AddNested("Transcript", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAudioOverrideConfiguration(v *types.AudioOverrideConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AudioOverrideConfiguration"}
	if v.SensitiveDataConfiguration != nil {
		if err := validateSensitiveDataConfiguration(v.SensitiveDataConfiguration); err != nil {
			invalidParams.AddNested("SensitiveDataConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateAudioStandardOutputConfiguration(v *types.AudioStandardOutputConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AudioStandardOutputConfiguration"}
	if v.Extraction != nil {
		if err := validateAudioStandardExtraction(v.Extraction); err != nil {
			invalidParams.AddNested("Extraction", err.(smithy.InvalidParamsError))
		}
	}
	if v.GenerativeField != nil {
		if err := validateAudioStandardGenerativeField(v.GenerativeField); err != nil {
			invalidParams.AddNested("GenerativeField", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateBlueprintOptimizationSample(v *types.BlueprintOptimizationSample) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BlueprintOptimizationSample"}
	if v.AssetS3Object == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetS3Object"))
	} else if v.AssetS3Object != nil {
		if err := validateS3Object(v.AssetS3Object); err != nil {
			invalidParams.AddNested("AssetS3Object", err.(smithy.InvalidParamsError))
		}
	}
	if v.GroundTruthS3Object == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroundTruthS3Object"))
	} else if v.GroundTruthS3Object != nil {
		if err := validateS3Object(v.GroundTruthS3Object); err != nil {
			invalidParams.AddNested("GroundTruthS3Object", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateCustomOutputConfiguration(v *types.CustomOutputConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomOutputConfiguration"}
	if v.Blueprints != nil {
		if err := validateBlueprintItems(v.Blueprints); err != nil {
			invalidParams.AddNested("Blueprints", err.(smithy.InvalidParamsError))
		}
	}
	if v.Document != nil {
		if err := validateDocumentCustomOutputConfiguration(v.Document); err != nil {
			invalidParams.AddNested("Document", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDataAutomationLibraryConfiguration(v *types.DataAutomationLibraryConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataAutomationLibraryConfiguration"}
	if v.Libraries != nil {
		if err := validateDataAutomationLibraryItems(v.Libraries); err != nil {
			invalidParams.AddNested("Libraries", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateDocumentCustomOutputConfiguration(v *types.DocumentCustomOutputConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DocumentCustomOutputConfiguration"}
	if v.FallbackBlueprints != nil {
		if err := validateFallbackBlueprintItems(v.FallbackBlueprints); err != nil {
			invalidParams.AddNested("FallbackBlueprints", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDocumentOutputFormat(v *types.DocumentOutputFormat) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DocumentOutputFormat"}
	if v.TextFormat == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextFormat"))
	}
	if v.AdditionalFileFormat == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AdditionalFileFormat"))
	} else if v.AdditionalFileFormat != nil {
		if err := validateDocumentOutputAdditionalFileFormat(v.AdditionalFileFormat); err != nil {
			invalidParams.AddNested("AdditionalFileFormat", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDocumentOverrideConfiguration(v *types.DocumentOverrideConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DocumentOverrideConfiguration"}
	if v.SensitiveDataConfiguration != nil {
		if err := validateSensitiveDataConfiguration(v.SensitiveDataConfiguration); err != nil {
			invalidParams.AddNested("SensitiveDataConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDocumentStandardExtraction(v *types.DocumentStandardExtraction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DocumentStandardExtraction"}
	if v.Granularity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Granularity"))
	}
	if v.BoundingBox == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BoundingBox"))
	} else if v.BoundingBox != nil {
		if err := validateDocumentBoundingBox(v.BoundingBox); err != nil {
			invalidParams.AddNested("BoundingBox", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDocumentStandardOutputConfiguration(v *types.DocumentStandardOutputConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DocumentStandardOutputConfiguration"}
	if v.Extraction != nil {
		if err := validateDocumentStandardExtraction(v.Extraction); err != nil {
			invalidParams.AddNested("Extraction", err.(smithy.InvalidParamsError))
		}
	}
	if v.GenerativeField != nil {
		if err := validateDocumentStandardGenerativeField(v.GenerativeField); err != nil {
			invalidParams.AddNested("GenerativeField", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputFormat != nil {
		if err := validateDocumentOutputFormat(v.OutputFormat); err != nil {
			invalidParams.AddNested("OutputFormat", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateImageOverrideConfiguration(v *types.ImageOverrideConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImageOverrideConfiguration"}
	if v.SensitiveDataConfiguration != nil {
		if err := validateSensitiveDataConfiguration(v.SensitiveDataConfiguration); err != nil {
			invalidParams.AddNested("SensitiveDataConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateImageStandardExtraction(v *types.ImageStandardExtraction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImageStandardExtraction"}
	if v.Category == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Category"))
	} else if v.Category != nil {
		if err := validateImageExtractionCategory(v.Category); err != nil {
			invalidParams.AddNested("Category", err.(smithy.InvalidParamsError))
		}
	}
	if v.BoundingBox == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BoundingBox"))
	} else if v.BoundingBox != nil {
		if err := validateImageBoundingBox(v.BoundingBox); err != nil {
			invalidParams.AddNested("BoundingBox", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateImageStandardOutputConfiguration(v *types.ImageStandardOutputConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImageStandardOutputConfiguration"}
	if v.Extraction != nil {
		if err := validateImageStandardExtraction(v.Extraction); err != nil {
			invalidParams.AddNested("Extraction", err.(smithy.InvalidParamsError))
		}
	}
	if v.GenerativeField != nil {
		if err := validateImageStandardGenerativeField(v.GenerativeField); err != nil {
			invalidParams.AddNested("GenerativeField", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInlinePayload(v types.InlinePayload) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InlinePayload"}
	switch uv := v.(type) {
	case *types.InlinePayloadMemberDeleteEntitiesInfo:
		if err := validateDeleteEntitiesInfo(&uv.Value); err != nil {
			invalidParams.AddNested("[deleteEntitiesInfo]", err.(smithy.InvalidParamsError))
		}

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

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

func validateInputConfiguration(v *types.InputConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InputConfiguration"}
	if v.S3Object != nil {
		if err := validateS3Object(v.S3Object); err != nil {
			invalidParams.AddNested("S3Object", err.(smithy.InvalidParamsError))
		}
	}
	if v.InlinePayload != nil {
		if err := validateInlinePayload(v.InlinePayload); err != nil {
			invalidParams.AddNested("InlinePayload", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOverrideConfiguration(v *types.OverrideConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OverrideConfiguration"}
	if v.Document != nil {
		if err := validateDocumentOverrideConfiguration(v.Document); err != nil {
			invalidParams.AddNested("Document", err.(smithy.InvalidParamsError))
		}
	}
	if v.Image != nil {
		if err := validateImageOverrideConfiguration(v.Image); err != nil {
			invalidParams.AddNested("Image", err.(smithy.InvalidParamsError))
		}
	}
	if v.Video != nil {
		if err := validateVideoOverrideConfiguration(v.Video); err != nil {
			invalidParams.AddNested("Video", err.(smithy.InvalidParamsError))
		}
	}
	if v.Audio != nil {
		if err := validateAudioOverrideConfiguration(v.Audio); err != nil {
			invalidParams.AddNested("Audio", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateStandardOutputConfiguration(v *types.StandardOutputConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StandardOutputConfiguration"}
	if v.Document != nil {
		if err := validateDocumentStandardOutputConfiguration(v.Document); err != nil {
			invalidParams.AddNested("Document", err.(smithy.InvalidParamsError))
		}
	}
	if v.Image != nil {
		if err := validateImageStandardOutputConfiguration(v.Image); err != nil {
			invalidParams.AddNested("Image", err.(smithy.InvalidParamsError))
		}
	}
	if v.Video != nil {
		if err := validateVideoStandardOutputConfiguration(v.Video); err != nil {
			invalidParams.AddNested("Video", err.(smithy.InvalidParamsError))
		}
	}
	if v.Audio != nil {
		if err := validateAudioStandardOutputConfiguration(v.Audio); err != nil {
			invalidParams.AddNested("Audio", err.(smithy.InvalidParamsError))
		}
	}
	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 validateTranscriptConfiguration(v *types.TranscriptConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TranscriptConfiguration"}
	if v.SpeakerLabeling != nil {
		if err := validateSpeakerLabelingConfiguration(v.SpeakerLabeling); err != nil {
			invalidParams.AddNested("SpeakerLabeling", err.(smithy.InvalidParamsError))
		}
	}
	if v.ChannelLabeling != nil {
		if err := validateChannelLabelingConfiguration(v.ChannelLabeling); err != nil {
			invalidParams.AddNested("ChannelLabeling", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateUpsertEntityInfo(v types.UpsertEntityInfo) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpsertEntityInfo"}
	switch uv := v.(type) {
	case *types.UpsertEntityInfoMemberVocabulary:
		if err := validateVocabularyEntityInfo(&uv.Value); err != nil {
			invalidParams.AddNested("[vocabulary]", err.(smithy.InvalidParamsError))
		}

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

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

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

func validateVideoOverrideConfiguration(v *types.VideoOverrideConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VideoOverrideConfiguration"}
	if v.SensitiveDataConfiguration != nil {
		if err := validateSensitiveDataConfiguration(v.SensitiveDataConfiguration); err != nil {
			invalidParams.AddNested("SensitiveDataConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateVideoStandardExtraction(v *types.VideoStandardExtraction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VideoStandardExtraction"}
	if v.Category == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Category"))
	} else if v.Category != nil {
		if err := validateVideoExtractionCategory(v.Category); err != nil {
			invalidParams.AddNested("Category", err.(smithy.InvalidParamsError))
		}
	}
	if v.BoundingBox == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BoundingBox"))
	} else if v.BoundingBox != nil {
		if err := validateVideoBoundingBox(v.BoundingBox); err != nil {
			invalidParams.AddNested("BoundingBox", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateVideoStandardOutputConfiguration(v *types.VideoStandardOutputConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VideoStandardOutputConfiguration"}
	if v.Extraction != nil {
		if err := validateVideoStandardExtraction(v.Extraction); err != nil {
			invalidParams.AddNested("Extraction", err.(smithy.InvalidParamsError))
		}
	}
	if v.GenerativeField != nil {
		if err := validateVideoStandardGenerativeField(v.GenerativeField); err != nil {
			invalidParams.AddNested("GenerativeField", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateVocabularyEntityInfo(v *types.VocabularyEntityInfo) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VocabularyEntityInfo"}
	if len(v.Language) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Language"))
	}
	if v.Phrases == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Phrases"))
	} else if v.Phrases != nil {
		if err := validatePhraseList(v.Phrases); err != nil {
			invalidParams.AddNested("Phrases", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCopyBlueprintStageInput(v *CopyBlueprintStageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CopyBlueprintStageInput"}
	if v.BlueprintArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BlueprintArn"))
	}
	if len(v.SourceStage) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SourceStage"))
	}
	if len(v.TargetStage) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TargetStage"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateBlueprintInput(v *CreateBlueprintInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateBlueprintInput"}
	if v.BlueprintName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BlueprintName"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.Schema == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Schema"))
	}
	if v.EncryptionConfiguration != nil {
		if err := validateEncryptionConfiguration(v.EncryptionConfiguration); err != nil {
			invalidParams.AddNested("EncryptionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpCreateDataAutomationProjectInput(v *CreateDataAutomationProjectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDataAutomationProjectInput"}
	if v.ProjectName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
	}
	if v.StandardOutputConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StandardOutputConfiguration"))
	} else if v.StandardOutputConfiguration != nil {
		if err := validateStandardOutputConfiguration(v.StandardOutputConfiguration); err != nil {
			invalidParams.AddNested("StandardOutputConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomOutputConfiguration != nil {
		if err := validateCustomOutputConfiguration(v.CustomOutputConfiguration); err != nil {
			invalidParams.AddNested("CustomOutputConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.OverrideConfiguration != nil {
		if err := validateOverrideConfiguration(v.OverrideConfiguration); err != nil {
			invalidParams.AddNested("OverrideConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataAutomationLibraryConfiguration != nil {
		if err := validateDataAutomationLibraryConfiguration(v.DataAutomationLibraryConfiguration); err != nil {
			invalidParams.AddNested("DataAutomationLibraryConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.EncryptionConfiguration != nil {
		if err := validateEncryptionConfiguration(v.EncryptionConfiguration); err != nil {
			invalidParams.AddNested("EncryptionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateOpGetDataAutomationLibraryIngestionJobInput(v *GetDataAutomationLibraryIngestionJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDataAutomationLibraryIngestionJobInput"}
	if v.LibraryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LibraryArn"))
	}
	if v.JobArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpInvokeBlueprintOptimizationAsyncInput(v *InvokeBlueprintOptimizationAsyncInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InvokeBlueprintOptimizationAsyncInput"}
	if v.Blueprint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Blueprint"))
	} else if v.Blueprint != nil {
		if err := validateBlueprintOptimizationObject(v.Blueprint); err != nil {
			invalidParams.AddNested("Blueprint", err.(smithy.InvalidParamsError))
		}
	}
	if v.Samples == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Samples"))
	} else if v.Samples != nil {
		if err := validateBlueprintOptimizationSamples(v.Samples); err != nil {
			invalidParams.AddNested("Samples", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputConfiguration"))
	} else if v.OutputConfiguration != nil {
		if err := validateBlueprintOptimizationOutputConfiguration(v.OutputConfiguration); err != nil {
			invalidParams.AddNested("OutputConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataAutomationProfileArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataAutomationProfileArn"))
	}
	if v.EncryptionConfiguration != nil {
		if err := validateEncryptionConfiguration(v.EncryptionConfiguration); err != nil {
			invalidParams.AddNested("EncryptionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpInvokeDataAutomationLibraryIngestionJobInput(v *InvokeDataAutomationLibraryIngestionJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InvokeDataAutomationLibraryIngestionJobInput"}
	if v.LibraryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LibraryArn"))
	}
	if v.InputConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputConfiguration"))
	} else if v.InputConfiguration != nil {
		if err := validateInputConfiguration(v.InputConfiguration); err != nil {
			invalidParams.AddNested("InputConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.EntityType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EntityType"))
	}
	if len(v.OperationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("OperationType"))
	}
	if v.OutputConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputConfiguration"))
	} else if v.OutputConfiguration != nil {
		if err := validateOutputConfiguration(v.OutputConfiguration); err != nil {
			invalidParams.AddNested("OutputConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.NotificationConfiguration != nil {
		if err := validateNotificationConfiguration(v.NotificationConfiguration); err != nil {
			invalidParams.AddNested("NotificationConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListBlueprintsInput(v *ListBlueprintsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListBlueprintsInput"}
	if v.ProjectFilter != nil {
		if err := validateDataAutomationProjectFilter(v.ProjectFilter); err != nil {
			invalidParams.AddNested("ProjectFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDataAutomationLibrariesInput(v *ListDataAutomationLibrariesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDataAutomationLibrariesInput"}
	if v.ProjectFilter != nil {
		if err := validateDataAutomationProjectFilter(v.ProjectFilter); err != nil {
			invalidParams.AddNested("ProjectFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDataAutomationLibraryEntitiesInput(v *ListDataAutomationLibraryEntitiesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDataAutomationLibraryEntitiesInput"}
	if v.LibraryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LibraryArn"))
	}
	if len(v.EntityType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EntityType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListDataAutomationProjectsInput(v *ListDataAutomationProjectsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDataAutomationProjectsInput"}
	if v.BlueprintFilter != nil {
		if err := validateBlueprintFilter(v.BlueprintFilter); err != nil {
			invalidParams.AddNested("BlueprintFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.LibraryFilter != nil {
		if err := validateDataAutomationLibraryFilter(v.LibraryFilter); err != nil {
			invalidParams.AddNested("LibraryFilter", err.(smithy.InvalidParamsError))
		}
	}
	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 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 validateOpUpdateBlueprintInput(v *UpdateBlueprintInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateBlueprintInput"}
	if v.BlueprintArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BlueprintArn"))
	}
	if v.Schema == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Schema"))
	}
	if v.EncryptionConfiguration != nil {
		if err := validateEncryptionConfiguration(v.EncryptionConfiguration); err != nil {
			invalidParams.AddNested("EncryptionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateDataAutomationProjectInput(v *UpdateDataAutomationProjectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDataAutomationProjectInput"}
	if v.ProjectArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProjectArn"))
	}
	if v.StandardOutputConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StandardOutputConfiguration"))
	} else if v.StandardOutputConfiguration != nil {
		if err := validateStandardOutputConfiguration(v.StandardOutputConfiguration); err != nil {
			invalidParams.AddNested("StandardOutputConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomOutputConfiguration != nil {
		if err := validateCustomOutputConfiguration(v.CustomOutputConfiguration); err != nil {
			invalidParams.AddNested("CustomOutputConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.OverrideConfiguration != nil {
		if err := validateOverrideConfiguration(v.OverrideConfiguration); err != nil {
			invalidParams.AddNested("OverrideConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataAutomationLibraryConfiguration != nil {
		if err := validateDataAutomationLibraryConfiguration(v.DataAutomationLibraryConfiguration); err != nil {
			invalidParams.AddNested("DataAutomationLibraryConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.EncryptionConfiguration != nil {
		if err := validateEncryptionConfiguration(v.EncryptionConfiguration); err != nil {
			invalidParams.AddNested("EncryptionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}
