xref: /dports/security/vault/aws-sdk-go-v2-fdbaadbce5fd/service/sagemaker/validators.go

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

package sagemaker

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

type validateOpAddAssociation struct {
}

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

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

type validateOpAddTags struct {
}

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

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

type validateOpAssociateTrialComponent struct {
}

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

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

type validateOpCreateAction struct {
}

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

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

type validateOpCreateAlgorithm struct {
}

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

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

type validateOpCreateAppImageConfig struct {
}

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

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

type validateOpCreateApp struct {
}

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

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

type validateOpCreateArtifact struct {
}

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

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

type validateOpCreateAutoMLJob struct {
}

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

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

type validateOpCreateCodeRepository struct {
}

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

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

type validateOpCreateCompilationJob struct {
}

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

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

type validateOpCreateContext struct {
}

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

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

type validateOpCreateDataQualityJobDefinition struct {
}

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

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

type validateOpCreateDeviceFleet struct {
}

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

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

type validateOpCreateDomain struct {
}

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

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

type validateOpCreateEdgePackagingJob struct {
}

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

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

type validateOpCreateEndpointConfig struct {
}

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

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

type validateOpCreateEndpoint struct {
}

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

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

type validateOpCreateExperiment struct {
}

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

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

type validateOpCreateFeatureGroup struct {
}

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

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

type validateOpCreateFlowDefinition struct {
}

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

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

type validateOpCreateHumanTaskUi struct {
}

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

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

type validateOpCreateHyperParameterTuningJob struct {
}

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

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

type validateOpCreateImage struct {
}

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

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

type validateOpCreateImageVersion struct {
}

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

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

type validateOpCreateLabelingJob struct {
}

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

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

type validateOpCreateModelBiasJobDefinition struct {
}

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

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

type validateOpCreateModelExplainabilityJobDefinition struct {
}

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

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

type validateOpCreateModel struct {
}

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

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

type validateOpCreateModelPackageGroup struct {
}

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

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

type validateOpCreateModelPackage struct {
}

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

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

type validateOpCreateModelQualityJobDefinition struct {
}

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

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

type validateOpCreateMonitoringSchedule struct {
}

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

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

type validateOpCreateNotebookInstance struct {
}

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

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

type validateOpCreateNotebookInstanceLifecycleConfig struct {
}

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

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

type validateOpCreatePipeline struct {
}

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

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

type validateOpCreatePresignedDomainUrl struct {
}

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

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

type validateOpCreatePresignedNotebookInstanceUrl struct {
}

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

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

type validateOpCreateProcessingJob struct {
}

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

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

type validateOpCreateProject struct {
}

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

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

type validateOpCreateTrainingJob struct {
}

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

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

type validateOpCreateTransformJob struct {
}

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

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

type validateOpCreateTrialComponent struct {
}

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

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

type validateOpCreateTrial struct {
}

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

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

type validateOpCreateUserProfile struct {
}

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

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

type validateOpCreateWorkforce struct {
}

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

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

type validateOpCreateWorkteam struct {
}

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

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

type validateOpDeleteAction struct {
}

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

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

type validateOpDeleteAlgorithm struct {
}

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

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

type validateOpDeleteAppImageConfig struct {
}

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

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

type validateOpDeleteApp struct {
}

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

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

type validateOpDeleteArtifact struct {
}

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

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

type validateOpDeleteAssociation struct {
}

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

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

type validateOpDeleteCodeRepository struct {
}

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

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

type validateOpDeleteContext struct {
}

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

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

type validateOpDeleteDataQualityJobDefinition struct {
}

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

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

type validateOpDeleteDeviceFleet struct {
}

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

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

type validateOpDeleteDomain struct {
}

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

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

type validateOpDeleteEndpointConfig struct {
}

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

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

type validateOpDeleteEndpoint struct {
}

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

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

type validateOpDeleteExperiment struct {
}

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

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

type validateOpDeleteFeatureGroup struct {
}

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

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

type validateOpDeleteFlowDefinition struct {
}

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

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

type validateOpDeleteHumanTaskUi struct {
}

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

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

type validateOpDeleteImage struct {
}

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

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

type validateOpDeleteImageVersion struct {
}

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

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

type validateOpDeleteModelBiasJobDefinition struct {
}

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

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

type validateOpDeleteModelExplainabilityJobDefinition struct {
}

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

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

type validateOpDeleteModel struct {
}

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

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

type validateOpDeleteModelPackageGroup struct {
}

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

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

type validateOpDeleteModelPackageGroupPolicy struct {
}

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

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

type validateOpDeleteModelPackage struct {
}

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

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

type validateOpDeleteModelQualityJobDefinition struct {
}

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

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

type validateOpDeleteMonitoringSchedule struct {
}

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

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

type validateOpDeleteNotebookInstance struct {
}

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

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

type validateOpDeleteNotebookInstanceLifecycleConfig struct {
}

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

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

type validateOpDeletePipeline struct {
}

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

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

type validateOpDeleteProject struct {
}

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

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

type validateOpDeleteTags struct {
}

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

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

type validateOpDeleteTrialComponent struct {
}

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

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

type validateOpDeleteTrial struct {
}

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

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

type validateOpDeleteUserProfile struct {
}

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

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

type validateOpDeleteWorkforce struct {
}

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

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

type validateOpDeleteWorkteam struct {
}

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

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

type validateOpDeregisterDevices struct {
}

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

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

type validateOpDescribeAction struct {
}

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

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

type validateOpDescribeAlgorithm struct {
}

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

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

type validateOpDescribeAppImageConfig struct {
}

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

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

type validateOpDescribeApp struct {
}

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

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

type validateOpDescribeArtifact struct {
}

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

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

type validateOpDescribeAutoMLJob struct {
}

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

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

type validateOpDescribeCodeRepository struct {
}

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

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

type validateOpDescribeCompilationJob struct {
}

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

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

type validateOpDescribeContext struct {
}

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

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

type validateOpDescribeDataQualityJobDefinition struct {
}

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

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

type validateOpDescribeDeviceFleet struct {
}

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

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

type validateOpDescribeDevice struct {
}

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

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

type validateOpDescribeDomain struct {
}

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

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

type validateOpDescribeEdgePackagingJob struct {
}

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

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

type validateOpDescribeEndpointConfig struct {
}

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

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

type validateOpDescribeEndpoint struct {
}

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

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

type validateOpDescribeExperiment struct {
}

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

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

type validateOpDescribeFeatureGroup struct {
}

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

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

type validateOpDescribeFlowDefinition struct {
}

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

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

type validateOpDescribeHumanTaskUi struct {
}

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

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

type validateOpDescribeHyperParameterTuningJob struct {
}

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

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

type validateOpDescribeImage struct {
}

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

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

type validateOpDescribeImageVersion struct {
}

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

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

type validateOpDescribeLabelingJob struct {
}

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

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

type validateOpDescribeModelBiasJobDefinition struct {
}

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

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

type validateOpDescribeModelExplainabilityJobDefinition struct {
}

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

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

type validateOpDescribeModel struct {
}

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

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

type validateOpDescribeModelPackageGroup struct {
}

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

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

type validateOpDescribeModelPackage struct {
}

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

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

type validateOpDescribeModelQualityJobDefinition struct {
}

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

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

type validateOpDescribeMonitoringSchedule struct {
}

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

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

type validateOpDescribeNotebookInstance struct {
}

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

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

type validateOpDescribeNotebookInstanceLifecycleConfig struct {
}

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

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

type validateOpDescribePipelineDefinitionForExecution struct {
}

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

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

type validateOpDescribePipelineExecution struct {
}

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

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

type validateOpDescribePipeline struct {
}

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

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

type validateOpDescribeProcessingJob struct {
}

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

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

type validateOpDescribeProject struct {
}

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

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

type validateOpDescribeSubscribedWorkteam struct {
}

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

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

type validateOpDescribeTrainingJob struct {
}

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

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

type validateOpDescribeTransformJob struct {
}

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

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

type validateOpDescribeTrialComponent struct {
}

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

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

type validateOpDescribeTrial struct {
}

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

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

type validateOpDescribeUserProfile struct {
}

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

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

type validateOpDescribeWorkforce struct {
}

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

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

type validateOpDescribeWorkteam struct {
}

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

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

type validateOpDisassociateTrialComponent struct {
}

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

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

type validateOpGetDeviceFleetReport struct {
}

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

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

type validateOpGetModelPackageGroupPolicy struct {
}

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

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

type validateOpGetSearchSuggestions struct {
}

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

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

type validateOpListCandidatesForAutoMLJob struct {
}

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

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

type validateOpListImageVersions struct {
}

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

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

type validateOpListLabelingJobsForWorkteam struct {
}

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

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

type validateOpListPipelineExecutions struct {
}

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

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

type validateOpListPipelineParametersForExecution struct {
}

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

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

type validateOpListTags struct {
}

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

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

type validateOpListTrainingJobsForHyperParameterTuningJob struct {
}

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

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

type validateOpPutModelPackageGroupPolicy struct {
}

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

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

type validateOpRegisterDevices struct {
}

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

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

type validateOpRenderUiTemplate struct {
}

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

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

type validateOpSearch struct {
}

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

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

type validateOpStartMonitoringSchedule struct {
}

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

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

type validateOpStartNotebookInstance struct {
}

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

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

type validateOpStartPipelineExecution struct {
}

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

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

type validateOpStopAutoMLJob struct {
}

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

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

