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

package glue

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

type validateOpBatchCreatePartition struct {
}

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

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

type validateOpBatchDeleteConnection struct {
}

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

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

type validateOpBatchDeletePartition struct {
}

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

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

type validateOpBatchDeleteTable struct {
}

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

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

type validateOpBatchDeleteTableVersion struct {
}

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

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

type validateOpBatchGetBlueprints struct {
}

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

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

type validateOpBatchGetCrawlers struct {
}

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

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

type validateOpBatchGetCustomEntityTypes struct {
}

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

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

type validateOpBatchGetDataQualityResult struct {
}

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

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

type validateOpBatchGetDevEndpoints struct {
}

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

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

type validateOpBatchGetJobs struct {
}

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

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

type validateOpBatchGetPartition struct {
}

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

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

type validateOpBatchGetTriggers struct {
}

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

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

type validateOpBatchGetWorkflows struct {
}

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

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

type validateOpBatchStopJobRun struct {
}

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

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

type validateOpBatchUpdatePartition struct {
}

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

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

type validateOpCancelDataQualityRuleRecommendationRun struct {
}

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

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

type validateOpCancelDataQualityRulesetEvaluationRun struct {
}

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

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

type validateOpCancelMLTaskRun struct {
}

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

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

type validateOpCancelStatement struct {
}

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

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

type validateOpCheckSchemaVersionValidity struct {
}

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

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

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

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

type validateOpCreateConnection struct {
}

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

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

type validateOpCreateCrawler struct {
}

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

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

type validateOpCreateCustomEntityType struct {
}

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

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

type validateOpCreateDatabase struct {
}

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

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

type validateOpCreateDataQualityRuleset struct {
}

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

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

type validateOpCreateDevEndpoint struct {
}

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

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

type validateOpCreateJob struct {
}

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

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

type validateOpCreateMLTransform struct {
}

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

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

type validateOpCreatePartitionIndex struct {
}

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

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

type validateOpCreatePartition struct {
}

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

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

type validateOpCreateRegistry struct {
}

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

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

type validateOpCreateSchema struct {
}

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

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

type validateOpCreateScript struct {
}

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

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

type validateOpCreateSecurityConfiguration struct {
}

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

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

type validateOpCreateSession struct {
}

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

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

type validateOpCreateTable struct {
}

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

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

type validateOpCreateTrigger struct {
}

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

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

type validateOpCreateUserDefinedFunction struct {
}

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

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

type validateOpCreateWorkflow struct {
}

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

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

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

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

type validateOpDeleteColumnStatisticsForPartition struct {
}

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

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

type validateOpDeleteColumnStatisticsForTable struct {
}

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

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

type validateOpDeleteConnection struct {
}

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

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

type validateOpDeleteCrawler struct {
}

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

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

type validateOpDeleteCustomEntityType struct {
}

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

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

type validateOpDeleteDatabase struct {
}

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

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

type validateOpDeleteDataQualityRuleset struct {
}

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

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

type validateOpDeleteDevEndpoint struct {
}

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

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

type validateOpDeleteJob struct {
}

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

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

type validateOpDeleteMLTransform struct {
}

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

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

type validateOpDeletePartitionIndex struct {
}

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

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

type validateOpDeletePartition struct {
}

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

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

type validateOpDeleteRegistry struct {
}

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

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

type validateOpDeleteSchema struct {
}

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

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

type validateOpDeleteSchemaVersions struct {
}

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

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

type validateOpDeleteSecurityConfiguration struct {
}

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

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

type validateOpDeleteSession struct {
}

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

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

type validateOpDeleteTable struct {
}

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

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

type validateOpDeleteTableVersion struct {
}

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

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

type validateOpDeleteTrigger struct {
}

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

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

type validateOpDeleteUserDefinedFunction struct {
}

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

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

type validateOpDeleteWorkflow struct {
}

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

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

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

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

type validateOpGetBlueprintRuns struct {
}

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

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

type validateOpGetClassifier struct {
}

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

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

type validateOpGetColumnStatisticsForPartition struct {
}

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

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

type validateOpGetColumnStatisticsForTable struct {
}

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

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

type validateOpGetConnection struct {
}

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

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

type validateOpGetCrawler struct {
}

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

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

type validateOpGetCustomEntityType struct {
}

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

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

type validateOpGetDatabase struct {
}

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

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

type validateOpGetDataQualityResult struct {
}

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

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

type validateOpGetDataQualityRuleRecommendationRun struct {
}

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

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

type validateOpGetDataQualityRulesetEvaluationRun struct {
}

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

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

type validateOpGetDataQualityRuleset struct {
}

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

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

type validateOpGetDevEndpoint struct {
}

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

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

type validateOpGetJobBookmark struct {
}

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

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

type validateOpGetJob struct {
}

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

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

type validateOpGetJobRun struct {
}

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

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

type validateOpGetJobRuns struct {
}

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

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

type validateOpGetMapping struct {
}

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

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

type validateOpGetMLTaskRun struct {
}

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

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

type validateOpGetMLTaskRuns struct {
}

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

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

type validateOpGetMLTransform struct {
}

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

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

type validateOpGetMLTransforms struct {
}

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

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

type validateOpGetPartitionIndexes struct {
}

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

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

type validateOpGetPartition struct {
}

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

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

type validateOpGetPartitions struct {
}

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

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

type validateOpGetPlan struct {
}

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

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

type validateOpGetRegistry struct {
}

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

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

type validateOpGetSchemaByDefinition struct {
}

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

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

type validateOpGetSchema struct {
}

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

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

type validateOpGetSchemaVersionsDiff struct {
}

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

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

type validateOpGetSecurityConfiguration struct {
}

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

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

type validateOpGetSession struct {
}

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

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

type validateOpGetStatement struct {
}

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

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

type validateOpGetTable struct {
}

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

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

type validateOpGetTables struct {
}

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

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

type validateOpGetTableVersion struct {
}

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

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

type validateOpGetTableVersions struct {
}

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

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

type validateOpGetTags struct {
}

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

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

type validateOpGetTrigger struct {
}

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

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

type validateOpGetUnfilteredPartitionMetadata struct {
}

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

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

type validateOpGetUnfilteredPartitionsMetadata struct {
}

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

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

type validateOpGetUnfilteredTableMetadata struct {
}

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

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

type validateOpGetUserDefinedFunction struct {
}

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

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

type validateOpGetUserDefinedFunctions struct {
}

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

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

type validateOpGetWorkflow struct {
}

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

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

type validateOpGetWorkflowRun struct {
}

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

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

type validateOpGetWorkflowRunProperties struct {
}

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

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

type validateOpGetWorkflowRuns struct {
}

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

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

type validateOpListCrawls struct {
}

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

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

type validateOpListDataQualityResults struct {
}

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

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

type validateOpListDataQualityRuleRecommendationRuns struct {
}

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

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

type validateOpListDataQualityRulesetEvaluationRuns struct {
}

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

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

type validateOpListDataQualityRulesets struct {
}

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

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

type validateOpListMLTransforms struct {
}

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

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

type validateOpListSchemaVersions struct {
}

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

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

type validateOpListStatements struct {
}

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

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

type validateOpPutDataCatalogEncryptionSettings struct {
}

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

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

type validateOpPutResourcePolicy struct {
}

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

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

type validateOpPutSchemaVersionMetadata struct {
}

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

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

type validateOpPutWorkflowRunProperties struct {
}

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

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

type validateOpRegisterSchemaVersion struct {
}

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

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

type validateOpRemoveSchemaVersionMetadata struct {
}

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

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

type validateOpResetJobBookmark struct {
}

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

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

type validateOpResumeWorkflowRun struct {
}

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

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

type validateOpRunStatement struct {
}

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

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

type validateOpStartBlueprintRun struct {
}

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

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

type validateOpStartCrawler struct {
}

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

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

type validateOpStartCrawlerSchedule struct {
}

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

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

type validateOpStartDataQualityRuleRecommendationRun struct {
}

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

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

type validateOpStartDataQualityRulesetEvaluationRun struct {
}

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

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

type validateOpStartExportLabelsTaskRun struct {
}

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

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

type validateOpStartImportLabelsTaskRun struct {
}

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

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

type validateOpStartJobRun struct {
}

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

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

