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

package rds

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

type validateOpAddRoleToDBCluster struct {
}

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

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

type validateOpAddRoleToDBInstance struct {
}

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

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

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

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

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

type validateOpBacktrackDBCluster struct {
}

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

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

type validateOpCancelExportTask struct {
}

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

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

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

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

type validateOpCopyDBSnapshot struct {
}

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

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

type validateOpCopyOptionGroup struct {
}

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

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

type validateOpCreateCustomDBEngineVersion struct {
}

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

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

type validateOpCreateDBClusterEndpoint struct {
}

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

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

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

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

type validateOpCreateDBParameterGroup struct {
}

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

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

type validateOpCreateDBProxyEndpoint struct {
}

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

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

type validateOpCreateDBProxy struct {
}

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

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

type validateOpCreateDBSecurityGroup struct {
}

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

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

type validateOpCreateDBSnapshot struct {
}

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

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

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

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

type validateOpDeleteCustomDBEngineVersion struct {
}

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

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

type validateOpDeleteDBClusterEndpoint struct {
}

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

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

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

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

type validateOpDeleteDBProxyEndpoint struct {
}

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

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

type validateOpDeleteDBProxy struct {
}

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

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

type validateOpDeleteDBSecurityGroup struct {
}

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

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

type validateOpDeleteDBSnapshot struct {
}

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

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

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

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

type validateOpDeregisterDBProxyTargets struct {
}

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

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

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

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

type validateOpDescribeDBClusterEndpoints struct {
}

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

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

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

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

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

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

type validateOpDescribeDBParameterGroups struct {
}

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

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

type validateOpDescribeDBParameters struct {
}

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

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

type validateOpDescribeDBProxies struct {
}

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

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

type validateOpDescribeDBProxyEndpoints struct {
}

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

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

type validateOpDescribeDBProxyTargetGroups struct {
}

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

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

type validateOpDescribeDBProxyTargets struct {
}

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

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

type validateOpDescribeDBSecurityGroups struct {
}

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

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

type validateOpDescribeDBSnapshotAttributes struct {
}

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

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

type validateOpDescribeDBSnapshots struct {
}

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

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

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

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

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

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

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

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

type validateOpDescribeOptionGroups struct {
}

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

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

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

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

type validateOpDescribeReservedDBInstancesOfferings struct {
}

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

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

type validateOpDescribeSourceRegions struct {
}

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

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

type validateOpDescribeValidDBInstanceModifications struct {
}

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

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

type validateOpDownloadDBLogFilePortion struct {
}

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

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

type validateOpFailoverDBCluster struct {
}

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

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

type validateOpFailoverGlobalCluster struct {
}

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

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

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

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

type validateOpModifyCustomDBEngineVersion struct {
}

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

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

type validateOpModifyDBClusterEndpoint struct {
}

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

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

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

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

type validateOpModifyDBProxyEndpoint struct {
}

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

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

type validateOpModifyDBProxy struct {
}

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

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

type validateOpModifyDBProxyTargetGroup struct {
}

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

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

type validateOpModifyDBSnapshotAttribute struct {
}

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

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

type validateOpModifyDBSnapshot struct {
}

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

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

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

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

type validateOpPromoteReadReplicaDBCluster struct {
}

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

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

type validateOpPromoteReadReplica struct {
}

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

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

type validateOpPurchaseReservedDBInstancesOffering struct {
}

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

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

type validateOpRebootDBCluster struct {
}

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

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

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

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

type validateOpRemoveRoleFromDBCluster struct {
}

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

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

type validateOpRemoveRoleFromDBInstance struct {
}

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

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

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

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

type validateOpRestoreDBClusterFromS3 struct {
}

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

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

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

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

type validateOpRestoreDBInstanceFromS3 struct {
}

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

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

type validateOpRestoreDBInstanceToPointInTime struct {
}

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

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

type validateOpRevokeDBSecurityGroupIngress struct {
}

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

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

type validateOpStartActivityStream struct {
}

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

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

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

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

type validateOpStartDBInstance struct {
}

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

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

type validateOpStartExportTask struct {
}

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

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

type validateOpStopActivityStream struct {
}

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

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

type validateOpStopDBInstanceAutomatedBackupsReplication struct {
}

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

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

type validateOpStopDBInstance struct {
}

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

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

type validateOpSwitchoverReadReplica struct {
}

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

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

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

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

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

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

func addOpCancelExportTaskValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCancelExportTask{}, 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 addOpCopyDBParameterGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCopyDBParameterGroup{}, middleware.After)
}

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

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

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

func addOpCreateDBClusterEndpointValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateDBClusterEndpoint{}, 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 addOpCreateDBInstanceReadReplicaValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateDBInstanceReadReplica{}, middleware.After)
}

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

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

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

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

func addOpCreateDBSnapshotValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateDBSnapshot{}, 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 addOpCreateOptionGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateOptionGroup{}, middleware.After)
}

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

func addOpDeleteDBClusterEndpointValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteDBClusterEndpoint{}, 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 addOpDeleteDBParameterGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteDBParameterGroup{}, middleware.After)
}

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

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

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

func addOpDeleteDBSnapshotValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteDBSnapshot{}, 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 addOpDeleteOptionGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteOptionGroup{}, middleware.After)
}

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

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

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

func addOpDescribeDBClusterEndpointsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeDBClusterEndpoints{}, 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 addOpDescribeDBInstanceAutomatedBackupsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeDBInstanceAutomatedBackups{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

func addOpDescribeDBSnapshotsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeDBSnapshots{}, 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 addOpDescribeEngineDefaultParametersValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeEngineDefaultParameters{}, 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 addOpDescribeExportTasksValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeExportTasks{}, middleware.After)
}

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

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

func addOpDescribeOptionGroupsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeOptionGroups{}, 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 addOpDescribeReservedDBInstancesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeReservedDBInstances{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

func addOpModifyDBClusterEndpointValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyDBClusterEndpoint{}, 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 addOpModifyDBParameterGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyDBParameterGroup{}, middleware.After)
}

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

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

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

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

func addOpModifyDBSnapshotValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyDBSnapshot{}, 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 addOpModifyOptionGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyOptionGroup{}, middleware.After)
}

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

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

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

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

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

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

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

func addOpRemoveRoleFromDBInstanceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRemoveRoleFromDBInstance{}, 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 addOpResetDBParameterGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpResetDBParameterGroup{}, middleware.After)
}