type validateOpStopCompilationJob struct {
}

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

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

type validateOpStopEdgePackagingJob struct {
}

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

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

type validateOpStopHyperParameterTuningJob struct {
}

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

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

type validateOpStopLabelingJob struct {
}

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

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

type validateOpStopMonitoringSchedule struct {
}

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

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

type validateOpStopNotebookInstance struct {
}

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

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

type validateOpStopPipelineExecution struct {
}

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

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

type validateOpStopProcessingJob struct {
}

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

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

type validateOpStopTrainingJob struct {
}

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

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

type validateOpStopTransformJob struct {
}

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

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

type validateOpUpdateAction struct {
}

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

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

type validateOpUpdateAppImageConfig struct {
}

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

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

type validateOpUpdateArtifact struct {
}

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

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

type validateOpUpdateCodeRepository struct {
}

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

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

type validateOpUpdateContext struct {
}

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

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

type validateOpUpdateDeviceFleet struct {
}

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

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

type validateOpUpdateDevices struct {
}

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

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

type validateOpUpdateDomain struct {
}

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

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

type validateOpUpdateEndpoint struct {
}

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

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

type validateOpUpdateEndpointWeightsAndCapacities struct {
}

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

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

type validateOpUpdateExperiment struct {
}

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

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

type validateOpUpdateImage struct {
}

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

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

type validateOpUpdateModelPackage struct {
}

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

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

type validateOpUpdateMonitoringSchedule struct {
}

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

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

type validateOpUpdateNotebookInstance struct {
}

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

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

type validateOpUpdateNotebookInstanceLifecycleConfig struct {
}

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

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

type validateOpUpdatePipelineExecution struct {
}

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

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

type validateOpUpdatePipeline struct {
}

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

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

type validateOpUpdateTrainingJob struct {
}

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

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

type validateOpUpdateTrialComponent struct {
}

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

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

type validateOpUpdateTrial struct {
}

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

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

type validateOpUpdateUserProfile struct {
}

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

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

type validateOpUpdateWorkforce struct {
}

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

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

