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

package docdb

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

type validateOpAddSourceIdentifierToSubscription struct {
}

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

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

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 validateOpCopyDBClusterParameterGroup struct {
}

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

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

type validateOpCopyDBClusterSnapshot struct {
}

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

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

type validateOpCreateDBCluster struct {
}

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

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

type validateOpCreateDBClusterParameterGroup struct {
}

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

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

type validateOpCreateDBClusterSnapshot struct {
}

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

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

type validateOpCreateDBInstance struct {
}

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

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

type validateOpCreateDBSubnetGroup struct {
}

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

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

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

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

type validateOpDeleteDBCluster struct {
}

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

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

type validateOpDeleteDBClusterParameterGroup struct {
}

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

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

type validateOpDeleteDBClusterSnapshot struct {
}

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

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

type validateOpDeleteDBInstance struct {
}

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

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

type validateOpDeleteDBSubnetGroup struct {
}

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

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

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

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

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

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

type validateOpDescribeDBClusterParameters struct {
}

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

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

type validateOpDescribeDBClusters struct {
}

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

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

type validateOpDescribeDBClusterSnapshotAttributes struct {
}

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

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

type validateOpDescribeDBClusterSnapshots struct {
}

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

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

type validateOpDescribeDBEngineVersions struct {
}

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

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

type validateOpDescribeDBInstances struct {
}

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

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

type validateOpDescribeDBSubnetGroups struct {
}

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

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

type validateOpDescribeEngineDefaultClusterParameters struct {
}

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

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

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

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

type validateOpDescribeOrderableDBInstanceOptions struct {
}

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

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

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

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

type validateOpModifyDBCluster struct {
}

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

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

type validateOpModifyDBClusterParameterGroup struct {
}

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

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

type validateOpModifyDBClusterSnapshotAttribute struct {
}

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

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

type validateOpModifyDBInstance struct {
}

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

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

type validateOpModifyDBSubnetGroup struct {
}

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

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

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

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

type validateOpRebootDBInstance struct {
}

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

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

type validateOpRemoveFromGlobalCluster struct {
}

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

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

type validateOpRemoveSourceIdentifierFromSubscription struct {
}

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

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

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

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

type validateOpRestoreDBClusterFromSnapshot struct {
}

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

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

type validateOpRestoreDBClusterToPointInTime struct {
}

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

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

type validateOpStartDBCluster struct {
}

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

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

