service/databasemigrationservice/validators.go

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

package databasemigrationservice

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

type validateOpAddTagsToResource struct {
}

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

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

type validateOpApplyPendingMaintenanceAction struct {
}

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

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

type validateOpBatchStartRecommendations struct {
}

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

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

type validateOpCancelReplicationTaskAssessmentRun struct {
}

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

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

type validateOpCreateDataMigration struct {
}

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

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

type validateOpCreateDataProvider struct {
}

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

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

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

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

type validateOpCreateFleetAdvisorCollector struct {
}

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

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

type validateOpCreateMigrationProject struct {
}

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

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

type validateOpCreateReplicationConfig struct {
}

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

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

type validateOpCreateReplicationInstance struct {
}

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

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

type validateOpCreateReplicationSubnetGroup struct {
}

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

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

type validateOpCreateReplicationTask struct {
}

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

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

type validateOpDeleteCertificate struct {
}

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

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

type validateOpDeleteConnection struct {
}

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

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

type validateOpDeleteDataMigration struct {
}

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

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

type validateOpDeleteDataProvider struct {
}

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

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

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

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

type validateOpDeleteFleetAdvisorCollector struct {
}

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

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

type validateOpDeleteFleetAdvisorDatabases struct {
}

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

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

type validateOpDeleteInstanceProfile struct {
}

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

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

type validateOpDeleteMigrationProject struct {
}

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

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

type validateOpDeleteReplicationConfig struct {
}

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

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

type validateOpDeleteReplicationInstance struct {
}

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

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

type validateOpDeleteReplicationSubnetGroup struct {
}

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

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

type validateOpDeleteReplicationTaskAssessmentRun struct {
}

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

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

type validateOpDeleteReplicationTask struct {
}

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

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

type validateOpDescribeCertificates struct {
}

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

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

type validateOpDescribeConnections struct {
}

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

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

type validateOpDescribeConversionConfiguration struct {
}

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

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

type validateOpDescribeDataMigrations struct {
}

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

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

type validateOpDescribeDataProviders struct {
}

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

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

type validateOpDescribeEndpointSettings struct {
}

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

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

type validateOpDescribeEndpoints struct {
}

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

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

type validateOpDescribeEndpointTypes struct {
}

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

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

type validateOpDescribeEventCategories struct {
}

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

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

type validateOpDescribeEvents struct {
}

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

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

type validateOpDescribeEventSubscriptions struct {
}

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

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

type validateOpDescribeExtensionPackAssociations struct {
}

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

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

type validateOpDescribeFleetAdvisorCollectors struct {
}

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

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

type validateOpDescribeFleetAdvisorDatabases struct {
}

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

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

type validateOpDescribeFleetAdvisorSchemaObjectSummary struct {
}

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

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

type validateOpDescribeFleetAdvisorSchemas struct {
}

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

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

type validateOpDescribeInstanceProfiles struct {
}

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

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

type validateOpDescribeMetadataModelAssessments struct {
}

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

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

type validateOpDescribeMetadataModelConversions struct {
}

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

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

type validateOpDescribeMetadataModelExportsAsScript struct {
}

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

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

type validateOpDescribeMetadataModelExportsToTarget struct {
}

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

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

type validateOpDescribeMetadataModelImports struct {
}

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

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

type validateOpDescribeMigrationProjects struct {
}

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

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

type validateOpDescribePendingMaintenanceActions struct {
}

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

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

type validateOpDescribeRecommendationLimitations struct {
}

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

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

type validateOpDescribeRecommendations struct {
}

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

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

type validateOpDescribeRefreshSchemasStatus struct {
}

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

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

type validateOpDescribeReplicationConfigs struct {
}

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

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

type validateOpDescribeReplicationInstances struct {
}

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

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

type validateOpDescribeReplicationInstanceTaskLogs struct {
}

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

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

type validateOpDescribeReplications struct {
}

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

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

type validateOpDescribeReplicationSubnetGroups struct {
}

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

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

type validateOpDescribeReplicationTableStatistics struct {
}

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

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

type validateOpDescribeReplicationTaskAssessmentRuns struct {
}

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

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