type validateOpUpdateWorkteam struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateAlgorithmSpecification(v *types.AlgorithmSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AlgorithmSpecification"}
	if len(v.TrainingInputMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TrainingInputMode"))
	}
	if v.MetricDefinitions != nil {
		if err := validateMetricDefinitionList(v.MetricDefinitions); err != nil {
			invalidParams.AddNested("MetricDefinitions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAlgorithmValidationProfile(v *types.AlgorithmValidationProfile) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AlgorithmValidationProfile"}
	if v.ProfileName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProfileName"))
	}
	if v.TrainingJobDefinition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrainingJobDefinition"))
	} else if v.TrainingJobDefinition != nil {
		if err := validateTrainingJobDefinition(v.TrainingJobDefinition); err != nil {
			invalidParams.AddNested("TrainingJobDefinition", err.(smithy.InvalidParamsError))
		}
	}
	if v.TransformJobDefinition != nil {
		if err := validateTransformJobDefinition(v.TransformJobDefinition); err != nil {
			invalidParams.AddNested("TransformJobDefinition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateAlgorithmValidationSpecification(v *types.AlgorithmValidationSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AlgorithmValidationSpecification"}
	if v.ValidationRole == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ValidationRole"))
	}
	if v.ValidationProfiles == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ValidationProfiles"))
	} else if v.ValidationProfiles != nil {
		if err := validateAlgorithmValidationProfiles(v.ValidationProfiles); err != nil {
			invalidParams.AddNested("ValidationProfiles", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateArtifactSource(v *types.ArtifactSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ArtifactSource"}
	if v.SourceUri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceUri"))
	}
	if v.SourceTypes != nil {
		if err := validateArtifactSourceTypes(v.SourceTypes); err != nil {
			invalidParams.AddNested("SourceTypes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateAthenaDatasetDefinition(v *types.AthenaDatasetDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AthenaDatasetDefinition"}
	if v.Catalog == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Catalog"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if v.QueryString == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryString"))
	}
	if v.OutputS3Uri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputS3Uri"))
	}
	if len(v.OutputFormat) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("OutputFormat"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateAutoMLJobConfig(v *types.AutoMLJobConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AutoMLJobConfig"}
	if v.SecurityConfig != nil {
		if err := validateAutoMLSecurityConfig(v.SecurityConfig); err != nil {
			invalidParams.AddNested("SecurityConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateAutoMLSecurityConfig(v *types.AutoMLSecurityConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AutoMLSecurityConfig"}
	if v.VpcConfig != nil {
		if err := validateVpcConfig(v.VpcConfig); err != nil {
			invalidParams.AddNested("VpcConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBias(v *types.Bias) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Bias"}
	if v.Report != nil {
		if err := validateMetricsSource(v.Report); err != nil {
			invalidParams.AddNested("Report", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCapacitySize(v *types.CapacitySize) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CapacitySize"}
	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 validateCaptureOption(v *types.CaptureOption) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CaptureOption"}
	if len(v.CaptureMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("CaptureMode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateChannel(v *types.Channel) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Channel"}
	if v.ChannelName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
	}
	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.ShuffleConfig != nil {
		if err := validateShuffleConfig(v.ShuffleConfig); err != nil {
			invalidParams.AddNested("ShuffleConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateCognitoConfig(v *types.CognitoConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CognitoConfig"}
	if v.UserPool == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPool"))
	}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCognitoMemberDefinition(v *types.CognitoMemberDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CognitoMemberDefinition"}
	if v.UserPool == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPool"))
	}
	if v.UserGroup == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserGroup"))
	}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateContainerDefinition(v *types.ContainerDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContainerDefinition"}
	if v.ImageConfig != nil {
		if err := validateImageConfig(v.ImageConfig); err != nil {
			invalidParams.AddNested("ImageConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateContinuousParameterRangeSpecification(v *types.ContinuousParameterRangeSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContinuousParameterRangeSpecification"}
	if v.MinValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MinValue"))
	}
	if v.MaxValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxValue"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomImage(v *types.CustomImage) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomImage"}
	if v.ImageName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageName"))
	}
	if v.AppImageConfigName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppImageConfigName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDataCaptureConfig(v *types.DataCaptureConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataCaptureConfig"}
	if v.InitialSamplingPercentage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InitialSamplingPercentage"))
	}
	if v.DestinationS3Uri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationS3Uri"))
	}
	if v.CaptureOptions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CaptureOptions"))
	} else if v.CaptureOptions != nil {
		if err := validateCaptureOptionList(v.CaptureOptions); err != nil {
			invalidParams.AddNested("CaptureOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDataCatalogConfig(v *types.DataCatalogConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataCatalogConfig"}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.Catalog == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Catalog"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateDatasetDefinition(v *types.DatasetDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DatasetDefinition"}
	if v.AthenaDatasetDefinition != nil {
		if err := validateAthenaDatasetDefinition(v.AthenaDatasetDefinition); err != nil {
			invalidParams.AddNested("AthenaDatasetDefinition", err.(smithy.InvalidParamsError))
		}
	}
	if v.RedshiftDatasetDefinition != nil {
		if err := validateRedshiftDatasetDefinition(v.RedshiftDatasetDefinition); err != nil {
			invalidParams.AddNested("RedshiftDatasetDefinition", err.(smithy.InvalidParamsError))
		}
	}
	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.S3DataSource != nil {
		if err := validateS3DataSource(v.S3DataSource); err != nil {
			invalidParams.AddNested("S3DataSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.FileSystemDataSource != nil {
		if err := validateFileSystemDataSource(v.FileSystemDataSource); err != nil {
			invalidParams.AddNested("FileSystemDataSource", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDebugRuleConfiguration(v *types.DebugRuleConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DebugRuleConfiguration"}
	if v.RuleConfigurationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleConfigurationName"))
	}
	if v.RuleEvaluatorImage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleEvaluatorImage"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

func validateExplainability(v *types.Explainability) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Explainability"}
	if v.Report != nil {
		if err := validateMetricsSource(v.Report); err != nil {
			invalidParams.AddNested("Report", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFileSystemDataSource(v *types.FileSystemDataSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FileSystemDataSource"}
	if v.FileSystemId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FileSystemId"))
	}
	if len(v.FileSystemAccessMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("FileSystemAccessMode"))
	}
	if len(v.FileSystemType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("FileSystemType"))
	}
	if v.DirectoryPath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryPath"))
	}
	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 invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateHumanLoopConfig(v *types.HumanLoopConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HumanLoopConfig"}
	if v.WorkteamArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkteamArn"))
	}
	if v.HumanTaskUiArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HumanTaskUiArn"))
	}
	if v.TaskTitle == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskTitle"))
	}
	if v.TaskDescription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskDescription"))
	}
	if v.TaskCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskCount"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateHumanTaskConfig(v *types.HumanTaskConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HumanTaskConfig"}
	if v.WorkteamArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkteamArn"))
	}
	if v.UiConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UiConfig"))
	}
	if v.PreHumanTaskLambdaArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PreHumanTaskLambdaArn"))
	}
	if v.TaskTitle == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskTitle"))
	}
	if v.TaskDescription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskDescription"))
	}
	if v.NumberOfHumanWorkersPerDataObject == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NumberOfHumanWorkersPerDataObject"))
	}
	if v.TaskTimeLimitInSeconds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskTimeLimitInSeconds"))
	}
	if v.AnnotationConsolidationConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnnotationConsolidationConfig"))
	} else if v.AnnotationConsolidationConfig != nil {
		if err := validateAnnotationConsolidationConfig(v.AnnotationConsolidationConfig); err != nil {
			invalidParams.AddNested("AnnotationConsolidationConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateHyperParameterAlgorithmSpecification(v *types.HyperParameterAlgorithmSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HyperParameterAlgorithmSpecification"}
	if len(v.TrainingInputMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TrainingInputMode"))
	}
	if v.MetricDefinitions != nil {
		if err := validateMetricDefinitionList(v.MetricDefinitions); err != nil {
			invalidParams.AddNested("MetricDefinitions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateHyperParameterSpecification(v *types.HyperParameterSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HyperParameterSpecification"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.Range != nil {
		if err := validateParameterRange(v.Range); err != nil {
			invalidParams.AddNested("Range", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateHyperParameterTrainingJobDefinition(v *types.HyperParameterTrainingJobDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HyperParameterTrainingJobDefinition"}
	if v.TuningObjective != nil {
		if err := validateHyperParameterTuningJobObjective(v.TuningObjective); err != nil {
			invalidParams.AddNested("TuningObjective", err.(smithy.InvalidParamsError))
		}
	}
	if v.HyperParameterRanges != nil {
		if err := validateParameterRanges(v.HyperParameterRanges); err != nil {
			invalidParams.AddNested("HyperParameterRanges", err.(smithy.InvalidParamsError))
		}
	}
	if v.AlgorithmSpecification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AlgorithmSpecification"))
	} else if v.AlgorithmSpecification != nil {
		if err := validateHyperParameterAlgorithmSpecification(v.AlgorithmSpecification); err != nil {
			invalidParams.AddNested("AlgorithmSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.InputDataConfig != nil {
		if err := validateInputDataConfig(v.InputDataConfig); err != nil {
			invalidParams.AddNested("InputDataConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.VpcConfig != nil {
		if err := validateVpcConfig(v.VpcConfig); err != nil {
			invalidParams.AddNested("VpcConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputDataConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputDataConfig"))
	} else if v.OutputDataConfig != nil {
		if err := validateOutputDataConfig(v.OutputDataConfig); err != nil {
			invalidParams.AddNested("OutputDataConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ResourceConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceConfig"))
	} else if v.ResourceConfig != nil {
		if err := validateResourceConfig(v.ResourceConfig); err != nil {
			invalidParams.AddNested("ResourceConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.StoppingCondition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StoppingCondition"))
	}
	if v.CheckpointConfig != nil {
		if err := validateCheckpointConfig(v.CheckpointConfig); err != nil {
			invalidParams.AddNested("CheckpointConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateHyperParameterTuningJobConfig(v *types.HyperParameterTuningJobConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HyperParameterTuningJobConfig"}
	if len(v.Strategy) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Strategy"))
	}
	if v.HyperParameterTuningJobObjective != nil {
		if err := validateHyperParameterTuningJobObjective(v.HyperParameterTuningJobObjective); err != nil {
			invalidParams.AddNested("HyperParameterTuningJobObjective", err.(smithy.InvalidParamsError))
		}
	}
	if v.ResourceLimits == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceLimits"))
	} else if v.ResourceLimits != nil {
		if err := validateResourceLimits(v.ResourceLimits); err != nil {
			invalidParams.AddNested("ResourceLimits", err.(smithy.InvalidParamsError))
		}
	}
	if v.ParameterRanges != nil {
		if err := validateParameterRanges(v.ParameterRanges); err != nil {
			invalidParams.AddNested("ParameterRanges", err.(smithy.InvalidParamsError))
		}
	}
	if v.TuningJobCompletionCriteria != nil {
		if err := validateTuningJobCompletionCriteria(v.TuningJobCompletionCriteria); err != nil {
			invalidParams.AddNested("TuningJobCompletionCriteria", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateHyperParameterTuningJobWarmStartConfig(v *types.HyperParameterTuningJobWarmStartConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HyperParameterTuningJobWarmStartConfig"}
	if v.ParentHyperParameterTuningJobs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParentHyperParameterTuningJobs"))
	}
	if len(v.WarmStartType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("WarmStartType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateImageConfig(v *types.ImageConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImageConfig"}
	if len(v.RepositoryAccessMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RepositoryAccessMode"))
	}
	if v.RepositoryAuthConfig != nil {
		if err := validateRepositoryAuthConfig(v.RepositoryAuthConfig); err != nil {
			invalidParams.AddNested("RepositoryAuthConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateInferenceSpecification(v *types.InferenceSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InferenceSpecification"}
	if v.Containers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Containers"))
	} else if v.Containers != nil {
		if err := validateModelPackageContainerDefinitionList(v.Containers); err != nil {
			invalidParams.AddNested("Containers", err.(smithy.InvalidParamsError))
		}
	}
	if v.SupportedContentTypes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SupportedContentTypes"))
	}
	if v.SupportedResponseMIMETypes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SupportedResponseMIMETypes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInputConfig(v *types.InputConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InputConfig"}
	if v.S3Uri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3Uri"))
	}
	if v.DataInputConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataInputConfig"))
	}
	if len(v.Framework) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Framework"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateIntegerParameterRangeSpecification(v *types.IntegerParameterRangeSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IntegerParameterRangeSpecification"}
	if v.MinValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MinValue"))
	}
	if v.MaxValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxValue"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateKernelGatewayAppSettings(v *types.KernelGatewayAppSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KernelGatewayAppSettings"}
	if v.CustomImages != nil {
		if err := validateCustomImages(v.CustomImages); err != nil {
			invalidParams.AddNested("CustomImages", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateLabelingJobDataSource(v *types.LabelingJobDataSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LabelingJobDataSource"}
	if v.S3DataSource != nil {
		if err := validateLabelingJobS3DataSource(v.S3DataSource); err != nil {
			invalidParams.AddNested("S3DataSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.SnsDataSource != nil {
		if err := validateLabelingJobSnsDataSource(v.SnsDataSource); err != nil {
			invalidParams.AddNested("SnsDataSource", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateMemberDefinition(v *types.MemberDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MemberDefinition"}
	if v.CognitoMemberDefinition != nil {
		if err := validateCognitoMemberDefinition(v.CognitoMemberDefinition); err != nil {
			invalidParams.AddNested("CognitoMemberDefinition", err.(smithy.InvalidParamsError))
		}
	}
	if v.OidcMemberDefinition != nil {
		if err := validateOidcMemberDefinition(v.OidcMemberDefinition); err != nil {
			invalidParams.AddNested("OidcMemberDefinition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateModelBiasAppSpecification(v *types.ModelBiasAppSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModelBiasAppSpecification"}
	if v.ImageUri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageUri"))
	}
	if v.ConfigUri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigUri"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateModelBiasJobInput(v *types.ModelBiasJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModelBiasJobInput"}
	if v.EndpointInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointInput"))
	} else if v.EndpointInput != nil {
		if err := validateEndpointInput(v.EndpointInput); err != nil {
			invalidParams.AddNested("EndpointInput", err.(smithy.InvalidParamsError))
		}
	}
	if v.GroundTruthS3Input == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroundTruthS3Input"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateModelDataQuality(v *types.ModelDataQuality) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModelDataQuality"}
	if v.Statistics != nil {
		if err := validateMetricsSource(v.Statistics); err != nil {
			invalidParams.AddNested("Statistics", err.(smithy.InvalidParamsError))
		}
	}
	if v.Constraints != nil {
		if err := validateMetricsSource(v.Constraints); err != nil {
			invalidParams.AddNested("Constraints", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateModelExplainabilityAppSpecification(v *types.ModelExplainabilityAppSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModelExplainabilityAppSpecification"}
	if v.ImageUri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageUri"))
	}
	if v.ConfigUri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigUri"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateModelMetrics(v *types.ModelMetrics) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModelMetrics"}
	if v.ModelQuality != nil {
		if err := validateModelQuality(v.ModelQuality); err != nil {
			invalidParams.AddNested("ModelQuality", err.(smithy.InvalidParamsError))
		}
	}
	if v.ModelDataQuality != nil {
		if err := validateModelDataQuality(v.ModelDataQuality); err != nil {
			invalidParams.AddNested("ModelDataQuality", err.(smithy.InvalidParamsError))
		}
	}
	if v.Bias != nil {
		if err := validateBias(v.Bias); err != nil {
			invalidParams.AddNested("Bias", err.(smithy.InvalidParamsError))
		}
	}
	if v.Explainability != nil {
		if err := validateExplainability(v.Explainability); err != nil {
			invalidParams.AddNested("Explainability", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateModelPackageValidationProfile(v *types.ModelPackageValidationProfile) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModelPackageValidationProfile"}
	if v.ProfileName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProfileName"))
	}
	if v.TransformJobDefinition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransformJobDefinition"))
	} else if v.TransformJobDefinition != nil {
		if err := validateTransformJobDefinition(v.TransformJobDefinition); err != nil {
			invalidParams.AddNested("TransformJobDefinition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateModelPackageValidationSpecification(v *types.ModelPackageValidationSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModelPackageValidationSpecification"}
	if v.ValidationRole == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ValidationRole"))
	}
	if v.ValidationProfiles == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ValidationProfiles"))
	} else if v.ValidationProfiles != nil {
		if err := validateModelPackageValidationProfiles(v.ValidationProfiles); err != nil {
			invalidParams.AddNested("ValidationProfiles", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateModelQuality(v *types.ModelQuality) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModelQuality"}
	if v.Statistics != nil {
		if err := validateMetricsSource(v.Statistics); err != nil {
			invalidParams.AddNested("Statistics", err.(smithy.InvalidParamsError))
		}
	}
	if v.Constraints != nil {
		if err := validateMetricsSource(v.Constraints); err != nil {
			invalidParams.AddNested("Constraints", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateModelQualityJobInput(v *types.ModelQualityJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModelQualityJobInput"}
	if v.EndpointInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointInput"))
	} else if v.EndpointInput != nil {
		if err := validateEndpointInput(v.EndpointInput); err != nil {
			invalidParams.AddNested("EndpointInput", err.(smithy.InvalidParamsError))
		}
	}
	if v.GroundTruthS3Input == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroundTruthS3Input"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateMonitoringClusterConfig(v *types.MonitoringClusterConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MonitoringClusterConfig"}
	if v.InstanceCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceCount"))
	}
	if len(v.InstanceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceType"))
	}
	if v.VolumeSizeInGB == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VolumeSizeInGB"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateMonitoringJobDefinition(v *types.MonitoringJobDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MonitoringJobDefinition"}
	if v.MonitoringInputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MonitoringInputs"))
	} else if v.MonitoringInputs != nil {
		if err := validateMonitoringInputs(v.MonitoringInputs); err != nil {
			invalidParams.AddNested("MonitoringInputs", err.(smithy.InvalidParamsError))
		}
	}
	if v.MonitoringOutputConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MonitoringOutputConfig"))
	} else if v.MonitoringOutputConfig != nil {
		if err := validateMonitoringOutputConfig(v.MonitoringOutputConfig); err != nil {
			invalidParams.AddNested("MonitoringOutputConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.MonitoringResources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MonitoringResources"))
	} else if v.MonitoringResources != nil {
		if err := validateMonitoringResources(v.MonitoringResources); err != nil {
			invalidParams.AddNested("MonitoringResources", err.(smithy.InvalidParamsError))
		}
	}
	if v.MonitoringAppSpecification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MonitoringAppSpecification"))
	} else if v.MonitoringAppSpecification != nil {
		if err := validateMonitoringAppSpecification(v.MonitoringAppSpecification); err != nil {
			invalidParams.AddNested("MonitoringAppSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.StoppingCondition != nil {
		if err := validateMonitoringStoppingCondition(v.StoppingCondition); err != nil {
			invalidParams.AddNested("StoppingCondition", err.(smithy.InvalidParamsError))
		}
	}
	if v.NetworkConfig != nil {
		if err := validateNetworkConfig(v.NetworkConfig); err != nil {
			invalidParams.AddNested("NetworkConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMonitoringNetworkConfig(v *types.MonitoringNetworkConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MonitoringNetworkConfig"}
	if v.VpcConfig != nil {
		if err := validateVpcConfig(v.VpcConfig); err != nil {
			invalidParams.AddNested("VpcConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateMonitoringScheduleConfig(v *types.MonitoringScheduleConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MonitoringScheduleConfig"}
	if v.ScheduleConfig != nil {
		if err := validateScheduleConfig(v.ScheduleConfig); err != nil {
			invalidParams.AddNested("ScheduleConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.MonitoringJobDefinition != nil {
		if err := validateMonitoringJobDefinition(v.MonitoringJobDefinition); err != nil {
			invalidParams.AddNested("MonitoringJobDefinition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateNestedFilters(v *types.NestedFilters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NestedFilters"}
	if v.NestedPropertyName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NestedPropertyName"))
	}
	if v.Filters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
	} else if v.Filters != nil {
		if err := validateFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateNetworkConfig(v *types.NetworkConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NetworkConfig"}
	if v.VpcConfig != nil {
		if err := validateVpcConfig(v.VpcConfig); err != nil {
			invalidParams.AddNested("VpcConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOfflineStoreConfig(v *types.OfflineStoreConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OfflineStoreConfig"}
	if v.S3StorageConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3StorageConfig"))
	} else if v.S3StorageConfig != nil {
		if err := validateS3StorageConfig(v.S3StorageConfig); err != nil {
			invalidParams.AddNested("S3StorageConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataCatalogConfig != nil {
		if err := validateDataCatalogConfig(v.DataCatalogConfig); err != nil {
			invalidParams.AddNested("DataCatalogConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOidcConfig(v *types.OidcConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OidcConfig"}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if v.ClientSecret == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientSecret"))
	}
	if v.Issuer == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Issuer"))
	}
	if v.AuthorizationEndpoint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthorizationEndpoint"))
	}
	if v.TokenEndpoint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TokenEndpoint"))
	}
	if v.UserInfoEndpoint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserInfoEndpoint"))
	}
	if v.LogoutEndpoint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LogoutEndpoint"))
	}
	if v.JwksUri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JwksUri"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOutputConfig(v *types.OutputConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OutputConfig"}
	if v.S3OutputLocation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3OutputLocation"))
	}
	if v.TargetPlatform != nil {
		if err := validateTargetPlatform(v.TargetPlatform); err != nil {
			invalidParams.AddNested("TargetPlatform", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateParameterRange(v *types.ParameterRange) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParameterRange"}
	if v.IntegerParameterRangeSpecification != nil {
		if err := validateIntegerParameterRangeSpecification(v.IntegerParameterRangeSpecification); err != nil {
			invalidParams.AddNested("IntegerParameterRangeSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContinuousParameterRangeSpecification != nil {
		if err := validateContinuousParameterRangeSpecification(v.ContinuousParameterRangeSpecification); err != nil {
			invalidParams.AddNested("ContinuousParameterRangeSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.CategoricalParameterRangeSpecification != nil {
		if err := validateCategoricalParameterRangeSpecification(v.CategoricalParameterRangeSpecification); err != nil {
			invalidParams.AddNested("CategoricalParameterRangeSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateParameterRanges(v *types.ParameterRanges) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParameterRanges"}
	if v.IntegerParameterRanges != nil {
		if err := validateIntegerParameterRanges(v.IntegerParameterRanges); err != nil {
			invalidParams.AddNested("IntegerParameterRanges", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContinuousParameterRanges != nil {
		if err := validateContinuousParameterRanges(v.ContinuousParameterRanges); err != nil {
			invalidParams.AddNested("ContinuousParameterRanges", err.(smithy.InvalidParamsError))
		}
	}
	if v.CategoricalParameterRanges != nil {
		if err := validateCategoricalParameterRanges(v.CategoricalParameterRanges); err != nil {
			invalidParams.AddNested("CategoricalParameterRanges", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateProcessingClusterConfig(v *types.ProcessingClusterConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProcessingClusterConfig"}
	if v.InstanceCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceCount"))
	}
	if len(v.InstanceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceType"))
	}
	if v.VolumeSizeInGB == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VolumeSizeInGB"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateProcessingInput(v *types.ProcessingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProcessingInput"}
	if v.InputName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputName"))
	}
	if v.S3Input != nil {
		if err := validateProcessingS3Input(v.S3Input); err != nil {
			invalidParams.AddNested("S3Input", err.(smithy.InvalidParamsError))
		}
	}
	if v.DatasetDefinition != nil {
		if err := validateDatasetDefinition(v.DatasetDefinition); err != nil {
			invalidParams.AddNested("DatasetDefinition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateProcessingOutput(v *types.ProcessingOutput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProcessingOutput"}
	if v.OutputName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputName"))
	}
	if v.S3Output != nil {
		if err := validateProcessingS3Output(v.S3Output); err != nil {
			invalidParams.AddNested("S3Output", err.(smithy.InvalidParamsError))
		}
	}
	if v.FeatureStoreOutput != nil {
		if err := validateProcessingFeatureStoreOutput(v.FeatureStoreOutput); err != nil {
			invalidParams.AddNested("FeatureStoreOutput", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateProcessingS3Output(v *types.ProcessingS3Output) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProcessingS3Output"}
	if v.S3Uri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3Uri"))
	}
	if v.LocalPath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocalPath"))
	}
	if len(v.S3UploadMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("S3UploadMode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateProductionVariant(v *types.ProductionVariant) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProductionVariant"}
	if v.VariantName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VariantName"))
	}
	if v.ModelName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelName"))
	}
	if v.InitialInstanceCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InitialInstanceCount"))
	}
	if len(v.InstanceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceType"))
	}
	if v.CoreDumpConfig != nil {
		if err := validateProductionVariantCoreDumpConfig(v.CoreDumpConfig); err != nil {
			invalidParams.AddNested("CoreDumpConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateProfilerRuleConfiguration(v *types.ProfilerRuleConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProfilerRuleConfiguration"}
	if v.RuleConfigurationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleConfigurationName"))
	}
	if v.RuleEvaluatorImage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleEvaluatorImage"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateRedshiftDatasetDefinition(v *types.RedshiftDatasetDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RedshiftDatasetDefinition"}
	if v.ClusterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterId"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if v.DbUser == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DbUser"))
	}
	if v.QueryString == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryString"))
	}
	if v.ClusterRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterRoleArn"))
	}
	if v.OutputS3Uri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputS3Uri"))
	}
	if len(v.OutputFormat) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("OutputFormat"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

func validateSearchExpression(v *types.SearchExpression) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchExpression"}
	if v.Filters != nil {
		if err := validateFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if v.NestedFilters != nil {
		if err := validateNestedFiltersList(v.NestedFilters); err != nil {
			invalidParams.AddNested("NestedFilters", err.(smithy.InvalidParamsError))
		}
	}
	if v.SubExpressions != nil {
		if err := validateSearchExpressionList(v.SubExpressions); err != nil {
			invalidParams.AddNested("SubExpressions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateServiceCatalogProvisioningDetails(v *types.ServiceCatalogProvisioningDetails) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ServiceCatalogProvisioningDetails"}
	if v.ProductId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProductId"))
	}
	if v.ProvisioningArtifactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProvisioningArtifactId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateSuggestionQuery(v *types.SuggestionQuery) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SuggestionQuery"}
	if v.PropertyNameQuery != nil {
		if err := validatePropertyNameQuery(v.PropertyNameQuery); err != nil {
			invalidParams.AddNested("PropertyNameQuery", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateTargetPlatform(v *types.TargetPlatform) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TargetPlatform"}
	if len(v.Os) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Os"))
	}
	if len(v.Arch) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Arch"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTrafficRoutingConfig(v *types.TrafficRoutingConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TrafficRoutingConfig"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.WaitIntervalInSeconds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WaitIntervalInSeconds"))
	}
	if v.CanarySize != nil {
		if err := validateCapacitySize(v.CanarySize); err != nil {
			invalidParams.AddNested("CanarySize", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTrainingJobDefinition(v *types.TrainingJobDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TrainingJobDefinition"}
	if len(v.TrainingInputMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TrainingInputMode"))
	}
	if v.InputDataConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputDataConfig"))
	} else if v.InputDataConfig != nil {
		if err := validateInputDataConfig(v.InputDataConfig); err != nil {
			invalidParams.AddNested("InputDataConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputDataConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputDataConfig"))
	} else if v.OutputDataConfig != nil {
		if err := validateOutputDataConfig(v.OutputDataConfig); err != nil {
			invalidParams.AddNested("OutputDataConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ResourceConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceConfig"))
	} else if v.ResourceConfig != nil {
		if err := validateResourceConfig(v.ResourceConfig); err != nil {
			invalidParams.AddNested("ResourceConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.StoppingCondition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StoppingCondition"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTrainingSpecification(v *types.TrainingSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TrainingSpecification"}
	if v.TrainingImage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrainingImage"))
	}
	if v.SupportedHyperParameters != nil {
		if err := validateHyperParameterSpecifications(v.SupportedHyperParameters); err != nil {
			invalidParams.AddNested("SupportedHyperParameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.SupportedTrainingInstanceTypes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SupportedTrainingInstanceTypes"))
	}
	if v.MetricDefinitions != nil {
		if err := validateMetricDefinitionList(v.MetricDefinitions); err != nil {
			invalidParams.AddNested("MetricDefinitions", err.(smithy.InvalidParamsError))
		}
	}
	if v.TrainingChannels == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrainingChannels"))
	} else if v.TrainingChannels != nil {
		if err := validateChannelSpecifications(v.TrainingChannels); err != nil {
			invalidParams.AddNested("TrainingChannels", err.(smithy.InvalidParamsError))
		}
	}
	if v.SupportedTuningJobObjectiveMetrics != nil {
		if err := validateHyperParameterTuningJobObjectives(v.SupportedTuningJobObjectiveMetrics); err != nil {
			invalidParams.AddNested("SupportedTuningJobObjectiveMetrics", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateTransformJobDefinition(v *types.TransformJobDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TransformJobDefinition"}
	if v.TransformInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransformInput"))
	} else if v.TransformInput != nil {
		if err := validateTransformInput(v.TransformInput); err != nil {
			invalidParams.AddNested("TransformInput", err.(smithy.InvalidParamsError))
		}
	}
	if v.TransformOutput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransformOutput"))
	} else if v.TransformOutput != nil {
		if err := validateTransformOutput(v.TransformOutput); err != nil {
			invalidParams.AddNested("TransformOutput", err.(smithy.InvalidParamsError))
		}
	}
	if v.TransformResources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransformResources"))
	} else if v.TransformResources != nil {
		if err := validateTransformResources(v.TransformResources); err != nil {
			invalidParams.AddNested("TransformResources", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTransformResources(v *types.TransformResources) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TransformResources"}
	if len(v.InstanceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceType"))
	}
	if v.InstanceCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceCount"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateUserSettings(v *types.UserSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UserSettings"}
	if v.KernelGatewayAppSettings != nil {
		if err := validateKernelGatewayAppSettings(v.KernelGatewayAppSettings); err != nil {
			invalidParams.AddNested("KernelGatewayAppSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpAddAssociationInput(v *AddAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddAssociationInput"}
	if v.SourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceArn"))
	}
	if v.DestinationArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpAssociateTrialComponentInput(v *AssociateTrialComponentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateTrialComponentInput"}
	if v.TrialComponentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrialComponentName"))
	}
	if v.TrialName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrialName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateActionInput(v *CreateActionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateActionInput"}
	if v.ActionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActionName"))
	}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	} else if v.Source != nil {
		if err := validateActionSource(v.Source); err != nil {
			invalidParams.AddNested("Source", err.(smithy.InvalidParamsError))
		}
	}
	if v.ActionType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActionType"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAlgorithmInput(v *CreateAlgorithmInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAlgorithmInput"}
	if v.AlgorithmName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AlgorithmName"))
	}
	if v.TrainingSpecification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrainingSpecification"))
	} else if v.TrainingSpecification != nil {
		if err := validateTrainingSpecification(v.TrainingSpecification); err != nil {
			invalidParams.AddNested("TrainingSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.InferenceSpecification != nil {
		if err := validateInferenceSpecification(v.InferenceSpecification); err != nil {
			invalidParams.AddNested("InferenceSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.ValidationSpecification != nil {
		if err := validateAlgorithmValidationSpecification(v.ValidationSpecification); err != nil {
			invalidParams.AddNested("ValidationSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateAppInput(v *CreateAppInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAppInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.UserProfileName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserProfileName"))
	}
	if len(v.AppType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AppType"))
	}
	if v.AppName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppName"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateAutoMLJobInput(v *CreateAutoMLJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAutoMLJobInput"}
	if v.AutoMLJobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoMLJobName"))
	}
	if v.InputDataConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputDataConfig"))
	} else if v.InputDataConfig != nil {
		if err := validateAutoMLInputDataConfig(v.InputDataConfig); err != nil {
			invalidParams.AddNested("InputDataConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputDataConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputDataConfig"))
	} else if v.OutputDataConfig != nil {
		if err := validateAutoMLOutputDataConfig(v.OutputDataConfig); err != nil {
			invalidParams.AddNested("OutputDataConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.AutoMLJobObjective != nil {
		if err := validateAutoMLJobObjective(v.AutoMLJobObjective); err != nil {
			invalidParams.AddNested("AutoMLJobObjective", err.(smithy.InvalidParamsError))
		}
	}
	if v.AutoMLJobConfig != nil {
		if err := validateAutoMLJobConfig(v.AutoMLJobConfig); err != nil {
			invalidParams.AddNested("AutoMLJobConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateCompilationJobInput(v *CreateCompilationJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCompilationJobInput"}
	if v.CompilationJobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CompilationJobName"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.InputConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputConfig"))
	} else if v.InputConfig != nil {
		if err := validateInputConfig(v.InputConfig); err != nil {
			invalidParams.AddNested("InputConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputConfig"))
	} else if v.OutputConfig != nil {
		if err := validateOutputConfig(v.OutputConfig); err != nil {
			invalidParams.AddNested("OutputConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.StoppingCondition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StoppingCondition"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateContextInput(v *CreateContextInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateContextInput"}
	if v.ContextName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContextName"))
	}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	} else if v.Source != nil {
		if err := validateContextSource(v.Source); err != nil {
			invalidParams.AddNested("Source", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContextType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContextType"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDataQualityJobDefinitionInput(v *CreateDataQualityJobDefinitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDataQualityJobDefinitionInput"}
	if v.JobDefinitionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobDefinitionName"))
	}
	if v.DataQualityAppSpecification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataQualityAppSpecification"))
	} else if v.DataQualityAppSpecification != nil {
		if err := validateDataQualityAppSpecification(v.DataQualityAppSpecification); err != nil {
			invalidParams.AddNested("DataQualityAppSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataQualityJobInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataQualityJobInput"))
	} else if v.DataQualityJobInput != nil {
		if err := validateDataQualityJobInput(v.DataQualityJobInput); err != nil {
			invalidParams.AddNested("DataQualityJobInput", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataQualityJobOutputConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataQualityJobOutputConfig"))
	} else if v.DataQualityJobOutputConfig != nil {
		if err := validateMonitoringOutputConfig(v.DataQualityJobOutputConfig); err != nil {
			invalidParams.AddNested("DataQualityJobOutputConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.JobResources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobResources"))
	} else if v.JobResources != nil {
		if err := validateMonitoringResources(v.JobResources); err != nil {
			invalidParams.AddNested("JobResources", err.(smithy.InvalidParamsError))
		}
	}
	if v.NetworkConfig != nil {
		if err := validateMonitoringNetworkConfig(v.NetworkConfig); err != nil {
			invalidParams.AddNested("NetworkConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.StoppingCondition != nil {
		if err := validateMonitoringStoppingCondition(v.StoppingCondition); err != nil {
			invalidParams.AddNested("StoppingCondition", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateDomainInput(v *CreateDomainInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDomainInput"}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if len(v.AuthMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AuthMode"))
	}
	if v.DefaultUserSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultUserSettings"))
	} else if v.DefaultUserSettings != nil {
		if err := validateUserSettings(v.DefaultUserSettings); err != nil {
			invalidParams.AddNested("DefaultUserSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
	}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateEdgePackagingJobInput(v *CreateEdgePackagingJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateEdgePackagingJobInput"}
	if v.EdgePackagingJobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EdgePackagingJobName"))
	}
	if v.CompilationJobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CompilationJobName"))
	}
	if v.ModelName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelName"))
	}
	if v.ModelVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelVersion"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.OutputConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputConfig"))
	} else if v.OutputConfig != nil {
		if err := validateEdgeOutputConfig(v.OutputConfig); err != nil {
			invalidParams.AddNested("OutputConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateEndpointConfigInput(v *CreateEndpointConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateEndpointConfigInput"}
	if v.EndpointConfigName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointConfigName"))
	}
	if v.ProductionVariants == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProductionVariants"))
	} else if v.ProductionVariants != nil {
		if err := validateProductionVariantList(v.ProductionVariants); err != nil {
			invalidParams.AddNested("ProductionVariants", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataCaptureConfig != nil {
		if err := validateDataCaptureConfig(v.DataCaptureConfig); err != nil {
			invalidParams.AddNested("DataCaptureConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpCreateFeatureGroupInput(v *CreateFeatureGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFeatureGroupInput"}
	if v.FeatureGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FeatureGroupName"))
	}
	if v.RecordIdentifierFeatureName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecordIdentifierFeatureName"))
	}
	if v.EventTimeFeatureName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EventTimeFeatureName"))
	}
	if v.FeatureDefinitions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FeatureDefinitions"))
	}
	if v.OfflineStoreConfig != nil {
		if err := validateOfflineStoreConfig(v.OfflineStoreConfig); err != nil {
			invalidParams.AddNested("OfflineStoreConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFlowDefinitionInput(v *CreateFlowDefinitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFlowDefinitionInput"}
	if v.FlowDefinitionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FlowDefinitionName"))
	}
	if v.HumanLoopRequestSource != nil {
		if err := validateHumanLoopRequestSource(v.HumanLoopRequestSource); err != nil {
			invalidParams.AddNested("HumanLoopRequestSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.HumanLoopActivationConfig != nil {
		if err := validateHumanLoopActivationConfig(v.HumanLoopActivationConfig); err != nil {
			invalidParams.AddNested("HumanLoopActivationConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.HumanLoopConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HumanLoopConfig"))
	} else if v.HumanLoopConfig != nil {
		if err := validateHumanLoopConfig(v.HumanLoopConfig); err != nil {
			invalidParams.AddNested("HumanLoopConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputConfig"))
	} else if v.OutputConfig != nil {
		if err := validateFlowDefinitionOutputConfig(v.OutputConfig); err != nil {
			invalidParams.AddNested("OutputConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateHyperParameterTuningJobInput(v *CreateHyperParameterTuningJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateHyperParameterTuningJobInput"}
	if v.HyperParameterTuningJobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HyperParameterTuningJobName"))
	}
	if v.HyperParameterTuningJobConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HyperParameterTuningJobConfig"))
	} else if v.HyperParameterTuningJobConfig != nil {
		if err := validateHyperParameterTuningJobConfig(v.HyperParameterTuningJobConfig); err != nil {
			invalidParams.AddNested("HyperParameterTuningJobConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.TrainingJobDefinition != nil {
		if err := validateHyperParameterTrainingJobDefinition(v.TrainingJobDefinition); err != nil {
			invalidParams.AddNested("TrainingJobDefinition", err.(smithy.InvalidParamsError))
		}
	}
	if v.TrainingJobDefinitions != nil {
		if err := validateHyperParameterTrainingJobDefinitions(v.TrainingJobDefinitions); err != nil {
			invalidParams.AddNested("TrainingJobDefinitions", err.(smithy.InvalidParamsError))
		}
	}
	if v.WarmStartConfig != nil {
		if err := validateHyperParameterTuningJobWarmStartConfig(v.WarmStartConfig); err != nil {
			invalidParams.AddNested("WarmStartConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateImageVersionInput(v *CreateImageVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateImageVersionInput"}
	if v.BaseImage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BaseImage"))
	}
	if v.ClientToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
	}
	if v.ImageName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLabelingJobInput(v *CreateLabelingJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLabelingJobInput"}
	if v.LabelingJobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LabelingJobName"))
	}
	if v.LabelAttributeName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LabelAttributeName"))
	}
	if v.InputConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputConfig"))
	} else if v.InputConfig != nil {
		if err := validateLabelingJobInputConfig(v.InputConfig); err != nil {
			invalidParams.AddNested("InputConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputConfig"))
	} else if v.OutputConfig != nil {
		if err := validateLabelingJobOutputConfig(v.OutputConfig); err != nil {
			invalidParams.AddNested("OutputConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.LabelingJobAlgorithmsConfig != nil {
		if err := validateLabelingJobAlgorithmsConfig(v.LabelingJobAlgorithmsConfig); err != nil {
			invalidParams.AddNested("LabelingJobAlgorithmsConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.HumanTaskConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HumanTaskConfig"))
	} else if v.HumanTaskConfig != nil {
		if err := validateHumanTaskConfig(v.HumanTaskConfig); err != nil {
			invalidParams.AddNested("HumanTaskConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateModelBiasJobDefinitionInput(v *CreateModelBiasJobDefinitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateModelBiasJobDefinitionInput"}
	if v.JobDefinitionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobDefinitionName"))
	}
	if v.ModelBiasAppSpecification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelBiasAppSpecification"))
	} else if v.ModelBiasAppSpecification != nil {
		if err := validateModelBiasAppSpecification(v.ModelBiasAppSpecification); err != nil {
			invalidParams.AddNested("ModelBiasAppSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.ModelBiasJobInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelBiasJobInput"))
	} else if v.ModelBiasJobInput != nil {
		if err := validateModelBiasJobInput(v.ModelBiasJobInput); err != nil {
			invalidParams.AddNested("ModelBiasJobInput", err.(smithy.InvalidParamsError))
		}
	}
	if v.ModelBiasJobOutputConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelBiasJobOutputConfig"))
	} else if v.ModelBiasJobOutputConfig != nil {
		if err := validateMonitoringOutputConfig(v.ModelBiasJobOutputConfig); err != nil {
			invalidParams.AddNested("ModelBiasJobOutputConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.JobResources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobResources"))
	} else if v.JobResources != nil {
		if err := validateMonitoringResources(v.JobResources); err != nil {
			invalidParams.AddNested("JobResources", err.(smithy.InvalidParamsError))
		}
	}
	if v.NetworkConfig != nil {
		if err := validateMonitoringNetworkConfig(v.NetworkConfig); err != nil {
			invalidParams.AddNested("NetworkConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.StoppingCondition != nil {
		if err := validateMonitoringStoppingCondition(v.StoppingCondition); err != nil {
			invalidParams.AddNested("StoppingCondition", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateModelExplainabilityJobDefinitionInput(v *CreateModelExplainabilityJobDefinitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateModelExplainabilityJobDefinitionInput"}
	if v.JobDefinitionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobDefinitionName"))
	}
	if v.ModelExplainabilityAppSpecification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelExplainabilityAppSpecification"))
	} else if v.ModelExplainabilityAppSpecification != nil {
		if err := validateModelExplainabilityAppSpecification(v.ModelExplainabilityAppSpecification); err != nil {
			invalidParams.AddNested("ModelExplainabilityAppSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.ModelExplainabilityJobInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelExplainabilityJobInput"))
	} else if v.ModelExplainabilityJobInput != nil {
		if err := validateModelExplainabilityJobInput(v.ModelExplainabilityJobInput); err != nil {
			invalidParams.AddNested("ModelExplainabilityJobInput", err.(smithy.InvalidParamsError))
		}
	}
	if v.ModelExplainabilityJobOutputConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelExplainabilityJobOutputConfig"))
	} else if v.ModelExplainabilityJobOutputConfig != nil {
		if err := validateMonitoringOutputConfig(v.ModelExplainabilityJobOutputConfig); err != nil {
			invalidParams.AddNested("ModelExplainabilityJobOutputConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.JobResources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobResources"))
	} else if v.JobResources != nil {
		if err := validateMonitoringResources(v.JobResources); err != nil {
			invalidParams.AddNested("JobResources", err.(smithy.InvalidParamsError))
		}
	}
	if v.NetworkConfig != nil {
		if err := validateMonitoringNetworkConfig(v.NetworkConfig); err != nil {
			invalidParams.AddNested("NetworkConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.StoppingCondition != nil {
		if err := validateMonitoringStoppingCondition(v.StoppingCondition); err != nil {
			invalidParams.AddNested("StoppingCondition", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateModelInput(v *CreateModelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateModelInput"}
	if v.ModelName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelName"))
	}
	if v.PrimaryContainer != nil {
		if err := validateContainerDefinition(v.PrimaryContainer); err != nil {
			invalidParams.AddNested("PrimaryContainer", err.(smithy.InvalidParamsError))
		}
	}
	if v.Containers != nil {
		if err := validateContainerDefinitionList(v.Containers); err != nil {
			invalidParams.AddNested("Containers", err.(smithy.InvalidParamsError))
		}
	}
	if v.InferenceExecutionConfig != nil {
		if err := validateInferenceExecutionConfig(v.InferenceExecutionConfig); err != nil {
			invalidParams.AddNested("InferenceExecutionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ExecutionRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExecutionRoleArn"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.VpcConfig != nil {
		if err := validateVpcConfig(v.VpcConfig); err != nil {
			invalidParams.AddNested("VpcConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateModelPackageInput(v *CreateModelPackageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateModelPackageInput"}
	if v.InferenceSpecification != nil {
		if err := validateInferenceSpecification(v.InferenceSpecification); err != nil {
			invalidParams.AddNested("InferenceSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.ValidationSpecification != nil {
		if err := validateModelPackageValidationSpecification(v.ValidationSpecification); err != nil {
			invalidParams.AddNested("ValidationSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.SourceAlgorithmSpecification != nil {
		if err := validateSourceAlgorithmSpecification(v.SourceAlgorithmSpecification); err != nil {
			invalidParams.AddNested("SourceAlgorithmSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.ModelMetrics != nil {
		if err := validateModelMetrics(v.ModelMetrics); err != nil {
			invalidParams.AddNested("ModelMetrics", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateModelQualityJobDefinitionInput(v *CreateModelQualityJobDefinitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateModelQualityJobDefinitionInput"}
	if v.JobDefinitionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobDefinitionName"))
	}
	if v.ModelQualityAppSpecification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelQualityAppSpecification"))
	} else if v.ModelQualityAppSpecification != nil {
		if err := validateModelQualityAppSpecification(v.ModelQualityAppSpecification); err != nil {
			invalidParams.AddNested("ModelQualityAppSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.ModelQualityJobInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelQualityJobInput"))
	} else if v.ModelQualityJobInput != nil {
		if err := validateModelQualityJobInput(v.ModelQualityJobInput); err != nil {
			invalidParams.AddNested("ModelQualityJobInput", err.(smithy.InvalidParamsError))
		}
	}
	if v.ModelQualityJobOutputConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelQualityJobOutputConfig"))
	} else if v.ModelQualityJobOutputConfig != nil {
		if err := validateMonitoringOutputConfig(v.ModelQualityJobOutputConfig); err != nil {
			invalidParams.AddNested("ModelQualityJobOutputConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.JobResources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobResources"))
	} else if v.JobResources != nil {
		if err := validateMonitoringResources(v.JobResources); err != nil {
			invalidParams.AddNested("JobResources", err.(smithy.InvalidParamsError))
		}
	}
	if v.NetworkConfig != nil {
		if err := validateMonitoringNetworkConfig(v.NetworkConfig); err != nil {
			invalidParams.AddNested("NetworkConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.StoppingCondition != nil {
		if err := validateMonitoringStoppingCondition(v.StoppingCondition); err != nil {
			invalidParams.AddNested("StoppingCondition", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateNotebookInstanceInput(v *CreateNotebookInstanceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateNotebookInstanceInput"}
	if v.NotebookInstanceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NotebookInstanceName"))
	}
	if len(v.InstanceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceType"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreatePipelineInput(v *CreatePipelineInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePipelineInput"}
	if v.PipelineName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PipelineName"))
	}
	if v.PipelineDefinition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PipelineDefinition"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePresignedDomainUrlInput(v *CreatePresignedDomainUrlInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePresignedDomainUrlInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.UserProfileName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserProfileName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateProcessingJobInput(v *CreateProcessingJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateProcessingJobInput"}
	if v.ProcessingInputs != nil {
		if err := validateProcessingInputs(v.ProcessingInputs); err != nil {
			invalidParams.AddNested("ProcessingInputs", err.(smithy.InvalidParamsError))
		}
	}
	if v.ProcessingOutputConfig != nil {
		if err := validateProcessingOutputConfig(v.ProcessingOutputConfig); err != nil {
			invalidParams.AddNested("ProcessingOutputConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ProcessingJobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProcessingJobName"))
	}
	if v.ProcessingResources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProcessingResources"))
	} else if v.ProcessingResources != nil {
		if err := validateProcessingResources(v.ProcessingResources); err != nil {
			invalidParams.AddNested("ProcessingResources", err.(smithy.InvalidParamsError))
		}
	}
	if v.StoppingCondition != nil {
		if err := validateProcessingStoppingCondition(v.StoppingCondition); err != nil {
			invalidParams.AddNested("StoppingCondition", err.(smithy.InvalidParamsError))
		}
	}
	if v.AppSpecification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppSpecification"))
	} else if v.AppSpecification != nil {
		if err := validateAppSpecification(v.AppSpecification); err != nil {
			invalidParams.AddNested("AppSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.NetworkConfig != nil {
		if err := validateNetworkConfig(v.NetworkConfig); err != nil {
			invalidParams.AddNested("NetworkConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateTrainingJobInput(v *CreateTrainingJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTrainingJobInput"}
	if v.TrainingJobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrainingJobName"))
	}
	if v.AlgorithmSpecification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AlgorithmSpecification"))
	} else if v.AlgorithmSpecification != nil {
		if err := validateAlgorithmSpecification(v.AlgorithmSpecification); err != nil {
			invalidParams.AddNested("AlgorithmSpecification", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.InputDataConfig != nil {
		if err := validateInputDataConfig(v.InputDataConfig); err != nil {
			invalidParams.AddNested("InputDataConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputDataConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputDataConfig"))
	} else if v.OutputDataConfig != nil {
		if err := validateOutputDataConfig(v.OutputDataConfig); err != nil {
			invalidParams.AddNested("OutputDataConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ResourceConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceConfig"))
	} else if v.ResourceConfig != nil {
		if err := validateResourceConfig(v.ResourceConfig); err != nil {
			invalidParams.AddNested("ResourceConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.VpcConfig != nil {
		if err := validateVpcConfig(v.VpcConfig); err != nil {
			invalidParams.AddNested("VpcConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.StoppingCondition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StoppingCondition"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.CheckpointConfig != nil {
		if err := validateCheckpointConfig(v.CheckpointConfig); err != nil {
			invalidParams.AddNested("CheckpointConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.DebugHookConfig != nil {
		if err := validateDebugHookConfig(v.DebugHookConfig); err != nil {
			invalidParams.AddNested("DebugHookConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.DebugRuleConfigurations != nil {
		if err := validateDebugRuleConfigurations(v.DebugRuleConfigurations); err != nil {
			invalidParams.AddNested("DebugRuleConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.TensorBoardOutputConfig != nil {
		if err := validateTensorBoardOutputConfig(v.TensorBoardOutputConfig); err != nil {
			invalidParams.AddNested("TensorBoardOutputConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ProfilerConfig != nil {
		if err := validateProfilerConfig(v.ProfilerConfig); err != nil {
			invalidParams.AddNested("ProfilerConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ProfilerRuleConfigurations != nil {
		if err := validateProfilerRuleConfigurations(v.ProfilerRuleConfigurations); err != nil {
			invalidParams.AddNested("ProfilerRuleConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTransformJobInput(v *CreateTransformJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTransformJobInput"}
	if v.TransformJobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransformJobName"))
	}
	if v.ModelName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelName"))
	}
	if v.TransformInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransformInput"))
	} else if v.TransformInput != nil {
		if err := validateTransformInput(v.TransformInput); err != nil {
			invalidParams.AddNested("TransformInput", err.(smithy.InvalidParamsError))
		}
	}
	if v.TransformOutput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransformOutput"))
	} else if v.TransformOutput != nil {
		if err := validateTransformOutput(v.TransformOutput); err != nil {
			invalidParams.AddNested("TransformOutput", err.(smithy.InvalidParamsError))
		}
	}
	if v.TransformResources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransformResources"))
	} else if v.TransformResources != nil {
		if err := validateTransformResources(v.TransformResources); err != nil {
			invalidParams.AddNested("TransformResources", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTrialComponentInput(v *CreateTrialComponentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTrialComponentInput"}
	if v.TrialComponentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrialComponentName"))
	}
	if v.InputArtifacts != nil {
		if err := validateTrialComponentArtifacts(v.InputArtifacts); err != nil {
			invalidParams.AddNested("InputArtifacts", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputArtifacts != nil {
		if err := validateTrialComponentArtifacts(v.OutputArtifacts); err != nil {
			invalidParams.AddNested("OutputArtifacts", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateUserProfileInput(v *CreateUserProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateUserProfileInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.UserProfileName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserProfileName"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.UserSettings != nil {
		if err := validateUserSettings(v.UserSettings); err != nil {
			invalidParams.AddNested("UserSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateWorkforceInput(v *CreateWorkforceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateWorkforceInput"}
	if v.CognitoConfig != nil {
		if err := validateCognitoConfig(v.CognitoConfig); err != nil {
			invalidParams.AddNested("CognitoConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.OidcConfig != nil {
		if err := validateOidcConfig(v.OidcConfig); err != nil {
			invalidParams.AddNested("OidcConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.SourceIpConfig != nil {
		if err := validateSourceIpConfig(v.SourceIpConfig); err != nil {
			invalidParams.AddNested("SourceIpConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.WorkforceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkforceName"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateWorkteamInput(v *CreateWorkteamInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateWorkteamInput"}
	if v.WorkteamName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkteamName"))
	}
	if v.MemberDefinitions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemberDefinitions"))
	} else if v.MemberDefinitions != nil {
		if err := validateMemberDefinitions(v.MemberDefinitions); err != nil {
			invalidParams.AddNested("MemberDefinitions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Description == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Description"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpDeleteAppInput(v *DeleteAppInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAppInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.UserProfileName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserProfileName"))
	}
	if len(v.AppType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AppType"))
	}
	if v.AppName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteArtifactInput(v *DeleteArtifactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteArtifactInput"}
	if v.Source != nil {
		if err := validateArtifactSource(v.Source); err != nil {
			invalidParams.AddNested("Source", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteAssociationInput(v *DeleteAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAssociationInput"}
	if v.SourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceArn"))
	}
	if v.DestinationArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpDeleteImageVersionInput(v *DeleteImageVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteImageVersionInput"}
	if v.ImageName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageName"))
	}
	if v.Version == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Version"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

func validateOpDeletePipelineInput(v *DeletePipelineInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeletePipelineInput"}
	if v.PipelineName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PipelineName"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpDeleteUserProfileInput(v *DeleteUserProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserProfileInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.UserProfileName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserProfileName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeregisterDevicesInput(v *DeregisterDevicesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeregisterDevicesInput"}
	if v.DeviceFleetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceFleetName"))
	}
	if v.DeviceNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpDescribeAppInput(v *DescribeAppInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeAppInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.UserProfileName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserProfileName"))
	}
	if len(v.AppType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AppType"))
	}
	if v.AppName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

func validateOpDescribeDeviceInput(v *DescribeDeviceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDeviceInput"}
	if v.DeviceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceName"))
	}
	if v.DeviceFleetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceFleetName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpDescribeUserProfileInput(v *DescribeUserProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeUserProfileInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.UserProfileName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserProfileName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDisassociateTrialComponentInput(v *DisassociateTrialComponentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateTrialComponentInput"}
	if v.TrialComponentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrialComponentName"))
	}
	if v.TrialName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrialName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpGetSearchSuggestionsInput(v *GetSearchSuggestionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSearchSuggestionsInput"}
	if len(v.Resource) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Resource"))
	}
	if v.SuggestionQuery != nil {
		if err := validateSuggestionQuery(v.SuggestionQuery); err != nil {
			invalidParams.AddNested("SuggestionQuery", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

func validateOpPutModelPackageGroupPolicyInput(v *PutModelPackageGroupPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutModelPackageGroupPolicyInput"}
	if v.ModelPackageGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelPackageGroupName"))
	}
	if v.ResourcePolicy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourcePolicy"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpRenderUiTemplateInput(v *RenderUiTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RenderUiTemplateInput"}
	if v.UiTemplate != nil {
		if err := validateUiTemplate(v.UiTemplate); err != nil {
			invalidParams.AddNested("UiTemplate", err.(smithy.InvalidParamsError))
		}
	}
	if v.Task == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Task"))
	} else if v.Task != nil {
		if err := validateRenderableTask(v.Task); err != nil {
			invalidParams.AddNested("Task", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchInput(v *SearchInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchInput"}
	if len(v.Resource) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Resource"))
	}
	if v.SearchExpression != nil {
		if err := validateSearchExpression(v.SearchExpression); err != nil {
			invalidParams.AddNested("SearchExpression", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpStartPipelineExecutionInput(v *StartPipelineExecutionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartPipelineExecutionInput"}
	if v.PipelineName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PipelineName"))
	}
	if v.PipelineParameters != nil {
		if err := validateParameterList(v.PipelineParameters); err != nil {
			invalidParams.AddNested("PipelineParameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

func validateOpStopPipelineExecutionInput(v *StopPipelineExecutionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopPipelineExecutionInput"}
	if v.PipelineExecutionArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PipelineExecutionArn"))
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpUpdateAppImageConfigInput(v *UpdateAppImageConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAppImageConfigInput"}
	if v.AppImageConfigName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AppImageConfigName"))
	}
	if v.KernelGatewayImageConfig != nil {
		if err := validateKernelGatewayImageConfig(v.KernelGatewayImageConfig); err != nil {
			invalidParams.AddNested("KernelGatewayImageConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpUpdateDeviceFleetInput(v *UpdateDeviceFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDeviceFleetInput"}
	if v.DeviceFleetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceFleetName"))
	}
	if v.OutputConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputConfig"))
	} else if v.OutputConfig != nil {
		if err := validateEdgeOutputConfig(v.OutputConfig); err != nil {
			invalidParams.AddNested("OutputConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDevicesInput(v *UpdateDevicesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDevicesInput"}
	if v.DeviceFleetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceFleetName"))
	}
	if v.Devices == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Devices"))
	} else if v.Devices != nil {
		if err := validateDevices(v.Devices); err != nil {
			invalidParams.AddNested("Devices", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDomainInput(v *UpdateDomainInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDomainInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.DefaultUserSettings != nil {
		if err := validateUserSettings(v.DefaultUserSettings); err != nil {
			invalidParams.AddNested("DefaultUserSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateEndpointInput(v *UpdateEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateEndpointInput"}
	if v.EndpointName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointName"))
	}
	if v.EndpointConfigName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointConfigName"))
	}
	if v.ExcludeRetainedVariantProperties != nil {
		if err := validateVariantPropertyList(v.ExcludeRetainedVariantProperties); err != nil {
			invalidParams.AddNested("ExcludeRetainedVariantProperties", err.(smithy.InvalidParamsError))
		}
	}
	if v.DeploymentConfig != nil {
		if err := validateDeploymentConfig(v.DeploymentConfig); err != nil {
			invalidParams.AddNested("DeploymentConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateEndpointWeightsAndCapacitiesInput(v *UpdateEndpointWeightsAndCapacitiesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateEndpointWeightsAndCapacitiesInput"}
	if v.EndpointName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointName"))
	}
	if v.DesiredWeightsAndCapacities == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DesiredWeightsAndCapacities"))
	} else if v.DesiredWeightsAndCapacities != nil {
		if err := validateDesiredWeightAndCapacityList(v.DesiredWeightsAndCapacities); err != nil {
			invalidParams.AddNested("DesiredWeightsAndCapacities", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpUpdateModelPackageInput(v *UpdateModelPackageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateModelPackageInput"}
	if v.ModelPackageArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ModelPackageArn"))
	}
	if len(v.ModelApprovalStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ModelApprovalStatus"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateMonitoringScheduleInput(v *UpdateMonitoringScheduleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateMonitoringScheduleInput"}
	if v.MonitoringScheduleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MonitoringScheduleName"))
	}
	if v.MonitoringScheduleConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MonitoringScheduleConfig"))
	} else if v.MonitoringScheduleConfig != nil {
		if err := validateMonitoringScheduleConfig(v.MonitoringScheduleConfig); err != nil {
			invalidParams.AddNested("MonitoringScheduleConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpUpdateTrainingJobInput(v *UpdateTrainingJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTrainingJobInput"}
	if v.TrainingJobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrainingJobName"))
	}
	if v.ProfilerRuleConfigurations != nil {
		if err := validateProfilerRuleConfigurations(v.ProfilerRuleConfigurations); err != nil {
			invalidParams.AddNested("ProfilerRuleConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateTrialComponentInput(v *UpdateTrialComponentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTrialComponentInput"}
	if v.TrialComponentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrialComponentName"))
	}
	if v.InputArtifacts != nil {
		if err := validateTrialComponentArtifacts(v.InputArtifacts); err != nil {
			invalidParams.AddNested("InputArtifacts", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputArtifacts != nil {
		if err := validateTrialComponentArtifacts(v.OutputArtifacts); err != nil {
			invalidParams.AddNested("OutputArtifacts", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateUserProfileInput(v *UpdateUserProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserProfileInput"}
	if v.DomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainId"))
	}
	if v.UserProfileName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserProfileName"))
	}
	if v.UserSettings != nil {
		if err := validateUserSettings(v.UserSettings); err != nil {
			invalidParams.AddNested("UserSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateWorkforceInput(v *UpdateWorkforceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateWorkforceInput"}
	if v.WorkforceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkforceName"))
	}
	if v.SourceIpConfig != nil {
		if err := validateSourceIpConfig(v.SourceIpConfig); err != nil {
			invalidParams.AddNested("SourceIpConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.OidcConfig != nil {
		if err := validateOidcConfig(v.OidcConfig); err != nil {
			invalidParams.AddNested("OidcConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateWorkteamInput(v *UpdateWorkteamInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateWorkteamInput"}
	if v.WorkteamName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkteamName"))
	}
	if v.MemberDefinitions != nil {
		if err := validateMemberDefinitions(v.MemberDefinitions); err != nil {
			invalidParams.AddNested("MemberDefinitions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}