service/rds/validators.go

// 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 validateOpCreateBlueGreenDeployment struct {
}

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

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

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

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

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

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

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

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

type validateOpDeleteBlueGreenDeployment struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type validateOpModifyDBShardGroup struct {
}

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

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

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

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

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

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

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

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

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

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

type validateOpSwitchoverGlobalCluster struct {
}

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

func (m *validateOpSwitchoverGlobalCluster) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SwitchoverGlobalClusterInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSwitchoverGlobalClusterInput(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 addOpCreateBlueGreenDeploymentValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateBlueGreenDeployment{}, 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 addOpCreateDBShardGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateDBShardGroup{}, 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 addOpCreateIntegrationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateIntegration{}, middleware.After)
}

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

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

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

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

func addOpDeleteDBClusterAutomatedBackupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteDBClusterAutomatedBackup{}, 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 addOpDeleteDBShardGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteDBShardGroup{}, 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 addOpDeleteIntegrationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteIntegration{}, middleware.After)
}

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

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

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

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

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

func addOpDescribeDBClusterAutomatedBackupsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeDBClusterAutomatedBackups{}, 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 addOpDescribeDBRecommendationsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeDBRecommendations{}, middleware.After)
}

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

func addOpDescribeDBShardGroupsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeDBShardGroups{}, 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 addOpDescribeDBSnapshotTenantDatabasesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeDBSnapshotTenantDatabases{}, 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 addOpDescribeIntegrationsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeIntegrations{}, 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 addOpDescribeTenantDatabasesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeTenantDatabases{}, middleware.After)
}

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

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

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

func addOpEnableHttpEndpointValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpEnableHttpEndpoint{}, 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 addOpModifyDBRecommendationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyDBRecommendation{}, middleware.After)
}

func addOpModifyDBShardGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyDBShardGroup{}, 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 addOpModifyIntegrationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyIntegration{}, middleware.After)
}

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

func addOpModifyTenantDatabaseValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpModifyTenantDatabase{}, 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 addOpRebootDBShardGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRebootDBShardGroup{}, 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 addOpSwitchoverBlueGreenDeploymentValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSwitchoverBlueGreenDeployment{}, middleware.After)
}

func addOpSwitchoverGlobalClusterValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSwitchoverGlobalCluster{}, 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 validateRecommendedActionUpdate(v *types.RecommendedActionUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RecommendedActionUpdate"}
	if v.ActionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActionId"))
	}
	if v.Status == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRecommendedActionUpdateList(v []types.RecommendedActionUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RecommendedActionUpdateList"}
	for i := range v {
		if err := validateRecommendedActionUpdate(&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 validateOpCreateBlueGreenDeploymentInput(v *CreateBlueGreenDeploymentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateBlueGreenDeploymentInput"}
	if v.BlueGreenDeploymentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BlueGreenDeploymentName"))
	}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	}
	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 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 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 validateOpCreateDBShardGroupInput(v *CreateDBShardGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDBShardGroupInput"}
	if v.DBShardGroupIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBShardGroupIdentifier"))
	}
	if v.DBClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBClusterIdentifier"))
	}
	if v.MaxACU == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxACU"))
	}
	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 validateOpCreateIntegrationInput(v *CreateIntegrationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateIntegrationInput"}
	if v.SourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceArn"))
	}
	if v.TargetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetArn"))
	}
	if v.IntegrationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationName"))
	}
	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 validateOpCreateTenantDatabaseInput(v *CreateTenantDatabaseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTenantDatabaseInput"}
	if v.DBInstanceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBInstanceIdentifier"))
	}
	if v.TenantDBName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TenantDBName"))
	}
	if v.MasterUsername == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MasterUsername"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteBlueGreenDeploymentInput(v *DeleteBlueGreenDeploymentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteBlueGreenDeploymentInput"}
	if v.BlueGreenDeploymentIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BlueGreenDeploymentIdentifier"))
	}
	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 validateOpDeleteDBClusterAutomatedBackupInput(v *DeleteDBClusterAutomatedBackupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDBClusterAutomatedBackupInput"}
	if v.DbClusterResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DbClusterResourceId"))
	}
	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 validateOpDeleteDBShardGroupInput(v *DeleteDBShardGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDBShardGroupInput"}
	if v.DBShardGroupIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBShardGroupIdentifier"))
	}
	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 validateOpDeleteIntegrationInput(v *DeleteIntegrationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIntegrationInput"}
	if v.IntegrationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationIdentifier"))
	}
	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 validateOpDeleteTenantDatabaseInput(v *DeleteTenantDatabaseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTenantDatabaseInput"}
	if v.DBInstanceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBInstanceIdentifier"))
	}
	if v.TenantDBName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TenantDBName"))
	}
	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 validateOpDescribeBlueGreenDeploymentsInput(v *DescribeBlueGreenDeploymentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeBlueGreenDeploymentsInput"}
	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 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 validateOpDescribeDBClusterAutomatedBackupsInput(v *DescribeDBClusterAutomatedBackupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBClusterAutomatedBackupsInput"}
	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 validateOpDescribeDBRecommendationsInput(v *DescribeDBRecommendationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBRecommendationsInput"}
	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 validateOpDescribeDBShardGroupsInput(v *DescribeDBShardGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBShardGroupsInput"}
	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 validateOpDescribeDBSnapshotTenantDatabasesInput(v *DescribeDBSnapshotTenantDatabasesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBSnapshotTenantDatabasesInput"}
	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 validateOpDescribeIntegrationsInput(v *DescribeIntegrationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeIntegrationsInput"}
	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 validateOpDescribeTenantDatabasesInput(v *DescribeTenantDatabasesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeTenantDatabasesInput"}
	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 validateOpDisableHttpEndpointInput(v *DisableHttpEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisableHttpEndpointInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	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 validateOpEnableHttpEndpointInput(v *EnableHttpEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableHttpEndpointInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	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 validateOpModifyDBRecommendationInput(v *ModifyDBRecommendationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyDBRecommendationInput"}
	if v.RecommendationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecommendationId"))
	}
	if v.RecommendedActionUpdates != nil {
		if err := validateRecommendedActionUpdateList(v.RecommendedActionUpdates); err != nil {
			invalidParams.AddNested("RecommendedActionUpdates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyDBShardGroupInput(v *ModifyDBShardGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyDBShardGroupInput"}
	if v.DBShardGroupIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBShardGroupIdentifier"))
	}
	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 validateOpModifyIntegrationInput(v *ModifyIntegrationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyIntegrationInput"}
	if v.IntegrationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationIdentifier"))
	}
	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 validateOpModifyTenantDatabaseInput(v *ModifyTenantDatabaseInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyTenantDatabaseInput"}
	if v.DBInstanceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBInstanceIdentifier"))
	}
	if v.TenantDBName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TenantDBName"))
	}
	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 validateOpRebootDBShardGroupInput(v *RebootDBShardGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RebootDBShardGroupInput"}
	if v.DBShardGroupIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DBShardGroupIdentifier"))
	}
	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.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 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 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 validateOpSwitchoverBlueGreenDeploymentInput(v *SwitchoverBlueGreenDeploymentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SwitchoverBlueGreenDeploymentInput"}
	if v.BlueGreenDeploymentIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BlueGreenDeploymentIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSwitchoverGlobalClusterInput(v *SwitchoverGlobalClusterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SwitchoverGlobalClusterInput"}
	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 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
	}
}