type validateOpDescribeReplicationTaskIndividualAssessments struct {
}

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

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

type validateOpDescribeReplicationTasks struct {
}

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

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

type validateOpDescribeSchemas struct {
}

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

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

type validateOpDescribeTableStatistics struct {
}

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

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

type validateOpExportMetadataModelAssessment struct {
}

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

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

type validateOpImportCertificate struct {
}

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

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

type validateOpModifyConversionConfiguration struct {
}

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

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

type validateOpModifyDataMigration struct {
}

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

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

type validateOpModifyDataProvider struct {
}

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

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

type validateOpModifyEndpoint struct {
}

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

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

type validateOpModifyEventSubscription struct {
}

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

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

type validateOpModifyInstanceProfile struct {
}

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

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

type validateOpModifyMigrationProject struct {
}

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

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

type validateOpModifyReplicationConfig struct {
}

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

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

type validateOpModifyReplicationInstance struct {
}

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

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

type validateOpModifyReplicationSubnetGroup struct {
}

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

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

type validateOpModifyReplicationTask struct {
}

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

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

type validateOpMoveReplicationTask struct {
}

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

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

type validateOpRebootReplicationInstance struct {
}

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

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

type validateOpRefreshSchemas struct {
}

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

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

type validateOpReloadReplicationTables struct {
}

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

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

type validateOpReloadTables struct {
}

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

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

type validateOpRemoveTagsFromResource struct {
}

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

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

type validateOpStartDataMigration struct {
}

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

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

type validateOpStartExtensionPackAssociation struct {
}

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

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

type validateOpStartMetadataModelAssessment struct {
}

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

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

type validateOpStartMetadataModelConversion struct {
}

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

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

type validateOpStartMetadataModelExportAsScript struct {
}

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

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

type validateOpStartMetadataModelExportToTarget struct {
}

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

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

type validateOpStartMetadataModelImport struct {
}

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

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

type validateOpStartRecommendations struct {
}

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

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

type validateOpStartReplication struct {
}

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

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

type validateOpStartReplicationTaskAssessment struct {
}

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

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

type validateOpStartReplicationTaskAssessmentRun struct {
}

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

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

type validateOpStartReplicationTask struct {
}

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

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

type validateOpStopDataMigration struct {
}

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

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

type validateOpStopReplication struct {
}

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

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

type validateOpStopReplicationTask struct {
}

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

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