func addOpRestoreDBClusterFromS3ValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRestoreDBClusterFromS3{}, 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 addOpRestoreDBInstanceFromDBSnapshotValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRestoreDBInstanceFromDBSnapshot{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

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

func addOpSwitchoverReadReplicaValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSwitchoverReadReplica{}, 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 validateOptionConfiguration(v *types.OptionConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OptionConfiguration"}
	if v.OptionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OptionName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpAddRoleToDBInstanceInput(v *AddRoleToDBInstanceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddRoleToDBInstanceInput"}
	if v.DBInstanceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBInstanceIdentifier"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.FeatureName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FeatureName"))
	}
	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 validateOpAuthorizeDBSecurityGroupIngressInput(v *AuthorizeDBSecurityGroupIngressInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AuthorizeDBSecurityGroupIngressInput"}
	if v.DBSecurityGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBSecurityGroupName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCancelExportTaskInput(v *CancelExportTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelExportTaskInput"}
	if v.ExportTaskIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExportTaskIdentifier"))
	}
	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 validateOpCopyDBParameterGroupInput(v *CopyDBParameterGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CopyDBParameterGroupInput"}
	if v.SourceDBParameterGroupIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceDBParameterGroupIdentifier"))
	}
	if v.TargetDBParameterGroupIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetDBParameterGroupIdentifier"))
	}
	if v.TargetDBParameterGroupDescription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetDBParameterGroupDescription"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCopyDBSnapshotInput(v *CopyDBSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CopyDBSnapshotInput"}
	if v.SourceDBSnapshotIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceDBSnapshotIdentifier"))
	}
	if v.TargetDBSnapshotIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetDBSnapshotIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCopyOptionGroupInput(v *CopyOptionGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CopyOptionGroupInput"}
	if v.SourceOptionGroupIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceOptionGroupIdentifier"))
	}
	if v.TargetOptionGroupIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetOptionGroupIdentifier"))
	}
	if v.TargetOptionGroupDescription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetOptionGroupDescription"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCustomDBEngineVersionInput(v *CreateCustomDBEngineVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCustomDBEngineVersionInput"}
	if v.Engine == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Engine"))
	}
	if v.EngineVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EngineVersion"))
	}
	if v.DatabaseInstallationFilesS3BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseInstallationFilesS3BucketName"))
	}
	if v.KMSKeyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KMSKeyId"))
	}
	if v.Manifest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Manifest"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpCreateDBParameterGroupInput(v *CreateDBParameterGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDBParameterGroupInput"}
	if v.DBParameterGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBParameterGroupName"))
	}
	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 validateOpCreateDBProxyEndpointInput(v *CreateDBProxyEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDBProxyEndpointInput"}
	if v.DBProxyName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBProxyName"))
	}
	if v.DBProxyEndpointName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBProxyEndpointName"))
	}
	if v.VpcSubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcSubnetIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDBProxyInput(v *CreateDBProxyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDBProxyInput"}
	if v.DBProxyName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBProxyName"))
	}
	if len(v.EngineFamily) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EngineFamily"))
	}
	if v.Auth == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Auth"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.VpcSubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcSubnetIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDBSecurityGroupInput(v *CreateDBSecurityGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDBSecurityGroupInput"}
	if v.DBSecurityGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBSecurityGroupName"))
	}
	if v.DBSecurityGroupDescription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBSecurityGroupDescription"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDBSnapshotInput(v *CreateDBSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDBSnapshotInput"}
	if v.DBSnapshotIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBSnapshotIdentifier"))
	}
	if v.DBInstanceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBInstanceIdentifier"))
	}
	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 validateOpCreateOptionGroupInput(v *CreateOptionGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateOptionGroupInput"}
	if v.OptionGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OptionGroupName"))
	}
	if v.EngineName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EngineName"))
	}
	if v.MajorEngineVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MajorEngineVersion"))
	}
	if v.OptionGroupDescription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OptionGroupDescription"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteDBClusterEndpointInput(v *DeleteDBClusterEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDBClusterEndpointInput"}
	if v.DBClusterEndpointIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBClusterEndpointIdentifier"))
	}
	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 validateOpDeleteDBParameterGroupInput(v *DeleteDBParameterGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDBParameterGroupInput"}
	if v.DBParameterGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBParameterGroupName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpDeleteDBSnapshotInput(v *DeleteDBSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDBSnapshotInput"}
	if v.DBSnapshotIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBSnapshotIdentifier"))
	}
	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 validateOpDeleteOptionGroupInput(v *DeleteOptionGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteOptionGroupInput"}
	if v.OptionGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OptionGroupName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeregisterDBProxyTargetsInput(v *DeregisterDBProxyTargetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeregisterDBProxyTargetsInput"}
	if v.DBProxyName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBProxyName"))
	}
	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 validateOpDescribeDBClusterBacktracksInput(v *DescribeDBClusterBacktracksInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBClusterBacktracksInput"}
	if v.DBClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBClusterIdentifier"))
	}
	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 validateOpDescribeDBClusterEndpointsInput(v *DescribeDBClusterEndpointsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBClusterEndpointsInput"}
	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 validateOpDescribeDBInstanceAutomatedBackupsInput(v *DescribeDBInstanceAutomatedBackupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBInstanceAutomatedBackupsInput"}
	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 validateOpDescribeDBLogFilesInput(v *DescribeDBLogFilesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBLogFilesInput"}
	if v.DBInstanceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBInstanceIdentifier"))
	}
	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 validateOpDescribeDBParameterGroupsInput(v *DescribeDBParameterGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBParameterGroupsInput"}
	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 validateOpDescribeDBParametersInput(v *DescribeDBParametersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBParametersInput"}
	if v.DBParameterGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBParameterGroupName"))
	}
	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 validateOpDescribeDBProxiesInput(v *DescribeDBProxiesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBProxiesInput"}
	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 validateOpDescribeDBProxyEndpointsInput(v *DescribeDBProxyEndpointsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBProxyEndpointsInput"}
	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 validateOpDescribeDBProxyTargetGroupsInput(v *DescribeDBProxyTargetGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBProxyTargetGroupsInput"}
	if v.DBProxyName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBProxyName"))
	}
	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 validateOpDescribeDBProxyTargetsInput(v *DescribeDBProxyTargetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBProxyTargetsInput"}
	if v.DBProxyName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBProxyName"))
	}
	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 validateOpDescribeDBSecurityGroupsInput(v *DescribeDBSecurityGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBSecurityGroupsInput"}
	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 validateOpDescribeDBSnapshotAttributesInput(v *DescribeDBSnapshotAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBSnapshotAttributesInput"}
	if v.DBSnapshotIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBSnapshotIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeDBSnapshotsInput(v *DescribeDBSnapshotsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBSnapshotsInput"}
	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 validateOpDescribeEngineDefaultParametersInput(v *DescribeEngineDefaultParametersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeEngineDefaultParametersInput"}
	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 validateOpDescribeExportTasksInput(v *DescribeExportTasksInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeExportTasksInput"}
	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 validateOpDescribeOptionGroupOptionsInput(v *DescribeOptionGroupOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeOptionGroupOptionsInput"}
	if v.EngineName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EngineName"))
	}
	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 validateOpDescribeOptionGroupsInput(v *DescribeOptionGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeOptionGroupsInput"}
	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 validateOpDescribeReservedDBInstancesInput(v *DescribeReservedDBInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeReservedDBInstancesInput"}
	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 validateOpDescribeReservedDBInstancesOfferingsInput(v *DescribeReservedDBInstancesOfferingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeReservedDBInstancesOfferingsInput"}
	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 validateOpDescribeSourceRegionsInput(v *DescribeSourceRegionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeSourceRegionsInput"}
	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 validateOpDescribeValidDBInstanceModificationsInput(v *DescribeValidDBInstanceModificationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeValidDBInstanceModificationsInput"}
	if v.DBInstanceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBInstanceIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpFailoverGlobalClusterInput(v *FailoverGlobalClusterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FailoverGlobalClusterInput"}
	if v.GlobalClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GlobalClusterIdentifier"))
	}
	if v.TargetDbClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetDbClusterIdentifier"))
	}
	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 validateOpModifyCurrentDBClusterCapacityInput(v *ModifyCurrentDBClusterCapacityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyCurrentDBClusterCapacityInput"}
	if v.DBClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBClusterIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpModifyDBClusterEndpointInput(v *ModifyDBClusterEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyDBClusterEndpointInput"}
	if v.DBClusterEndpointIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBClusterEndpointIdentifier"))
	}
	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 validateOpModifyDBParameterGroupInput(v *ModifyDBParameterGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyDBParameterGroupInput"}
	if v.DBParameterGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBParameterGroupName"))
	}
	if v.Parameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Parameters"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpModifyDBProxyTargetGroupInput(v *ModifyDBProxyTargetGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyDBProxyTargetGroupInput"}
	if v.TargetGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetGroupName"))
	}
	if v.DBProxyName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBProxyName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpModifyDBSnapshotInput(v *ModifyDBSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyDBSnapshotInput"}
	if v.DBSnapshotIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBSnapshotIdentifier"))
	}
	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 validateOpModifyOptionGroupInput(v *ModifyOptionGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyOptionGroupInput"}
	if v.OptionGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OptionGroupName"))
	}
	if v.OptionsToInclude != nil {
		if err := validateOptionConfigurationList(v.OptionsToInclude); err != nil {
			invalidParams.AddNested("OptionsToInclude", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpRebootDBClusterInput(v *RebootDBClusterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RebootDBClusterInput"}
	if v.DBClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBClusterIdentifier"))
	}
	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 validateOpRegisterDBProxyTargetsInput(v *RegisterDBProxyTargetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterDBProxyTargetsInput"}
	if v.DBProxyName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBProxyName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpRemoveRoleFromDBInstanceInput(v *RemoveRoleFromDBInstanceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveRoleFromDBInstanceInput"}
	if v.DBInstanceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBInstanceIdentifier"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.FeatureName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FeatureName"))
	}
	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 validateOpResetDBParameterGroupInput(v *ResetDBParameterGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResetDBParameterGroupInput"}
	if v.DBParameterGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBParameterGroupName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRestoreDBClusterFromS3Input(v *RestoreDBClusterFromS3Input) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RestoreDBClusterFromS3Input"}
	if v.DBClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBClusterIdentifier"))
	}
	if v.Engine == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Engine"))
	}
	if v.MasterUsername == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MasterUsername"))
	}
	if v.MasterUserPassword == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MasterUserPassword"))
	}
	if v.SourceEngine == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceEngine"))
	}
	if v.SourceEngineVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceEngineVersion"))
	}
	if v.S3BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3BucketName"))
	}
	if v.S3IngestionRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3IngestionRoleArn"))
	}
	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 validateOpRestoreDBInstanceFromDBSnapshotInput(v *RestoreDBInstanceFromDBSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RestoreDBInstanceFromDBSnapshotInput"}
	if v.DBInstanceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBInstanceIdentifier"))
	}
	if v.DBSnapshotIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBSnapshotIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRestoreDBInstanceFromS3Input(v *RestoreDBInstanceFromS3Input) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RestoreDBInstanceFromS3Input"}
	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.SourceEngine == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceEngine"))
	}
	if v.SourceEngineVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceEngineVersion"))
	}
	if v.S3BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3BucketName"))
	}
	if v.S3IngestionRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3IngestionRoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpStartActivityStreamInput(v *StartActivityStreamInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartActivityStreamInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if len(v.Mode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Mode"))
	}
	if v.KmsKeyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KmsKeyId"))
	}
	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 validateOpStartDBInstanceAutomatedBackupsReplicationInput(v *StartDBInstanceAutomatedBackupsReplicationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartDBInstanceAutomatedBackupsReplicationInput"}
	if v.SourceDBInstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceDBInstanceArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpStartExportTaskInput(v *StartExportTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartExportTaskInput"}
	if v.ExportTaskIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExportTaskIdentifier"))
	}
	if v.SourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceArn"))
	}
	if v.S3BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3BucketName"))
	}
	if v.IamRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IamRoleArn"))
	}
	if v.KmsKeyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KmsKeyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopActivityStreamInput(v *StopActivityStreamInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopActivityStreamInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	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
	}
}

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

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

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