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


package rdb

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

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

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

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

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

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

type validateOpCreateDBSnapshot struct {
}

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

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

type 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 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 validateOpDeleteDBSecurityGroup struct {
}

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

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

type validateOpDeleteDBSnapshot struct {
}

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

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

type 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 validateOpDescribeDBLogFilesOperation struct {
}

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

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

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

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

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

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

type validateOpPrepareDBInstanceForUpgrade struct {
}

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

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

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

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

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

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

type validateOpStartReplication struct {
}

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

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

type validateOpStopReplication struct {
}

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

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

type validateOpUpgradeDBEngineVersion struct {
}

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

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

type validateOpUpgradeDBInstance struct {
}

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

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

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

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

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

func addOpCopyDBSnapshotValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCopyDBSnapshot{}, 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 addOpCreateDBSecurityGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateDBSecurityGroup{}, middleware.After)
}

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

func addOpCreateEventSubscriptionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateEventSubscription{}, 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 addOpDeleteDBSecurityGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteDBSecurityGroup{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateRequestParameters(v *types.RequestParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RequestParameters"}
	if len(v.ApplyMethod) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("ApplyMethod"))
	}
	if v.ParameterName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("ParameterName"))
	}
	if v.ParameterValue == nil {
	invalidParams.Add(smithy.NewErrParamRequired("ParameterValue"))
	}
	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.SourceIdentifier == nil {
	invalidParams.Add(smithy.NewErrParamRequired("SourceIdentifier"))
	}
	if v.SubscriptionName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("SubscriptionName"))
	}
	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 validateOpCancelDBInstanceForUpgradeInput(v *CancelDBInstanceForUpgradeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelDBInstanceForUpgradeInput"}
	if v.DBInstanceIdentifier == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DBInstanceIdentifier"))
	}
	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 validateOpCreateDBInstanceInput(v *CreateDBInstanceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDBInstanceInput"}
	if v.AllocatedStorage == nil {
	invalidParams.Add(smithy.NewErrParamRequired("AllocatedStorage"))
	}
	if len(v.DBInstanceClass) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("DBInstanceClass"))
	}
	if v.DBInstanceIdentifier == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DBInstanceIdentifier"))
	}
	if len(v.Engine) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("Engine"))
	}
	if v.MasterUsername == nil {
	invalidParams.Add(smithy.NewErrParamRequired("MasterUsername"))
	}
	if v.MasterUserPassword == nil {
	invalidParams.Add(smithy.NewErrParamRequired("MasterUserPassword"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateOpCreateDBParameterGroupInput(v *CreateDBParameterGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDBParameterGroupInput"}
	if v.DBParameterGroupFamily == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DBParameterGroupFamily"))
	}
	if v.DBParameterGroupName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DBParameterGroupName"))
	}
	if v.Description == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Description"))
	}
	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.DBSecurityGroupDescription == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DBSecurityGroupDescription"))
	}
	if v.DBSecurityGroupName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DBSecurityGroupName"))
	}
	if v.NiftyAvailabilityZone == nil {
	invalidParams.Add(smithy.NewErrParamRequired("NiftyAvailabilityZone"))
	}
	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.DBInstanceIdentifier == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DBInstanceIdentifier"))
	}
	if v.DBSnapshotIdentifier == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DBSnapshotIdentifier"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpCreateEventSubscriptionInput(v *CreateEventSubscriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateEventSubscriptionInput"}
	if v.NiftyEmailAddresses == nil {
	invalidParams.Add(smithy.NewErrParamRequired("NiftyEmailAddresses"))
	}
	if v.SubscriptionName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("SubscriptionName"))
	}
	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 validateOpDeleteDBSecurityGroupInput(v *DeleteDBSecurityGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDBSecurityGroupInput"}
	if v.DBSecurityGroupName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DBSecurityGroupName"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func 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 validateOpDescribeDBLogFilesOperationInput(v *DescribeDBLogFilesOperationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDBLogFilesOperationInput"}
	if v.DBInstanceIdentifier == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DBInstanceIdentifier"))
	}
	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 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 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 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 validateOpModifyDBInstanceNetworkInput(v *ModifyDBInstanceNetworkInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyDBInstanceNetworkInput"}
	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"))
	} else if v.Parameters != nil {
		if err := validateListOfRequestParameters(v.Parameters); err != nil {
			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateOpNiftyGetMetricStatisticsInput(v *NiftyGetMetricStatisticsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyGetMetricStatisticsInput"}
	if v.Dimensions == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Dimensions"))
	} else if v.Dimensions != nil {
		if err := validateListOfRequestDimensions(v.Dimensions); err != nil {
			invalidParams.AddNested("Dimensions", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.MetricName) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpPrepareDBInstanceForUpgradeInput(v *PrepareDBInstanceForUpgradeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PrepareDBInstanceForUpgradeInput"}
	if v.DBInstanceIdentifier == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DBInstanceIdentifier"))
	}
	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 validateOpRemoveSourceIdentifierFromSubscriptionInput(v *RemoveSourceIdentifierFromSubscriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveSourceIdentifierFromSubscriptionInput"}
	if v.SourceIdentifier == nil {
	invalidParams.Add(smithy.NewErrParamRequired("SourceIdentifier"))
	}
	if v.SubscriptionName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("SubscriptionName"))
	}
	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 validateOpResetExternalMasterInput(v *ResetExternalMasterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResetExternalMasterInput"}
	if v.DBInstanceIdentifier == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DBInstanceIdentifier"))
	}
	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 len(v.DBInstanceClass) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("DBInstanceClass"))
	}
	if v.DBInstanceIdentifier == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DBInstanceIdentifier"))
	}
	if v.DBSnapshotIdentifier == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DBSnapshotIdentifier"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpRestoreDBInstanceToPointInTimeInput(v *RestoreDBInstanceToPointInTimeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RestoreDBInstanceToPointInTimeInput"}
	if v.SourceDBInstanceIdentifier == nil {
	invalidParams.Add(smithy.NewErrParamRequired("SourceDBInstanceIdentifier"))
	}
	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 validateOpSetExternalMasterInput(v *SetExternalMasterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetExternalMasterInput"}
	if v.BinlogFileName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("BinlogFileName"))
	}
	if v.BinlogPosition == nil {
	invalidParams.Add(smithy.NewErrParamRequired("BinlogPosition"))
	}
	if v.DBInstanceIdentifier == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DBInstanceIdentifier"))
	}
	if v.MasterHost == nil {
	invalidParams.Add(smithy.NewErrParamRequired("MasterHost"))
	}
	if v.ReplicationUserName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("ReplicationUserName"))
	}
	if v.ReplicationUserPassword == nil {
	invalidParams.Add(smithy.NewErrParamRequired("ReplicationUserPassword"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

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

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