type validateOpStopDBCluster struct {
}

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

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

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

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 addOpCopyDBClusterParameterGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCopyDBClusterParameterGroup{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpDescribeEngineDefaultClusterParametersValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeEngineDefaultClusterParameters{}, 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 addOpDescribeGlobalClustersValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeGlobalClusters{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 validateOpAddSourceIdentifierToSubscriptionInput(v *AddSourceIdentifierToSubscriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddSourceIdentifierToSubscriptionInput"}
	if v.SubscriptionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubscriptionName"))
	}
	if v.SourceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceIdentifier"))
	}
	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.ResourceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
	}
	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.ResourceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
	}
	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 validateOpCopyDBClusterParameterGroupInput(v *CopyDBClusterParameterGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CopyDBClusterParameterGroupInput"}
	if v.SourceDBClusterParameterGroupIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceDBClusterParameterGroupIdentifier"))
	}
	if v.TargetDBClusterParameterGroupIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetDBClusterParameterGroupIdentifier"))
	}
	if v.TargetDBClusterParameterGroupDescription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetDBClusterParameterGroupDescription"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCopyDBClusterSnapshotInput(v *CopyDBClusterSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CopyDBClusterSnapshotInput"}
	if v.SourceDBClusterSnapshotIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceDBClusterSnapshotIdentifier"))
	}
	if v.TargetDBClusterSnapshotIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetDBClusterSnapshotIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDBClusterInput(v *CreateDBClusterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDBClusterInput"}
	if v.DBClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBClusterIdentifier"))
	}
	if v.Engine == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Engine"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDBClusterParameterGroupInput(v *CreateDBClusterParameterGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDBClusterParameterGroupInput"}
	if v.DBClusterParameterGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBClusterParameterGroupName"))
	}
	if v.DBParameterGroupFamily == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBParameterGroupFamily"))
	}
	if v.Description == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Description"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDBClusterSnapshotInput(v *CreateDBClusterSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDBClusterSnapshotInput"}
	if v.DBClusterSnapshotIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBClusterSnapshotIdentifier"))
	}
	if v.DBClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBClusterIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDBInstanceInput(v *CreateDBInstanceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDBInstanceInput"}
	if v.DBInstanceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBInstanceIdentifier"))
	}
	if v.DBInstanceClass == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBInstanceClass"))
	}
	if v.Engine == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Engine"))
	}
	if v.DBClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBClusterIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDBSubnetGroupInput(v *CreateDBSubnetGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDBSubnetGroupInput"}
	if v.DBSubnetGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBSubnetGroupName"))
	}
	if v.DBSubnetGroupDescription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBSubnetGroupDescription"))
	}
	if v.SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
	}
	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 validateOpCreateGlobalClusterInput(v *CreateGlobalClusterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateGlobalClusterInput"}
	if v.GlobalClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GlobalClusterIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpDeleteDBSubnetGroupInput(v *DeleteDBSubnetGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDBSubnetGroupInput"}
	if v.DBSubnetGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBSubnetGroupName"))
	}
	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 validateOpDeleteGlobalClusterInput(v *DeleteGlobalClusterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteGlobalClusterInput"}
	if v.GlobalClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GlobalClusterIdentifier"))
	}
	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 validateOpDescribeDBClusterParameterGroupsInput(v *DescribeDBClusterParameterGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBClusterParameterGroupsInput"}
	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 validateOpDescribeDBClusterParametersInput(v *DescribeDBClusterParametersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBClusterParametersInput"}
	if v.DBClusterParameterGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBClusterParameterGroupName"))
	}
	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 validateOpDescribeDBClustersInput(v *DescribeDBClustersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBClustersInput"}
	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 validateOpDescribeDBClusterSnapshotAttributesInput(v *DescribeDBClusterSnapshotAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBClusterSnapshotAttributesInput"}
	if v.DBClusterSnapshotIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBClusterSnapshotIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeDBClusterSnapshotsInput(v *DescribeDBClusterSnapshotsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBClusterSnapshotsInput"}
	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 validateOpDescribeDBEngineVersionsInput(v *DescribeDBEngineVersionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBEngineVersionsInput"}
	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 validateOpDescribeDBInstancesInput(v *DescribeDBInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBInstancesInput"}
	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 validateOpDescribeDBSubnetGroupsInput(v *DescribeDBSubnetGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBSubnetGroupsInput"}
	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 validateOpDescribeEngineDefaultClusterParametersInput(v *DescribeEngineDefaultClusterParametersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeEngineDefaultClusterParametersInput"}
	if v.DBParameterGroupFamily == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBParameterGroupFamily"))
	}
	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 validateOpDescribeGlobalClustersInput(v *DescribeGlobalClustersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeGlobalClustersInput"}
	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 validateOpDescribeOrderableDBInstanceOptionsInput(v *DescribeOrderableDBInstanceOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeOrderableDBInstanceOptionsInput"}
	if v.Engine == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Engine"))
	}
	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 validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
	if v.ResourceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
	}
	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 validateOpModifyDBClusterInput(v *ModifyDBClusterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyDBClusterInput"}
	if v.DBClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBClusterIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyDBClusterParameterGroupInput(v *ModifyDBClusterParameterGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyDBClusterParameterGroupInput"}
	if v.DBClusterParameterGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBClusterParameterGroupName"))
	}
	if v.Parameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Parameters"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyDBClusterSnapshotAttributeInput(v *ModifyDBClusterSnapshotAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyDBClusterSnapshotAttributeInput"}
	if v.DBClusterSnapshotIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBClusterSnapshotIdentifier"))
	}
	if v.AttributeName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpModifyDBSubnetGroupInput(v *ModifyDBSubnetGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyDBSubnetGroupInput"}
	if v.DBSubnetGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBSubnetGroupName"))
	}
	if v.SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
	}
	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 validateOpModifyGlobalClusterInput(v *ModifyGlobalClusterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyGlobalClusterInput"}
	if v.GlobalClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GlobalClusterIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpRemoveFromGlobalClusterInput(v *RemoveFromGlobalClusterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveFromGlobalClusterInput"}
	if v.GlobalClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GlobalClusterIdentifier"))
	}
	if v.DbClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DbClusterIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRemoveSourceIdentifierFromSubscriptionInput(v *RemoveSourceIdentifierFromSubscriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveSourceIdentifierFromSubscriptionInput"}
	if v.SubscriptionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubscriptionName"))
	}
	if v.SourceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceIdentifier"))
	}
	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.ResourceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceName"))
	}
	if v.TagKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpRestoreDBClusterFromSnapshotInput(v *RestoreDBClusterFromSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RestoreDBClusterFromSnapshotInput"}
	if v.DBClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBClusterIdentifier"))
	}
	if v.SnapshotIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier"))
	}
	if v.Engine == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Engine"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRestoreDBClusterToPointInTimeInput(v *RestoreDBClusterToPointInTimeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RestoreDBClusterToPointInTimeInput"}
	if v.DBClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBClusterIdentifier"))
	}
	if v.SourceDBClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceDBClusterIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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