type validateOpTestConnection struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateElasticsearchSettings(v *types.ElasticsearchSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ElasticsearchSettings"}
	if v.ServiceAccessRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceAccessRoleArn"))
	}
	if v.EndpointUri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointUri"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFilter(v *types.Filter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Filter"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Values == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Values"))
	}
	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 validateNeptuneSettings(v *types.NeptuneSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NeptuneSettings"}
	if v.S3BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3BucketName"))
	}
	if v.S3BucketFolder == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3BucketFolder"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRecommendationSettings(v *types.RecommendationSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RecommendationSettings"}
	if v.InstanceSizingType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceSizingType"))
	}
	if v.WorkloadType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateStartRecommendationsRequestEntry(v *types.StartRecommendationsRequestEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartRecommendationsRequestEntry"}
	if v.DatabaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseId"))
	}
	if v.Settings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Settings"))
	} else if v.Settings != nil {
		if err := validateRecommendationSettings(v.Settings); err != nil {
			invalidParams.AddNested("Settings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateTimestreamSettings(v *types.TimestreamSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TimestreamSettings"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.MemoryDuration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryDuration"))
	}
	if v.MagneticDuration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MagneticDuration"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpApplyPendingMaintenanceActionInput(v *ApplyPendingMaintenanceActionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ApplyPendingMaintenanceActionInput"}
	if v.ReplicationInstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationInstanceArn"))
	}
	if v.ApplyAction == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplyAction"))
	}
	if v.OptInType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OptInType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchStartRecommendationsInput(v *BatchStartRecommendationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchStartRecommendationsInput"}
	if v.Data != nil {
		if err := validateStartRecommendationsRequestEntryList(v.Data); err != nil {
			invalidParams.AddNested("Data", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateDataMigrationInput(v *CreateDataMigrationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDataMigrationInput"}
	if v.MigrationProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationProjectIdentifier"))
	}
	if len(v.DataMigrationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DataMigrationType"))
	}
	if v.ServiceAccessRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceAccessRoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDataProviderInput(v *CreateDataProviderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDataProviderInput"}
	if v.Engine == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Engine"))
	}
	if v.Settings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Settings"))
	}
	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.EndpointIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointIdentifier"))
	}
	if len(v.EndpointType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointType"))
	}
	if v.EngineName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EngineName"))
	}
	if v.DynamoDbSettings != nil {
		if err := validateDynamoDbSettings(v.DynamoDbSettings); err != nil {
			invalidParams.AddNested("DynamoDbSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.ElasticsearchSettings != nil {
		if err := validateElasticsearchSettings(v.ElasticsearchSettings); err != nil {
			invalidParams.AddNested("ElasticsearchSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.NeptuneSettings != nil {
		if err := validateNeptuneSettings(v.NeptuneSettings); err != nil {
			invalidParams.AddNested("NeptuneSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.RedisSettings != nil {
		if err := validateRedisSettings(v.RedisSettings); err != nil {
			invalidParams.AddNested("RedisSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.TimestreamSettings != nil {
		if err := validateTimestreamSettings(v.TimestreamSettings); err != nil {
			invalidParams.AddNested("TimestreamSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateFleetAdvisorCollectorInput(v *CreateFleetAdvisorCollectorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFleetAdvisorCollectorInput"}
	if v.CollectorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollectorName"))
	}
	if v.ServiceAccessRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceAccessRoleArn"))
	}
	if v.S3BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3BucketName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMigrationProjectInput(v *CreateMigrationProjectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMigrationProjectInput"}
	if v.SourceDataProviderDescriptors == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceDataProviderDescriptors"))
	} else if v.SourceDataProviderDescriptors != nil {
		if err := validateDataProviderDescriptorDefinitionList(v.SourceDataProviderDescriptors); err != nil {
			invalidParams.AddNested("SourceDataProviderDescriptors", err.(smithy.InvalidParamsError))
		}
	}
	if v.TargetDataProviderDescriptors == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetDataProviderDescriptors"))
	} else if v.TargetDataProviderDescriptors != nil {
		if err := validateDataProviderDescriptorDefinitionList(v.TargetDataProviderDescriptors); err != nil {
			invalidParams.AddNested("TargetDataProviderDescriptors", err.(smithy.InvalidParamsError))
		}
	}
	if v.InstanceProfileIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceProfileIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateReplicationConfigInput(v *CreateReplicationConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateReplicationConfigInput"}
	if v.ReplicationConfigIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationConfigIdentifier"))
	}
	if v.SourceEndpointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceEndpointArn"))
	}
	if v.TargetEndpointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetEndpointArn"))
	}
	if v.ComputeConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ComputeConfig"))
	}
	if len(v.ReplicationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationType"))
	}
	if v.TableMappings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableMappings"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateReplicationInstanceInput(v *CreateReplicationInstanceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateReplicationInstanceInput"}
	if v.ReplicationInstanceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationInstanceIdentifier"))
	}
	if v.ReplicationInstanceClass == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationInstanceClass"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateReplicationSubnetGroupInput(v *CreateReplicationSubnetGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateReplicationSubnetGroupInput"}
	if v.ReplicationSubnetGroupIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationSubnetGroupIdentifier"))
	}
	if v.ReplicationSubnetGroupDescription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationSubnetGroupDescription"))
	}
	if v.SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateReplicationTaskInput(v *CreateReplicationTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateReplicationTaskInput"}
	if v.ReplicationTaskIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationTaskIdentifier"))
	}
	if v.SourceEndpointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceEndpointArn"))
	}
	if v.TargetEndpointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetEndpointArn"))
	}
	if v.ReplicationInstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationInstanceArn"))
	}
	if len(v.MigrationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationType"))
	}
	if v.TableMappings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableMappings"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpDescribeCertificatesInput(v *DescribeCertificatesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeCertificatesInput"}
	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 validateOpDescribeConnectionsInput(v *DescribeConnectionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeConnectionsInput"}
	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 validateOpDescribeConversionConfigurationInput(v *DescribeConversionConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeConversionConfigurationInput"}
	if v.MigrationProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationProjectIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeDataMigrationsInput(v *DescribeDataMigrationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDataMigrationsInput"}
	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 validateOpDescribeDataProvidersInput(v *DescribeDataProvidersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDataProvidersInput"}
	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 validateOpDescribeEndpointSettingsInput(v *DescribeEndpointSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeEndpointSettingsInput"}
	if v.EngineName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EngineName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeEndpointsInput(v *DescribeEndpointsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeEndpointsInput"}
	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 validateOpDescribeEndpointTypesInput(v *DescribeEndpointTypesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeEndpointTypesInput"}
	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 validateOpDescribeEventCategoriesInput(v *DescribeEventCategoriesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeEventCategoriesInput"}
	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 validateOpDescribeEventsInput(v *DescribeEventsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeEventsInput"}
	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 validateOpDescribeEventSubscriptionsInput(v *DescribeEventSubscriptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeEventSubscriptionsInput"}
	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 validateOpDescribeExtensionPackAssociationsInput(v *DescribeExtensionPackAssociationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeExtensionPackAssociationsInput"}
	if v.MigrationProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationProjectIdentifier"))
	}
	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 validateOpDescribeFleetAdvisorCollectorsInput(v *DescribeFleetAdvisorCollectorsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeFleetAdvisorCollectorsInput"}
	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 validateOpDescribeFleetAdvisorDatabasesInput(v *DescribeFleetAdvisorDatabasesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeFleetAdvisorDatabasesInput"}
	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 validateOpDescribeFleetAdvisorSchemaObjectSummaryInput(v *DescribeFleetAdvisorSchemaObjectSummaryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeFleetAdvisorSchemaObjectSummaryInput"}
	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 validateOpDescribeFleetAdvisorSchemasInput(v *DescribeFleetAdvisorSchemasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeFleetAdvisorSchemasInput"}
	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 validateOpDescribeInstanceProfilesInput(v *DescribeInstanceProfilesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeInstanceProfilesInput"}
	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 validateOpDescribeMetadataModelAssessmentsInput(v *DescribeMetadataModelAssessmentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeMetadataModelAssessmentsInput"}
	if v.MigrationProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationProjectIdentifier"))
	}
	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 validateOpDescribeMetadataModelConversionsInput(v *DescribeMetadataModelConversionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeMetadataModelConversionsInput"}
	if v.MigrationProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationProjectIdentifier"))
	}
	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 validateOpDescribeMetadataModelExportsAsScriptInput(v *DescribeMetadataModelExportsAsScriptInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeMetadataModelExportsAsScriptInput"}
	if v.MigrationProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationProjectIdentifier"))
	}
	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 validateOpDescribeMetadataModelExportsToTargetInput(v *DescribeMetadataModelExportsToTargetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeMetadataModelExportsToTargetInput"}
	if v.MigrationProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationProjectIdentifier"))
	}
	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 validateOpDescribeMetadataModelImportsInput(v *DescribeMetadataModelImportsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeMetadataModelImportsInput"}
	if v.MigrationProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationProjectIdentifier"))
	}
	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 validateOpDescribeMigrationProjectsInput(v *DescribeMigrationProjectsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeMigrationProjectsInput"}
	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 validateOpDescribePendingMaintenanceActionsInput(v *DescribePendingMaintenanceActionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribePendingMaintenanceActionsInput"}
	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 validateOpDescribeRecommendationLimitationsInput(v *DescribeRecommendationLimitationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeRecommendationLimitationsInput"}
	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 validateOpDescribeRecommendationsInput(v *DescribeRecommendationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeRecommendationsInput"}
	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 validateOpDescribeRefreshSchemasStatusInput(v *DescribeRefreshSchemasStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeRefreshSchemasStatusInput"}
	if v.EndpointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeReplicationConfigsInput(v *DescribeReplicationConfigsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeReplicationConfigsInput"}
	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 validateOpDescribeReplicationInstancesInput(v *DescribeReplicationInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeReplicationInstancesInput"}
	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 validateOpDescribeReplicationInstanceTaskLogsInput(v *DescribeReplicationInstanceTaskLogsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeReplicationInstanceTaskLogsInput"}
	if v.ReplicationInstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationInstanceArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeReplicationsInput(v *DescribeReplicationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeReplicationsInput"}
	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 validateOpDescribeReplicationSubnetGroupsInput(v *DescribeReplicationSubnetGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeReplicationSubnetGroupsInput"}
	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 validateOpDescribeReplicationTableStatisticsInput(v *DescribeReplicationTableStatisticsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeReplicationTableStatisticsInput"}
	if v.ReplicationConfigArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationConfigArn"))
	}
	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 validateOpDescribeReplicationTaskAssessmentRunsInput(v *DescribeReplicationTaskAssessmentRunsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeReplicationTaskAssessmentRunsInput"}
	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 validateOpDescribeReplicationTaskIndividualAssessmentsInput(v *DescribeReplicationTaskIndividualAssessmentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeReplicationTaskIndividualAssessmentsInput"}
	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 validateOpDescribeReplicationTasksInput(v *DescribeReplicationTasksInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeReplicationTasksInput"}
	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 validateOpDescribeSchemasInput(v *DescribeSchemasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeSchemasInput"}
	if v.EndpointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeTableStatisticsInput(v *DescribeTableStatisticsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeTableStatisticsInput"}
	if v.ReplicationTaskArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationTaskArn"))
	}
	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 validateOpExportMetadataModelAssessmentInput(v *ExportMetadataModelAssessmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExportMetadataModelAssessmentInput"}
	if v.MigrationProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationProjectIdentifier"))
	}
	if v.SelectionRules == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SelectionRules"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpModifyConversionConfigurationInput(v *ModifyConversionConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyConversionConfigurationInput"}
	if v.MigrationProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationProjectIdentifier"))
	}
	if v.ConversionConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConversionConfiguration"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpModifyEndpointInput(v *ModifyEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyEndpointInput"}
	if v.EndpointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointArn"))
	}
	if v.DynamoDbSettings != nil {
		if err := validateDynamoDbSettings(v.DynamoDbSettings); err != nil {
			invalidParams.AddNested("DynamoDbSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.ElasticsearchSettings != nil {
		if err := validateElasticsearchSettings(v.ElasticsearchSettings); err != nil {
			invalidParams.AddNested("ElasticsearchSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.NeptuneSettings != nil {
		if err := validateNeptuneSettings(v.NeptuneSettings); err != nil {
			invalidParams.AddNested("NeptuneSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.RedisSettings != nil {
		if err := validateRedisSettings(v.RedisSettings); err != nil {
			invalidParams.AddNested("RedisSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.TimestreamSettings != nil {
		if err := validateTimestreamSettings(v.TimestreamSettings); err != nil {
			invalidParams.AddNested("TimestreamSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpModifyMigrationProjectInput(v *ModifyMigrationProjectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyMigrationProjectInput"}
	if v.MigrationProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationProjectIdentifier"))
	}
	if v.SourceDataProviderDescriptors != nil {
		if err := validateDataProviderDescriptorDefinitionList(v.SourceDataProviderDescriptors); err != nil {
			invalidParams.AddNested("SourceDataProviderDescriptors", err.(smithy.InvalidParamsError))
		}
	}
	if v.TargetDataProviderDescriptors != nil {
		if err := validateDataProviderDescriptorDefinitionList(v.TargetDataProviderDescriptors); err != nil {
			invalidParams.AddNested("TargetDataProviderDescriptors", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpModifyReplicationSubnetGroupInput(v *ModifyReplicationSubnetGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyReplicationSubnetGroupInput"}
	if v.ReplicationSubnetGroupIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationSubnetGroupIdentifier"))
	}
	if v.SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpMoveReplicationTaskInput(v *MoveReplicationTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MoveReplicationTaskInput"}
	if v.ReplicationTaskArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationTaskArn"))
	}
	if v.TargetReplicationInstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetReplicationInstanceArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpRefreshSchemasInput(v *RefreshSchemasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RefreshSchemasInput"}
	if v.EndpointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointArn"))
	}
	if v.ReplicationInstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationInstanceArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpReloadReplicationTablesInput(v *ReloadReplicationTablesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReloadReplicationTablesInput"}
	if v.ReplicationConfigArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationConfigArn"))
	}
	if v.TablesToReload == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TablesToReload"))
	} else if v.TablesToReload != nil {
		if err := validateTableListToReload(v.TablesToReload); err != nil {
			invalidParams.AddNested("TablesToReload", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpReloadTablesInput(v *ReloadTablesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReloadTablesInput"}
	if v.ReplicationTaskArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationTaskArn"))
	}
	if v.TablesToReload == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TablesToReload"))
	} else if v.TablesToReload != nil {
		if err := validateTableListToReload(v.TablesToReload); err != nil {
			invalidParams.AddNested("TablesToReload", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRemoveTagsFromResourceInput(v *RemoveTagsFromResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveTagsFromResourceInput"}
	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 validateOpStartDataMigrationInput(v *StartDataMigrationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartDataMigrationInput"}
	if v.DataMigrationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataMigrationIdentifier"))
	}
	if len(v.StartType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("StartType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpStartMetadataModelAssessmentInput(v *StartMetadataModelAssessmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartMetadataModelAssessmentInput"}
	if v.MigrationProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationProjectIdentifier"))
	}
	if v.SelectionRules == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SelectionRules"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartMetadataModelConversionInput(v *StartMetadataModelConversionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartMetadataModelConversionInput"}
	if v.MigrationProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationProjectIdentifier"))
	}
	if v.SelectionRules == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SelectionRules"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartMetadataModelExportAsScriptInput(v *StartMetadataModelExportAsScriptInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartMetadataModelExportAsScriptInput"}
	if v.MigrationProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationProjectIdentifier"))
	}
	if v.SelectionRules == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SelectionRules"))
	}
	if len(v.Origin) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Origin"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartMetadataModelExportToTargetInput(v *StartMetadataModelExportToTargetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartMetadataModelExportToTargetInput"}
	if v.MigrationProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationProjectIdentifier"))
	}
	if v.SelectionRules == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SelectionRules"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartMetadataModelImportInput(v *StartMetadataModelImportInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartMetadataModelImportInput"}
	if v.MigrationProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationProjectIdentifier"))
	}
	if v.SelectionRules == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SelectionRules"))
	}
	if len(v.Origin) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Origin"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartRecommendationsInput(v *StartRecommendationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartRecommendationsInput"}
	if v.DatabaseId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseId"))
	}
	if v.Settings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Settings"))
	} else if v.Settings != nil {
		if err := validateRecommendationSettings(v.Settings); err != nil {
			invalidParams.AddNested("Settings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartReplicationInput(v *StartReplicationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartReplicationInput"}
	if v.ReplicationConfigArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationConfigArn"))
	}
	if v.StartReplicationType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartReplicationType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpStartReplicationTaskAssessmentRunInput(v *StartReplicationTaskAssessmentRunInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartReplicationTaskAssessmentRunInput"}
	if v.ReplicationTaskArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationTaskArn"))
	}
	if v.ServiceAccessRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceAccessRoleArn"))
	}
	if v.ResultLocationBucket == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResultLocationBucket"))
	}
	if v.AssessmentRunName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentRunName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartReplicationTaskInput(v *StartReplicationTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartReplicationTaskInput"}
	if v.ReplicationTaskArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationTaskArn"))
	}
	if len(v.StartReplicationTaskType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("StartReplicationTaskType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpTestConnectionInput(v *TestConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestConnectionInput"}
	if v.ReplicationInstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationInstanceArn"))
	}
	if v.EndpointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}