type validateOpStartMLEvaluationTaskRun struct {
}

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

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

type validateOpStartMLLabelingSetGenerationTaskRun struct {
}

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

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

type validateOpStartTrigger struct {
}

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

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

type validateOpStartWorkflowRun struct {
}

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

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

type validateOpStopCrawler struct {
}

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

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

type validateOpStopCrawlerSchedule struct {
}

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

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

type validateOpStopSession struct {
}

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

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

type validateOpStopTrigger struct {
}

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

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

type validateOpStopWorkflowRun struct {
}

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

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

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

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

type validateOpUpdateColumnStatisticsForPartition struct {
}

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

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

type validateOpUpdateColumnStatisticsForTable struct {
}

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

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

type validateOpUpdateConnection struct {
}

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

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

type validateOpUpdateCrawler struct {
}

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

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

type validateOpUpdateCrawlerSchedule struct {
}

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

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

type validateOpUpdateDatabase struct {
}

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

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

type validateOpUpdateDataQualityRuleset struct {
}

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

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

type validateOpUpdateDevEndpoint struct {
}

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

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

type validateOpUpdateJob struct {
}

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

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

type validateOpUpdateMLTransform struct {
}

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

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

type validateOpUpdatePartition struct {
}

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

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

type validateOpUpdateRegistry struct {
}

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

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

type validateOpUpdateSchema struct {
}

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

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

type validateOpUpdateTable struct {
}

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

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

type validateOpUpdateTrigger struct {
}

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

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

type validateOpUpdateUserDefinedFunction struct {
}

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

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

type validateOpUpdateWorkflow struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpStopWorkflowRunValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStopWorkflowRun{}, 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 addOpUpdateClassifierValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateClassifier{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateAggregate(v *types.Aggregate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Aggregate"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.Groups == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Groups"))
	}
	if v.Aggs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Aggs"))
	} else if v.Aggs != nil {
		if err := validateAggregateOperations(v.Aggs); err != nil {
			invalidParams.AddNested("Aggs", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAggregateOperation(v *types.AggregateOperation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AggregateOperation"}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	}
	if len(v.AggFunc) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AggFunc"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateAthenaConnectorSource(v *types.AthenaConnectorSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AthenaConnectorSource"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ConnectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionName"))
	}
	if v.ConnectorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectorName"))
	}
	if v.ConnectionType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionType"))
	}
	if v.SchemaName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaName"))
	}
	if v.OutputSchemas != nil {
		if err := validateGlueSchemas(v.OutputSchemas); err != nil {
			invalidParams.AddNested("OutputSchemas", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBasicCatalogTarget(v *types.BasicCatalogTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BasicCatalogTarget"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if v.Table == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Table"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateBatchUpdatePartitionRequestEntry(v *types.BatchUpdatePartitionRequestEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchUpdatePartitionRequestEntry"}
	if v.PartitionValueList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartitionValueList"))
	}
	if v.PartitionInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartitionInput"))
	} else if v.PartitionInput != nil {
		if err := validatePartitionInput(v.PartitionInput); err != nil {
			invalidParams.AddNested("PartitionInput", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateCatalogDeltaSource(v *types.CatalogDeltaSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CatalogDeltaSource"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if v.Table == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Table"))
	}
	if v.OutputSchemas != nil {
		if err := validateGlueSchemas(v.OutputSchemas); err != nil {
			invalidParams.AddNested("OutputSchemas", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateCatalogHudiSource(v *types.CatalogHudiSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CatalogHudiSource"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if v.Table == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Table"))
	}
	if v.OutputSchemas != nil {
		if err := validateGlueSchemas(v.OutputSchemas); err != nil {
			invalidParams.AddNested("OutputSchemas", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateCatalogTarget(v *types.CatalogTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CatalogTarget"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.Tables == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tables"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCodeGenConfigurationNode(v *types.CodeGenConfigurationNode) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CodeGenConfigurationNode"}
	if v.AthenaConnectorSource != nil {
		if err := validateAthenaConnectorSource(v.AthenaConnectorSource); err != nil {
			invalidParams.AddNested("AthenaConnectorSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.JDBCConnectorSource != nil {
		if err := validateJDBCConnectorSource(v.JDBCConnectorSource); err != nil {
			invalidParams.AddNested("JDBCConnectorSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.SparkConnectorSource != nil {
		if err := validateSparkConnectorSource(v.SparkConnectorSource); err != nil {
			invalidParams.AddNested("SparkConnectorSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.CatalogSource != nil {
		if err := validateCatalogSource(v.CatalogSource); err != nil {
			invalidParams.AddNested("CatalogSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.RedshiftSource != nil {
		if err := validateRedshiftSource(v.RedshiftSource); err != nil {
			invalidParams.AddNested("RedshiftSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3CatalogSource != nil {
		if err := validateS3CatalogSource(v.S3CatalogSource); err != nil {
			invalidParams.AddNested("S3CatalogSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3CsvSource != nil {
		if err := validateS3CsvSource(v.S3CsvSource); err != nil {
			invalidParams.AddNested("S3CsvSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3JsonSource != nil {
		if err := validateS3JsonSource(v.S3JsonSource); err != nil {
			invalidParams.AddNested("S3JsonSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3ParquetSource != nil {
		if err := validateS3ParquetSource(v.S3ParquetSource); err != nil {
			invalidParams.AddNested("S3ParquetSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.RelationalCatalogSource != nil {
		if err := validateRelationalCatalogSource(v.RelationalCatalogSource); err != nil {
			invalidParams.AddNested("RelationalCatalogSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.DynamoDBCatalogSource != nil {
		if err := validateDynamoDBCatalogSource(v.DynamoDBCatalogSource); err != nil {
			invalidParams.AddNested("DynamoDBCatalogSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.JDBCConnectorTarget != nil {
		if err := validateJDBCConnectorTarget(v.JDBCConnectorTarget); err != nil {
			invalidParams.AddNested("JDBCConnectorTarget", err.(smithy.InvalidParamsError))
		}
	}
	if v.SparkConnectorTarget != nil {
		if err := validateSparkConnectorTarget(v.SparkConnectorTarget); err != nil {
			invalidParams.AddNested("SparkConnectorTarget", err.(smithy.InvalidParamsError))
		}
	}
	if v.CatalogTarget != nil {
		if err := validateBasicCatalogTarget(v.CatalogTarget); err != nil {
			invalidParams.AddNested("CatalogTarget", err.(smithy.InvalidParamsError))
		}
	}
	if v.RedshiftTarget != nil {
		if err := validateRedshiftTarget(v.RedshiftTarget); err != nil {
			invalidParams.AddNested("RedshiftTarget", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3CatalogTarget != nil {
		if err := validateS3CatalogTarget(v.S3CatalogTarget); err != nil {
			invalidParams.AddNested("S3CatalogTarget", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3GlueParquetTarget != nil {
		if err := validateS3GlueParquetTarget(v.S3GlueParquetTarget); err != nil {
			invalidParams.AddNested("S3GlueParquetTarget", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3DirectTarget != nil {
		if err := validateS3DirectTarget(v.S3DirectTarget); err != nil {
			invalidParams.AddNested("S3DirectTarget", err.(smithy.InvalidParamsError))
		}
	}
	if v.ApplyMapping != nil {
		if err := validateApplyMapping(v.ApplyMapping); err != nil {
			invalidParams.AddNested("ApplyMapping", err.(smithy.InvalidParamsError))
		}
	}
	if v.SelectFields != nil {
		if err := validateSelectFields(v.SelectFields); err != nil {
			invalidParams.AddNested("SelectFields", err.(smithy.InvalidParamsError))
		}
	}
	if v.DropFields != nil {
		if err := validateDropFields(v.DropFields); err != nil {
			invalidParams.AddNested("DropFields", err.(smithy.InvalidParamsError))
		}
	}
	if v.RenameField != nil {
		if err := validateRenameField(v.RenameField); err != nil {
			invalidParams.AddNested("RenameField", err.(smithy.InvalidParamsError))
		}
	}
	if v.Spigot != nil {
		if err := validateSpigot(v.Spigot); err != nil {
			invalidParams.AddNested("Spigot", err.(smithy.InvalidParamsError))
		}
	}
	if v.Join != nil {
		if err := validateJoin(v.Join); err != nil {
			invalidParams.AddNested("Join", err.(smithy.InvalidParamsError))
		}
	}
	if v.SplitFields != nil {
		if err := validateSplitFields(v.SplitFields); err != nil {
			invalidParams.AddNested("SplitFields", err.(smithy.InvalidParamsError))
		}
	}
	if v.SelectFromCollection != nil {
		if err := validateSelectFromCollection(v.SelectFromCollection); err != nil {
			invalidParams.AddNested("SelectFromCollection", err.(smithy.InvalidParamsError))
		}
	}
	if v.FillMissingValues != nil {
		if err := validateFillMissingValues(v.FillMissingValues); err != nil {
			invalidParams.AddNested("FillMissingValues", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filter != nil {
		if err := validateFilter(v.Filter); err != nil {
			invalidParams.AddNested("Filter", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomCode != nil {
		if err := validateCustomCode(v.CustomCode); err != nil {
			invalidParams.AddNested("CustomCode", err.(smithy.InvalidParamsError))
		}
	}
	if v.SparkSQL != nil {
		if err := validateSparkSQL(v.SparkSQL); err != nil {
			invalidParams.AddNested("SparkSQL", err.(smithy.InvalidParamsError))
		}
	}
	if v.DirectKinesisSource != nil {
		if err := validateDirectKinesisSource(v.DirectKinesisSource); err != nil {
			invalidParams.AddNested("DirectKinesisSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.DirectKafkaSource != nil {
		if err := validateDirectKafkaSource(v.DirectKafkaSource); err != nil {
			invalidParams.AddNested("DirectKafkaSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.CatalogKinesisSource != nil {
		if err := validateCatalogKinesisSource(v.CatalogKinesisSource); err != nil {
			invalidParams.AddNested("CatalogKinesisSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.CatalogKafkaSource != nil {
		if err := validateCatalogKafkaSource(v.CatalogKafkaSource); err != nil {
			invalidParams.AddNested("CatalogKafkaSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.DropNullFields != nil {
		if err := validateDropNullFields(v.DropNullFields); err != nil {
			invalidParams.AddNested("DropNullFields", err.(smithy.InvalidParamsError))
		}
	}
	if v.Merge != nil {
		if err := validateMerge(v.Merge); err != nil {
			invalidParams.AddNested("Merge", err.(smithy.InvalidParamsError))
		}
	}
	if v.Union != nil {
		if err := validateUnion(v.Union); err != nil {
			invalidParams.AddNested("Union", err.(smithy.InvalidParamsError))
		}
	}
	if v.PIIDetection != nil {
		if err := validatePIIDetection(v.PIIDetection); err != nil {
			invalidParams.AddNested("PIIDetection", err.(smithy.InvalidParamsError))
		}
	}
	if v.Aggregate != nil {
		if err := validateAggregate(v.Aggregate); err != nil {
			invalidParams.AddNested("Aggregate", err.(smithy.InvalidParamsError))
		}
	}
	if v.DropDuplicates != nil {
		if err := validateDropDuplicates(v.DropDuplicates); err != nil {
			invalidParams.AddNested("DropDuplicates", err.(smithy.InvalidParamsError))
		}
	}
	if v.GovernedCatalogTarget != nil {
		if err := validateGovernedCatalogTarget(v.GovernedCatalogTarget); err != nil {
			invalidParams.AddNested("GovernedCatalogTarget", err.(smithy.InvalidParamsError))
		}
	}
	if v.GovernedCatalogSource != nil {
		if err := validateGovernedCatalogSource(v.GovernedCatalogSource); err != nil {
			invalidParams.AddNested("GovernedCatalogSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.MicrosoftSQLServerCatalogSource != nil {
		if err := validateMicrosoftSQLServerCatalogSource(v.MicrosoftSQLServerCatalogSource); err != nil {
			invalidParams.AddNested("MicrosoftSQLServerCatalogSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.MySQLCatalogSource != nil {
		if err := validateMySQLCatalogSource(v.MySQLCatalogSource); err != nil {
			invalidParams.AddNested("MySQLCatalogSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.OracleSQLCatalogSource != nil {
		if err := validateOracleSQLCatalogSource(v.OracleSQLCatalogSource); err != nil {
			invalidParams.AddNested("OracleSQLCatalogSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.PostgreSQLCatalogSource != nil {
		if err := validatePostgreSQLCatalogSource(v.PostgreSQLCatalogSource); err != nil {
			invalidParams.AddNested("PostgreSQLCatalogSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.MicrosoftSQLServerCatalogTarget != nil {
		if err := validateMicrosoftSQLServerCatalogTarget(v.MicrosoftSQLServerCatalogTarget); err != nil {
			invalidParams.AddNested("MicrosoftSQLServerCatalogTarget", err.(smithy.InvalidParamsError))
		}
	}
	if v.MySQLCatalogTarget != nil {
		if err := validateMySQLCatalogTarget(v.MySQLCatalogTarget); err != nil {
			invalidParams.AddNested("MySQLCatalogTarget", err.(smithy.InvalidParamsError))
		}
	}
	if v.OracleSQLCatalogTarget != nil {
		if err := validateOracleSQLCatalogTarget(v.OracleSQLCatalogTarget); err != nil {
			invalidParams.AddNested("OracleSQLCatalogTarget", err.(smithy.InvalidParamsError))
		}
	}
	if v.PostgreSQLCatalogTarget != nil {
		if err := validatePostgreSQLCatalogTarget(v.PostgreSQLCatalogTarget); err != nil {
			invalidParams.AddNested("PostgreSQLCatalogTarget", err.(smithy.InvalidParamsError))
		}
	}
	if v.DynamicTransform != nil {
		if err := validateDynamicTransform(v.DynamicTransform); err != nil {
			invalidParams.AddNested("DynamicTransform", err.(smithy.InvalidParamsError))
		}
	}
	if v.EvaluateDataQuality != nil {
		if err := validateEvaluateDataQuality(v.EvaluateDataQuality); err != nil {
			invalidParams.AddNested("EvaluateDataQuality", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3CatalogHudiSource != nil {
		if err := validateS3CatalogHudiSource(v.S3CatalogHudiSource); err != nil {
			invalidParams.AddNested("S3CatalogHudiSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.CatalogHudiSource != nil {
		if err := validateCatalogHudiSource(v.CatalogHudiSource); err != nil {
			invalidParams.AddNested("CatalogHudiSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3HudiSource != nil {
		if err := validateS3HudiSource(v.S3HudiSource); err != nil {
			invalidParams.AddNested("S3HudiSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3HudiCatalogTarget != nil {
		if err := validateS3HudiCatalogTarget(v.S3HudiCatalogTarget); err != nil {
			invalidParams.AddNested("S3HudiCatalogTarget", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3HudiDirectTarget != nil {
		if err := validateS3HudiDirectTarget(v.S3HudiDirectTarget); err != nil {
			invalidParams.AddNested("S3HudiDirectTarget", err.(smithy.InvalidParamsError))
		}
	}
	if v.DirectJDBCSource != nil {
		if err := validateDirectJDBCSource(v.DirectJDBCSource); err != nil {
			invalidParams.AddNested("DirectJDBCSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3CatalogDeltaSource != nil {
		if err := validateS3CatalogDeltaSource(v.S3CatalogDeltaSource); err != nil {
			invalidParams.AddNested("S3CatalogDeltaSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.CatalogDeltaSource != nil {
		if err := validateCatalogDeltaSource(v.CatalogDeltaSource); err != nil {
			invalidParams.AddNested("CatalogDeltaSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3DeltaSource != nil {
		if err := validateS3DeltaSource(v.S3DeltaSource); err != nil {
			invalidParams.AddNested("S3DeltaSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3DeltaCatalogTarget != nil {
		if err := validateS3DeltaCatalogTarget(v.S3DeltaCatalogTarget); err != nil {
			invalidParams.AddNested("S3DeltaCatalogTarget", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3DeltaDirectTarget != nil {
		if err := validateS3DeltaDirectTarget(v.S3DeltaDirectTarget); err != nil {
			invalidParams.AddNested("S3DeltaDirectTarget", err.(smithy.InvalidParamsError))
		}
	}
	if v.EvaluateDataQualityMultiFrame != nil {
		if err := validateEvaluateDataQualityMultiFrame(v.EvaluateDataQualityMultiFrame); err != nil {
			invalidParams.AddNested("EvaluateDataQualityMultiFrame", err.(smithy.InvalidParamsError))
		}
	}
	if v.Recipe != nil {
		if err := validateRecipe(v.Recipe); err != nil {
			invalidParams.AddNested("Recipe", err.(smithy.InvalidParamsError))
		}
	}
	if v.SnowflakeSource != nil {
		if err := validateSnowflakeSource(v.SnowflakeSource); err != nil {
			invalidParams.AddNested("SnowflakeSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.SnowflakeTarget != nil {
		if err := validateSnowflakeTarget(v.SnowflakeTarget); err != nil {
			invalidParams.AddNested("SnowflakeTarget", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCodeGenEdge(v *types.CodeGenEdge) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CodeGenEdge"}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	}
	if v.Target == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Target"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCodeGenNode(v *types.CodeGenNode) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CodeGenNode"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.NodeType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NodeType"))
	}
	if v.Args == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Args"))
	} else if v.Args != nil {
		if err := validateCodeGenNodeArgs(v.Args); err != nil {
			invalidParams.AddNested("Args", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateColumnStatistics(v *types.ColumnStatistics) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ColumnStatistics"}
	if v.ColumnName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnName"))
	}
	if v.ColumnType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnType"))
	}
	if v.AnalyzedTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnalyzedTime"))
	}
	if v.StatisticsData == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StatisticsData"))
	} else if v.StatisticsData != nil {
		if err := validateColumnStatisticsData(v.StatisticsData); err != nil {
			invalidParams.AddNested("StatisticsData", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateColumnStatisticsData(v *types.ColumnStatisticsData) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ColumnStatisticsData"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.BooleanColumnStatisticsData != nil {
		if err := validateBooleanColumnStatisticsData(v.BooleanColumnStatisticsData); err != nil {
			invalidParams.AddNested("BooleanColumnStatisticsData", err.(smithy.InvalidParamsError))
		}
	}
	if v.DateColumnStatisticsData != nil {
		if err := validateDateColumnStatisticsData(v.DateColumnStatisticsData); err != nil {
			invalidParams.AddNested("DateColumnStatisticsData", err.(smithy.InvalidParamsError))
		}
	}
	if v.DecimalColumnStatisticsData != nil {
		if err := validateDecimalColumnStatisticsData(v.DecimalColumnStatisticsData); err != nil {
			invalidParams.AddNested("DecimalColumnStatisticsData", err.(smithy.InvalidParamsError))
		}
	}
	if v.DoubleColumnStatisticsData != nil {
		if err := validateDoubleColumnStatisticsData(v.DoubleColumnStatisticsData); err != nil {
			invalidParams.AddNested("DoubleColumnStatisticsData", err.(smithy.InvalidParamsError))
		}
	}
	if v.LongColumnStatisticsData != nil {
		if err := validateLongColumnStatisticsData(v.LongColumnStatisticsData); err != nil {
			invalidParams.AddNested("LongColumnStatisticsData", err.(smithy.InvalidParamsError))
		}
	}
	if v.StringColumnStatisticsData != nil {
		if err := validateStringColumnStatisticsData(v.StringColumnStatisticsData); err != nil {
			invalidParams.AddNested("StringColumnStatisticsData", err.(smithy.InvalidParamsError))
		}
	}
	if v.BinaryColumnStatisticsData != nil {
		if err := validateBinaryColumnStatisticsData(v.BinaryColumnStatisticsData); err != nil {
			invalidParams.AddNested("BinaryColumnStatisticsData", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConnectionInput(v *types.ConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConnectionInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.ConnectionType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionType"))
	}
	if v.ConnectionProperties == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionProperties"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCrawlerTargets(v *types.CrawlerTargets) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CrawlerTargets"}
	if v.CatalogTargets != nil {
		if err := validateCatalogTargetList(v.CatalogTargets); err != nil {
			invalidParams.AddNested("CatalogTargets", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateCustomCode(v *types.CustomCode) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomCode"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.Code == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Code"))
	}
	if v.ClassName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClassName"))
	}
	if v.OutputSchemas != nil {
		if err := validateGlueSchemas(v.OutputSchemas); err != nil {
			invalidParams.AddNested("OutputSchemas", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateDataCatalogEncryptionSettings(v *types.DataCatalogEncryptionSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataCatalogEncryptionSettings"}
	if v.EncryptionAtRest != nil {
		if err := validateEncryptionAtRest(v.EncryptionAtRest); err != nil {
			invalidParams.AddNested("EncryptionAtRest", err.(smithy.InvalidParamsError))
		}
	}
	if v.ConnectionPasswordEncryption != nil {
		if err := validateConnectionPasswordEncryption(v.ConnectionPasswordEncryption); err != nil {
			invalidParams.AddNested("ConnectionPasswordEncryption", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDataQualityResultFilterCriteria(v *types.DataQualityResultFilterCriteria) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataQualityResultFilterCriteria"}
	if v.DataSource != nil {
		if err := validateDataSource(v.DataSource); err != nil {
			invalidParams.AddNested("DataSource", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateDataQualityRulesetFilterCriteria(v *types.DataQualityRulesetFilterCriteria) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataQualityRulesetFilterCriteria"}
	if v.TargetTable != nil {
		if err := validateDataQualityTargetTable(v.TargetTable); err != nil {
			invalidParams.AddNested("TargetTable", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateDecimalColumnStatisticsData(v *types.DecimalColumnStatisticsData) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DecimalColumnStatisticsData"}
	if v.MinimumValue != nil {
		if err := validateDecimalNumber(v.MinimumValue); err != nil {
			invalidParams.AddNested("MinimumValue", err.(smithy.InvalidParamsError))
		}
	}
	if v.MaximumValue != nil {
		if err := validateDecimalNumber(v.MaximumValue); err != nil {
			invalidParams.AddNested("MaximumValue", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDirectJDBCSource(v *types.DirectJDBCSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DirectJDBCSource"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if v.Table == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Table"))
	}
	if v.ConnectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionName"))
	}
	if len(v.ConnectionType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateDropNullFields(v *types.DropNullFields) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DropNullFields"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.NullTextList != nil {
		if err := validateNullValueFields(v.NullTextList); err != nil {
			invalidParams.AddNested("NullTextList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDynamicTransform(v *types.DynamicTransform) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DynamicTransform"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.TransformName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransformName"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.Parameters != nil {
		if err := validateTransformConfigParameterList(v.Parameters); err != nil {
			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.FunctionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if v.Path == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Path"))
	}
	if v.OutputSchemas != nil {
		if err := validateGlueSchemas(v.OutputSchemas); err != nil {
			invalidParams.AddNested("OutputSchemas", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateFilter(v *types.Filter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Filter"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if len(v.LogicalOperator) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LogicalOperator"))
	}
	if v.Filters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
	} else if v.Filters != nil {
		if err := validateFilterExpressions(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFilterExpression(v *types.FilterExpression) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilterExpression"}
	if len(v.Operation) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Operation"))
	}
	if v.Values == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Values"))
	} else if v.Values != nil {
		if err := validateFilterValues(v.Values); err != nil {
			invalidParams.AddNested("Values", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateGlueSchema(v *types.GlueSchema) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GlueSchema"}
	if v.Columns != nil {
		if err := validateGlueStudioSchemaColumnList(v.Columns); err != nil {
			invalidParams.AddNested("Columns", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateGovernedCatalogTarget(v *types.GovernedCatalogTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GovernedCatalogTarget"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.Table == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Table"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateJDBCConnectorSource(v *types.JDBCConnectorSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "JDBCConnectorSource"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ConnectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionName"))
	}
	if v.ConnectorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectorName"))
	}
	if v.ConnectionType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionType"))
	}
	if v.OutputSchemas != nil {
		if err := validateGlueSchemas(v.OutputSchemas); err != nil {
			invalidParams.AddNested("OutputSchemas", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateJDBCConnectorTarget(v *types.JDBCConnectorTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "JDBCConnectorTarget"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.ConnectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionName"))
	}
	if v.ConnectionTable == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionTable"))
	}
	if v.ConnectorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectorName"))
	}
	if v.ConnectionType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionType"))
	}
	if v.OutputSchemas != nil {
		if err := validateGlueSchemas(v.OutputSchemas); err != nil {
			invalidParams.AddNested("OutputSchemas", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateJobUpdate(v *types.JobUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "JobUpdate"}
	if v.CodeGenConfigurationNodes != nil {
		if err := validateCodeGenConfigurationNodes(v.CodeGenConfigurationNodes); err != nil {
			invalidParams.AddNested("CodeGenConfigurationNodes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateJoin(v *types.Join) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Join"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if len(v.JoinType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("JoinType"))
	}
	if v.Columns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Columns"))
	} else if v.Columns != nil {
		if err := validateJoinColumns(v.Columns); err != nil {
			invalidParams.AddNested("Columns", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateLocation(v *types.Location) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Location"}
	if v.Jdbc != nil {
		if err := validateCodeGenNodeArgs(v.Jdbc); err != nil {
			invalidParams.AddNested("Jdbc", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3 != nil {
		if err := validateCodeGenNodeArgs(v.S3); err != nil {
			invalidParams.AddNested("S3", err.(smithy.InvalidParamsError))
		}
	}
	if v.DynamoDB != nil {
		if err := validateCodeGenNodeArgs(v.DynamoDB); err != nil {
			invalidParams.AddNested("DynamoDB", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateMerge(v *types.Merge) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Merge"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	}
	if v.PrimaryKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrimaryKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateMicrosoftSQLServerCatalogTarget(v *types.MicrosoftSQLServerCatalogTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MicrosoftSQLServerCatalogTarget"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if v.Table == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Table"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateMySQLCatalogTarget(v *types.MySQLCatalogTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MySQLCatalogTarget"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if v.Table == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Table"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNullValueField(v *types.NullValueField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NullValueField"}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if v.Datatype == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Datatype"))
	} else if v.Datatype != nil {
		if err := validateDatatype(v.Datatype); err != nil {
			invalidParams.AddNested("Datatype", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpenTableFormatInput(v *types.OpenTableFormatInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OpenTableFormatInput"}
	if v.IcebergInput != nil {
		if err := validateIcebergInput(v.IcebergInput); err != nil {
			invalidParams.AddNested("IcebergInput", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOracleSQLCatalogTarget(v *types.OracleSQLCatalogTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OracleSQLCatalogTarget"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if v.Table == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Table"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validatePartitionInput(v *types.PartitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PartitionInput"}
	if v.StorageDescriptor != nil {
		if err := validateStorageDescriptor(v.StorageDescriptor); err != nil {
			invalidParams.AddNested("StorageDescriptor", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validatePIIDetection(v *types.PIIDetection) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PIIDetection"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if len(v.PiiType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PiiType"))
	}
	if v.EntityTypesToDetect == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityTypesToDetect"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validatePostgreSQLCatalogTarget(v *types.PostgreSQLCatalogTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PostgreSQLCatalogTarget"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if v.Table == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Table"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRecipe(v *types.Recipe) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Recipe"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.RecipeReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecipeReference"))
	} else if v.RecipeReference != nil {
		if err := validateRecipeReference(v.RecipeReference); err != nil {
			invalidParams.AddNested("RecipeReference", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRecipeReference(v *types.RecipeReference) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RecipeReference"}
	if v.RecipeArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecipeArn"))
	}
	if v.RecipeVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecipeVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRedshiftTarget(v *types.RedshiftTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RedshiftTarget"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if v.Table == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Table"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRenameField(v *types.RenameField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RenameField"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.SourcePath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourcePath"))
	}
	if v.TargetPath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetPath"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3CatalogDeltaSource(v *types.S3CatalogDeltaSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3CatalogDeltaSource"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if v.Table == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Table"))
	}
	if v.OutputSchemas != nil {
		if err := validateGlueSchemas(v.OutputSchemas); err != nil {
			invalidParams.AddNested("OutputSchemas", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3CatalogHudiSource(v *types.S3CatalogHudiSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3CatalogHudiSource"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if v.Table == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Table"))
	}
	if v.OutputSchemas != nil {
		if err := validateGlueSchemas(v.OutputSchemas); err != nil {
			invalidParams.AddNested("OutputSchemas", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateS3CatalogTarget(v *types.S3CatalogTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3CatalogTarget"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.Table == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Table"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3CsvSource(v *types.S3CsvSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3CsvSource"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Paths == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Paths"))
	}
	if len(v.Separator) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Separator"))
	}
	if len(v.QuoteChar) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("QuoteChar"))
	}
	if v.OutputSchemas != nil {
		if err := validateGlueSchemas(v.OutputSchemas); err != nil {
			invalidParams.AddNested("OutputSchemas", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3DeltaCatalogTarget(v *types.S3DeltaCatalogTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3DeltaCatalogTarget"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.Table == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Table"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3DeltaDirectTarget(v *types.S3DeltaDirectTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3DeltaDirectTarget"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.Path == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Path"))
	}
	if len(v.Compression) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Compression"))
	}
	if len(v.Format) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Format"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3DeltaSource(v *types.S3DeltaSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3DeltaSource"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Paths == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Paths"))
	}
	if v.OutputSchemas != nil {
		if err := validateGlueSchemas(v.OutputSchemas); err != nil {
			invalidParams.AddNested("OutputSchemas", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3DirectTarget(v *types.S3DirectTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3DirectTarget"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.Path == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Path"))
	}
	if len(v.Format) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Format"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateS3HudiCatalogTarget(v *types.S3HudiCatalogTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3HudiCatalogTarget"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.Table == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Table"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if v.AdditionalOptions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AdditionalOptions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3HudiDirectTarget(v *types.S3HudiDirectTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3HudiDirectTarget"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.Path == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Path"))
	}
	if len(v.Compression) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Compression"))
	}
	if len(v.Format) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Format"))
	}
	if v.AdditionalOptions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AdditionalOptions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3HudiSource(v *types.S3HudiSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3HudiSource"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Paths == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Paths"))
	}
	if v.OutputSchemas != nil {
		if err := validateGlueSchemas(v.OutputSchemas); err != nil {
			invalidParams.AddNested("OutputSchemas", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3JsonSource(v *types.S3JsonSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3JsonSource"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Paths == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Paths"))
	}
	if v.OutputSchemas != nil {
		if err := validateGlueSchemas(v.OutputSchemas); err != nil {
			invalidParams.AddNested("OutputSchemas", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3ParquetSource(v *types.S3ParquetSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3ParquetSource"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Paths == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Paths"))
	}
	if v.OutputSchemas != nil {
		if err := validateGlueSchemas(v.OutputSchemas); err != nil {
			invalidParams.AddNested("OutputSchemas", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateSnowflakeSource(v *types.SnowflakeSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SnowflakeSource"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Data == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Data"))
	}
	if v.OutputSchemas != nil {
		if err := validateGlueSchemas(v.OutputSchemas); err != nil {
			invalidParams.AddNested("OutputSchemas", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSparkConnectorSource(v *types.SparkConnectorSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SparkConnectorSource"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ConnectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionName"))
	}
	if v.ConnectorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectorName"))
	}
	if v.ConnectionType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionType"))
	}
	if v.OutputSchemas != nil {
		if err := validateGlueSchemas(v.OutputSchemas); err != nil {
			invalidParams.AddNested("OutputSchemas", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSparkConnectorTarget(v *types.SparkConnectorTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SparkConnectorTarget"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.ConnectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionName"))
	}
	if v.ConnectorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectorName"))
	}
	if v.ConnectionType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionType"))
	}
	if v.OutputSchemas != nil {
		if err := validateGlueSchemas(v.OutputSchemas); err != nil {
			invalidParams.AddNested("OutputSchemas", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSparkSQL(v *types.SparkSQL) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SparkSQL"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if v.SqlQuery == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SqlQuery"))
	}
	if v.SqlAliases == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SqlAliases"))
	} else if v.SqlAliases != nil {
		if err := validateSqlAliases(v.SqlAliases); err != nil {
			invalidParams.AddNested("SqlAliases", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputSchemas != nil {
		if err := validateGlueSchemas(v.OutputSchemas); err != nil {
			invalidParams.AddNested("OutputSchemas", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateSqlAlias(v *types.SqlAlias) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SqlAlias"}
	if v.From == nil {
		invalidParams.Add(smithy.NewErrParamRequired("From"))
	}
	if v.Alias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Alias"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateStorageDescriptor(v *types.StorageDescriptor) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StorageDescriptor"}
	if v.Columns != nil {
		if err := validateColumnList(v.Columns); err != nil {
			invalidParams.AddNested("Columns", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortColumns != nil {
		if err := validateOrderList(v.SortColumns); err != nil {
			invalidParams.AddNested("SortColumns", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTableInput(v *types.TableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TableInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.StorageDescriptor != nil {
		if err := validateStorageDescriptor(v.StorageDescriptor); err != nil {
			invalidParams.AddNested("StorageDescriptor", err.(smithy.InvalidParamsError))
		}
	}
	if v.PartitionKeys != nil {
		if err := validateColumnList(v.PartitionKeys); err != nil {
			invalidParams.AddNested("PartitionKeys", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTaskRunSortCriteria(v *types.TaskRunSortCriteria) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TaskRunSortCriteria"}
	if len(v.Column) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	}
	if len(v.SortDirection) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SortDirection"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTransformConfigParameter(v *types.TransformConfigParameter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TransformConfigParameter"}
	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 validateTransformConfigParameterList(v []types.TransformConfigParameter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TransformConfigParameterList"}
	for i := range v {
		if err := validateTransformConfigParameter(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTransformEncryption(v *types.TransformEncryption) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TransformEncryption"}
	if v.MlUserDataEncryption != nil {
		if err := validateMLUserDataEncryption(v.MlUserDataEncryption); err != nil {
			invalidParams.AddNested("MlUserDataEncryption", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTransformSortCriteria(v *types.TransformSortCriteria) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TransformSortCriteria"}
	if len(v.Column) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	}
	if len(v.SortDirection) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SortDirection"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTriggerUpdate(v *types.TriggerUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TriggerUpdate"}
	if v.EventBatchingCondition != nil {
		if err := validateEventBatchingCondition(v.EventBatchingCondition); err != nil {
			invalidParams.AddNested("EventBatchingCondition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateUnion(v *types.Union) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Union"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Inputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Inputs"))
	}
	if len(v.UnionType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("UnionType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpBatchCreatePartitionInput(v *BatchCreatePartitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchCreatePartitionInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.PartitionInputList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartitionInputList"))
	} else if v.PartitionInputList != nil {
		if err := validatePartitionInputList(v.PartitionInputList); err != nil {
			invalidParams.AddNested("PartitionInputList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpBatchDeletePartitionInput(v *BatchDeletePartitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDeletePartitionInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.PartitionsToDelete == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartitionsToDelete"))
	} else if v.PartitionsToDelete != nil {
		if err := validateBatchDeletePartitionValueList(v.PartitionsToDelete); err != nil {
			invalidParams.AddNested("PartitionsToDelete", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchDeleteTableInput(v *BatchDeleteTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteTableInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TablesToDelete == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TablesToDelete"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchDeleteTableVersionInput(v *BatchDeleteTableVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteTableVersionInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.VersionIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VersionIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateOpBatchGetPartitionInput(v *BatchGetPartitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetPartitionInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.PartitionsToGet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartitionsToGet"))
	} else if v.PartitionsToGet != nil {
		if err := validateBatchGetPartitionValueList(v.PartitionsToGet); err != nil {
			invalidParams.AddNested("PartitionsToGet", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpBatchStopJobRunInput(v *BatchStopJobRunInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchStopJobRunInput"}
	if v.JobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobName"))
	}
	if v.JobRunIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobRunIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchUpdatePartitionInput(v *BatchUpdatePartitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchUpdatePartitionInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.Entries == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Entries"))
	} else if v.Entries != nil {
		if err := validateBatchUpdatePartitionRequestEntryList(v.Entries); err != nil {
			invalidParams.AddNested("Entries", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpCancelMLTaskRunInput(v *CancelMLTaskRunInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelMLTaskRunInput"}
	if v.TransformId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransformId"))
	}
	if v.TaskRunId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskRunId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCheckSchemaVersionValidityInput(v *CheckSchemaVersionValidityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CheckSchemaVersionValidityInput"}
	if len(v.DataFormat) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DataFormat"))
	}
	if v.SchemaDefinition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaDefinition"))
	}
	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.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.BlueprintLocation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BlueprintLocation"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateClassifierInput(v *CreateClassifierInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateClassifierInput"}
	if v.GrokClassifier != nil {
		if err := validateCreateGrokClassifierRequest(v.GrokClassifier); err != nil {
			invalidParams.AddNested("GrokClassifier", err.(smithy.InvalidParamsError))
		}
	}
	if v.XMLClassifier != nil {
		if err := validateCreateXMLClassifierRequest(v.XMLClassifier); err != nil {
			invalidParams.AddNested("XMLClassifier", err.(smithy.InvalidParamsError))
		}
	}
	if v.JsonClassifier != nil {
		if err := validateCreateJsonClassifierRequest(v.JsonClassifier); err != nil {
			invalidParams.AddNested("JsonClassifier", err.(smithy.InvalidParamsError))
		}
	}
	if v.CsvClassifier != nil {
		if err := validateCreateCsvClassifierRequest(v.CsvClassifier); err != nil {
			invalidParams.AddNested("CsvClassifier", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateConnectionInput(v *CreateConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionInput"}
	if v.ConnectionInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionInput"))
	} else if v.ConnectionInput != nil {
		if err := validateConnectionInput(v.ConnectionInput); err != nil {
			invalidParams.AddNested("ConnectionInput", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCrawlerInput(v *CreateCrawlerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCrawlerInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Role == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Role"))
	}
	if v.Targets == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Targets"))
	} else if v.Targets != nil {
		if err := validateCrawlerTargets(v.Targets); err != nil {
			invalidParams.AddNested("Targets", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateDatabaseInput(v *CreateDatabaseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDatabaseInput"}
	if v.DatabaseInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseInput"))
	} else if v.DatabaseInput != nil {
		if err := validateDatabaseInput(v.DatabaseInput); err != nil {
			invalidParams.AddNested("DatabaseInput", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDataQualityRulesetInput(v *CreateDataQualityRulesetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDataQualityRulesetInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Ruleset == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Ruleset"))
	}
	if v.TargetTable != nil {
		if err := validateDataQualityTargetTable(v.TargetTable); err != nil {
			invalidParams.AddNested("TargetTable", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDevEndpointInput(v *CreateDevEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDevEndpointInput"}
	if v.EndpointName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointName"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateJobInput(v *CreateJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateJobInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Role == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Role"))
	}
	if v.Command == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Command"))
	}
	if v.CodeGenConfigurationNodes != nil {
		if err := validateCodeGenConfigurationNodes(v.CodeGenConfigurationNodes); err != nil {
			invalidParams.AddNested("CodeGenConfigurationNodes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMLTransformInput(v *CreateMLTransformInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMLTransformInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.InputRecordTables == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputRecordTables"))
	} else if v.InputRecordTables != nil {
		if err := validateGlueTables(v.InputRecordTables); err != nil {
			invalidParams.AddNested("InputRecordTables", err.(smithy.InvalidParamsError))
		}
	}
	if v.Parameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Parameters"))
	} else if v.Parameters != nil {
		if err := validateTransformParameters(v.Parameters); err != nil {
			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.Role == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Role"))
	}
	if v.TransformEncryption != nil {
		if err := validateTransformEncryption(v.TransformEncryption); err != nil {
			invalidParams.AddNested("TransformEncryption", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePartitionIndexInput(v *CreatePartitionIndexInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePartitionIndexInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.PartitionIndex == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartitionIndex"))
	} else if v.PartitionIndex != nil {
		if err := validatePartitionIndex(v.PartitionIndex); err != nil {
			invalidParams.AddNested("PartitionIndex", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePartitionInput(v *CreatePartitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePartitionInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.PartitionInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartitionInput"))
	} else if v.PartitionInput != nil {
		if err := validatePartitionInput(v.PartitionInput); err != nil {
			invalidParams.AddNested("PartitionInput", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateSchemaInput(v *CreateSchemaInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSchemaInput"}
	if v.SchemaName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaName"))
	}
	if len(v.DataFormat) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DataFormat"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateScriptInput(v *CreateScriptInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateScriptInput"}
	if v.DagNodes != nil {
		if err := validateDagNodes(v.DagNodes); err != nil {
			invalidParams.AddNested("DagNodes", err.(smithy.InvalidParamsError))
		}
	}
	if v.DagEdges != nil {
		if err := validateDagEdges(v.DagEdges); err != nil {
			invalidParams.AddNested("DagEdges", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpCreateTableInput(v *CreateTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTableInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableInput"))
	} else if v.TableInput != nil {
		if err := validateTableInput(v.TableInput); err != nil {
			invalidParams.AddNested("TableInput", err.(smithy.InvalidParamsError))
		}
	}
	if v.PartitionIndexes != nil {
		if err := validatePartitionIndexList(v.PartitionIndexes); err != nil {
			invalidParams.AddNested("PartitionIndexes", err.(smithy.InvalidParamsError))
		}
	}
	if v.OpenTableFormatInput != nil {
		if err := validateOpenTableFormatInput(v.OpenTableFormatInput); err != nil {
			invalidParams.AddNested("OpenTableFormatInput", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTriggerInput(v *CreateTriggerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTriggerInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.Actions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Actions"))
	}
	if v.EventBatchingCondition != nil {
		if err := validateEventBatchingCondition(v.EventBatchingCondition); err != nil {
			invalidParams.AddNested("EventBatchingCondition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateUserDefinedFunctionInput(v *CreateUserDefinedFunctionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateUserDefinedFunctionInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.FunctionInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionInput"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteColumnStatisticsForPartitionInput(v *DeleteColumnStatisticsForPartitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteColumnStatisticsForPartitionInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.PartitionValues == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartitionValues"))
	}
	if v.ColumnName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteColumnStatisticsForTableInput(v *DeleteColumnStatisticsForTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteColumnStatisticsForTableInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.ColumnName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

func validateOpDeletePartitionIndexInput(v *DeletePartitionIndexInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeletePartitionIndexInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.IndexName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeletePartitionInput(v *DeletePartitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeletePartitionInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.PartitionValues == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartitionValues"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteSchemaVersionsInput(v *DeleteSchemaVersionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteSchemaVersionsInput"}
	if v.SchemaId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaId"))
	}
	if v.Versions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Versions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpDeleteTableVersionInput(v *DeleteTableVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTableVersionInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.VersionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VersionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteUserDefinedFunctionInput(v *DeleteUserDefinedFunctionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserDefinedFunctionInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.FunctionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetBlueprintRunInput(v *GetBlueprintRunInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetBlueprintRunInput"}
	if v.BlueprintName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BlueprintName"))
	}
	if v.RunId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RunId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpGetColumnStatisticsForPartitionInput(v *GetColumnStatisticsForPartitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetColumnStatisticsForPartitionInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.PartitionValues == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartitionValues"))
	}
	if v.ColumnNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetColumnStatisticsForTableInput(v *GetColumnStatisticsForTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetColumnStatisticsForTableInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.ColumnNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

func validateOpGetJobRunInput(v *GetJobRunInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetJobRunInput"}
	if v.JobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobName"))
	}
	if v.RunId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RunId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetMappingInput(v *GetMappingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMappingInput"}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	} else if v.Source != nil {
		if err := validateCatalogEntry(v.Source); err != nil {
			invalidParams.AddNested("Source", err.(smithy.InvalidParamsError))
		}
	}
	if v.Sinks != nil {
		if err := validateCatalogEntries(v.Sinks); err != nil {
			invalidParams.AddNested("Sinks", err.(smithy.InvalidParamsError))
		}
	}
	if v.Location != nil {
		if err := validateLocation(v.Location); err != nil {
			invalidParams.AddNested("Location", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetMLTaskRunInput(v *GetMLTaskRunInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMLTaskRunInput"}
	if v.TransformId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransformId"))
	}
	if v.TaskRunId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskRunId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetMLTaskRunsInput(v *GetMLTaskRunsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMLTaskRunsInput"}
	if v.TransformId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransformId"))
	}
	if v.Sort != nil {
		if err := validateTaskRunSortCriteria(v.Sort); err != nil {
			invalidParams.AddNested("Sort", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetMLTransformsInput(v *GetMLTransformsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMLTransformsInput"}
	if v.Sort != nil {
		if err := validateTransformSortCriteria(v.Sort); err != nil {
			invalidParams.AddNested("Sort", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetPartitionIndexesInput(v *GetPartitionIndexesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPartitionIndexesInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetPartitionInput(v *GetPartitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPartitionInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.PartitionValues == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartitionValues"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetPartitionsInput(v *GetPartitionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPartitionsInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.Segment != nil {
		if err := validateSegment(v.Segment); err != nil {
			invalidParams.AddNested("Segment", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetPlanInput(v *GetPlanInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPlanInput"}
	if v.Mapping == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Mapping"))
	}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	} else if v.Source != nil {
		if err := validateCatalogEntry(v.Source); err != nil {
			invalidParams.AddNested("Source", err.(smithy.InvalidParamsError))
		}
	}
	if v.Sinks != nil {
		if err := validateCatalogEntries(v.Sinks); err != nil {
			invalidParams.AddNested("Sinks", err.(smithy.InvalidParamsError))
		}
	}
	if v.Location != nil {
		if err := validateLocation(v.Location); err != nil {
			invalidParams.AddNested("Location", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetSchemaByDefinitionInput(v *GetSchemaByDefinitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSchemaByDefinitionInput"}
	if v.SchemaId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaId"))
	}
	if v.SchemaDefinition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaDefinition"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetSchemaVersionsDiffInput(v *GetSchemaVersionsDiffInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSchemaVersionsDiffInput"}
	if v.SchemaId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaId"))
	}
	if v.FirstSchemaVersionNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FirstSchemaVersionNumber"))
	}
	if v.SecondSchemaVersionNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecondSchemaVersionNumber"))
	}
	if len(v.SchemaDiffType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaDiffType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpGetTableVersionInput(v *GetTableVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTableVersionInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetTableVersionsInput(v *GetTableVersionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTableVersionsInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpGetUnfilteredPartitionMetadataInput(v *GetUnfilteredPartitionMetadataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetUnfilteredPartitionMetadataInput"}
	if v.CatalogId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CatalogId"))
	}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.PartitionValues == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartitionValues"))
	}
	if v.SupportedPermissionTypes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SupportedPermissionTypes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetUnfilteredPartitionsMetadataInput(v *GetUnfilteredPartitionsMetadataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetUnfilteredPartitionsMetadataInput"}
	if v.CatalogId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CatalogId"))
	}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.SupportedPermissionTypes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SupportedPermissionTypes"))
	}
	if v.Segment != nil {
		if err := validateSegment(v.Segment); err != nil {
			invalidParams.AddNested("Segment", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetUnfilteredTableMetadataInput(v *GetUnfilteredTableMetadataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetUnfilteredTableMetadataInput"}
	if v.CatalogId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CatalogId"))
	}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.SupportedPermissionTypes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SupportedPermissionTypes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetUserDefinedFunctionInput(v *GetUserDefinedFunctionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetUserDefinedFunctionInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.FunctionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateOpListDataQualityResultsInput(v *ListDataQualityResultsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDataQualityResultsInput"}
	if v.Filter != nil {
		if err := validateDataQualityResultFilterCriteria(v.Filter); err != nil {
			invalidParams.AddNested("Filter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDataQualityRuleRecommendationRunsInput(v *ListDataQualityRuleRecommendationRunsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDataQualityRuleRecommendationRunsInput"}
	if v.Filter != nil {
		if err := validateDataQualityRuleRecommendationRunFilter(v.Filter); err != nil {
			invalidParams.AddNested("Filter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDataQualityRulesetEvaluationRunsInput(v *ListDataQualityRulesetEvaluationRunsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDataQualityRulesetEvaluationRunsInput"}
	if v.Filter != nil {
		if err := validateDataQualityRulesetEvaluationRunFilter(v.Filter); err != nil {
			invalidParams.AddNested("Filter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDataQualityRulesetsInput(v *ListDataQualityRulesetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDataQualityRulesetsInput"}
	if v.Filter != nil {
		if err := validateDataQualityRulesetFilterCriteria(v.Filter); err != nil {
			invalidParams.AddNested("Filter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListMLTransformsInput(v *ListMLTransformsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListMLTransformsInput"}
	if v.Sort != nil {
		if err := validateTransformSortCriteria(v.Sort); err != nil {
			invalidParams.AddNested("Sort", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpPutDataCatalogEncryptionSettingsInput(v *PutDataCatalogEncryptionSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutDataCatalogEncryptionSettingsInput"}
	if v.DataCatalogEncryptionSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataCatalogEncryptionSettings"))
	} else if v.DataCatalogEncryptionSettings != nil {
		if err := validateDataCatalogEncryptionSettings(v.DataCatalogEncryptionSettings); err != nil {
			invalidParams.AddNested("DataCatalogEncryptionSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpPutWorkflowRunPropertiesInput(v *PutWorkflowRunPropertiesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutWorkflowRunPropertiesInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.RunId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RunId"))
	}
	if v.RunProperties == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RunProperties"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRegisterSchemaVersionInput(v *RegisterSchemaVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterSchemaVersionInput"}
	if v.SchemaId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaId"))
	}
	if v.SchemaDefinition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaDefinition"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpResumeWorkflowRunInput(v *ResumeWorkflowRunInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResumeWorkflowRunInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.RunId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RunId"))
	}
	if v.NodeIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NodeIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpStartBlueprintRunInput(v *StartBlueprintRunInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartBlueprintRunInput"}
	if v.BlueprintName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BlueprintName"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpStartDataQualityRuleRecommendationRunInput(v *StartDataQualityRuleRecommendationRunInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartDataQualityRuleRecommendationRunInput"}
	if v.DataSource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSource"))
	} else if v.DataSource != nil {
		if err := validateDataSource(v.DataSource); err != nil {
			invalidParams.AddNested("DataSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.Role == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Role"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartDataQualityRulesetEvaluationRunInput(v *StartDataQualityRulesetEvaluationRunInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartDataQualityRulesetEvaluationRunInput"}
	if v.DataSource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSource"))
	} else if v.DataSource != nil {
		if err := validateDataSource(v.DataSource); err != nil {
			invalidParams.AddNested("DataSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.Role == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Role"))
	}
	if v.RulesetNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RulesetNames"))
	}
	if v.AdditionalDataSources != nil {
		if err := validateDataSourceMap(v.AdditionalDataSources); err != nil {
			invalidParams.AddNested("AdditionalDataSources", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartExportLabelsTaskRunInput(v *StartExportLabelsTaskRunInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartExportLabelsTaskRunInput"}
	if v.TransformId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransformId"))
	}
	if v.OutputS3Path == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputS3Path"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartImportLabelsTaskRunInput(v *StartImportLabelsTaskRunInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartImportLabelsTaskRunInput"}
	if v.TransformId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransformId"))
	}
	if v.InputS3Path == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputS3Path"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpStartMLLabelingSetGenerationTaskRunInput(v *StartMLLabelingSetGenerationTaskRunInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartMLLabelingSetGenerationTaskRunInput"}
	if v.TransformId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransformId"))
	}
	if v.OutputS3Path == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputS3Path"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateOpStopWorkflowRunInput(v *StopWorkflowRunInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopWorkflowRunInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.RunId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RunId"))
	}
	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.TagsToAdd == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagsToAdd"))
	}
	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.TagsToRemove == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagsToRemove"))
	}
	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.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.BlueprintLocation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BlueprintLocation"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateClassifierInput(v *UpdateClassifierInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateClassifierInput"}
	if v.GrokClassifier != nil {
		if err := validateUpdateGrokClassifierRequest(v.GrokClassifier); err != nil {
			invalidParams.AddNested("GrokClassifier", err.(smithy.InvalidParamsError))
		}
	}
	if v.XMLClassifier != nil {
		if err := validateUpdateXMLClassifierRequest(v.XMLClassifier); err != nil {
			invalidParams.AddNested("XMLClassifier", err.(smithy.InvalidParamsError))
		}
	}
	if v.JsonClassifier != nil {
		if err := validateUpdateJsonClassifierRequest(v.JsonClassifier); err != nil {
			invalidParams.AddNested("JsonClassifier", err.(smithy.InvalidParamsError))
		}
	}
	if v.CsvClassifier != nil {
		if err := validateUpdateCsvClassifierRequest(v.CsvClassifier); err != nil {
			invalidParams.AddNested("CsvClassifier", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateColumnStatisticsForPartitionInput(v *UpdateColumnStatisticsForPartitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateColumnStatisticsForPartitionInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.PartitionValues == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartitionValues"))
	}
	if v.ColumnStatisticsList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnStatisticsList"))
	} else if v.ColumnStatisticsList != nil {
		if err := validateUpdateColumnStatisticsList(v.ColumnStatisticsList); err != nil {
			invalidParams.AddNested("ColumnStatisticsList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateColumnStatisticsForTableInput(v *UpdateColumnStatisticsForTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateColumnStatisticsForTableInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.ColumnStatisticsList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnStatisticsList"))
	} else if v.ColumnStatisticsList != nil {
		if err := validateUpdateColumnStatisticsList(v.ColumnStatisticsList); err != nil {
			invalidParams.AddNested("ColumnStatisticsList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateConnectionInput(v *UpdateConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateConnectionInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ConnectionInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionInput"))
	} else if v.ConnectionInput != nil {
		if err := validateConnectionInput(v.ConnectionInput); err != nil {
			invalidParams.AddNested("ConnectionInput", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateCrawlerInput(v *UpdateCrawlerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCrawlerInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Targets != nil {
		if err := validateCrawlerTargets(v.Targets); err != nil {
			invalidParams.AddNested("Targets", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateDatabaseInput(v *UpdateDatabaseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDatabaseInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.DatabaseInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseInput"))
	} else if v.DatabaseInput != nil {
		if err := validateDatabaseInput(v.DatabaseInput); err != nil {
			invalidParams.AddNested("DatabaseInput", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpUpdateJobInput(v *UpdateJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateJobInput"}
	if v.JobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobName"))
	}
	if v.JobUpdate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobUpdate"))
	} else if v.JobUpdate != nil {
		if err := validateJobUpdate(v.JobUpdate); err != nil {
			invalidParams.AddNested("JobUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateMLTransformInput(v *UpdateMLTransformInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateMLTransformInput"}
	if v.TransformId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransformId"))
	}
	if v.Parameters != nil {
		if err := validateTransformParameters(v.Parameters); err != nil {
			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdatePartitionInput(v *UpdatePartitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePartitionInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.PartitionValueList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartitionValueList"))
	}
	if v.PartitionInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartitionInput"))
	} else if v.PartitionInput != nil {
		if err := validatePartitionInput(v.PartitionInput); err != nil {
			invalidParams.AddNested("PartitionInput", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRegistryInput(v *UpdateRegistryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRegistryInput"}
	if v.RegistryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RegistryId"))
	}
	if v.Description == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Description"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateTableInput(v *UpdateTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTableInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableInput"))
	} else if v.TableInput != nil {
		if err := validateTableInput(v.TableInput); err != nil {
			invalidParams.AddNested("TableInput", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateTriggerInput(v *UpdateTriggerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTriggerInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.TriggerUpdate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TriggerUpdate"))
	} else if v.TriggerUpdate != nil {
		if err := validateTriggerUpdate(v.TriggerUpdate); err != nil {
			invalidParams.AddNested("TriggerUpdate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateUserDefinedFunctionInput(v *UpdateUserDefinedFunctionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserDefinedFunctionInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.FunctionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if v.FunctionInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionInput"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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