driftctl/test/aws/mock_FakeRDS.go

// Code generated by mockery v1.0.0. DO NOT EDIT.

package aws

import (
	"context"

	"github.com/aws/aws-sdk-go/service/rds"
	"github.com/stretchr/testify/mock"

	"github.com/aws/aws-sdk-go/aws/request"
)

// MockFakeRDS is an autogenerated mock type for the FakeRDS type
type MockFakeRDS struct {
	mock.Mock
}

// AddRoleToDBCluster provides a mock function with given fields: _a0
func (_m *MockFakeRDS) AddRoleToDBCluster(_a0 *rds.AddRoleToDBClusterInput) (*rds.AddRoleToDBClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.AddRoleToDBClusterOutput
	if rf, ok := ret.Get(0).(func(*rds.AddRoleToDBClusterInput) *rds.AddRoleToDBClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.AddRoleToDBClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.AddRoleToDBClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddRoleToDBClusterRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) AddRoleToDBClusterRequest(_a0 *rds.AddRoleToDBClusterInput) (*request.Request, *rds.AddRoleToDBClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.AddRoleToDBClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.AddRoleToDBClusterOutput
	if rf, ok := ret.Get(1).(func(*rds.AddRoleToDBClusterInput) *rds.AddRoleToDBClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.AddRoleToDBClusterOutput)
		}
	}

	return r0, r1
}

// AddRoleToDBClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) AddRoleToDBClusterWithContext(_a0 context.Context, _a1 *rds.AddRoleToDBClusterInput, _a2 ...request.Option) (*rds.AddRoleToDBClusterOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.AddRoleToDBClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.AddRoleToDBClusterInput, ...request.Option) *rds.AddRoleToDBClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.AddRoleToDBClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.AddRoleToDBClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddRoleToDBInstance provides a mock function with given fields: _a0
func (_m *MockFakeRDS) AddRoleToDBInstance(_a0 *rds.AddRoleToDBInstanceInput) (*rds.AddRoleToDBInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.AddRoleToDBInstanceOutput
	if rf, ok := ret.Get(0).(func(*rds.AddRoleToDBInstanceInput) *rds.AddRoleToDBInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.AddRoleToDBInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.AddRoleToDBInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddRoleToDBInstanceRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) AddRoleToDBInstanceRequest(_a0 *rds.AddRoleToDBInstanceInput) (*request.Request, *rds.AddRoleToDBInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.AddRoleToDBInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.AddRoleToDBInstanceOutput
	if rf, ok := ret.Get(1).(func(*rds.AddRoleToDBInstanceInput) *rds.AddRoleToDBInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.AddRoleToDBInstanceOutput)
		}
	}

	return r0, r1
}

// AddRoleToDBInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) AddRoleToDBInstanceWithContext(_a0 context.Context, _a1 *rds.AddRoleToDBInstanceInput, _a2 ...request.Option) (*rds.AddRoleToDBInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.AddRoleToDBInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.AddRoleToDBInstanceInput, ...request.Option) *rds.AddRoleToDBInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.AddRoleToDBInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.AddRoleToDBInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddSourceIdentifierToSubscription provides a mock function with given fields: _a0
func (_m *MockFakeRDS) AddSourceIdentifierToSubscription(_a0 *rds.AddSourceIdentifierToSubscriptionInput) (*rds.AddSourceIdentifierToSubscriptionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.AddSourceIdentifierToSubscriptionOutput
	if rf, ok := ret.Get(0).(func(*rds.AddSourceIdentifierToSubscriptionInput) *rds.AddSourceIdentifierToSubscriptionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.AddSourceIdentifierToSubscriptionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.AddSourceIdentifierToSubscriptionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddSourceIdentifierToSubscriptionRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) AddSourceIdentifierToSubscriptionRequest(_a0 *rds.AddSourceIdentifierToSubscriptionInput) (*request.Request, *rds.AddSourceIdentifierToSubscriptionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.AddSourceIdentifierToSubscriptionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.AddSourceIdentifierToSubscriptionOutput
	if rf, ok := ret.Get(1).(func(*rds.AddSourceIdentifierToSubscriptionInput) *rds.AddSourceIdentifierToSubscriptionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.AddSourceIdentifierToSubscriptionOutput)
		}
	}

	return r0, r1
}

// AddSourceIdentifierToSubscriptionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) AddSourceIdentifierToSubscriptionWithContext(_a0 context.Context, _a1 *rds.AddSourceIdentifierToSubscriptionInput, _a2 ...request.Option) (*rds.AddSourceIdentifierToSubscriptionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.AddSourceIdentifierToSubscriptionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.AddSourceIdentifierToSubscriptionInput, ...request.Option) *rds.AddSourceIdentifierToSubscriptionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.AddSourceIdentifierToSubscriptionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.AddSourceIdentifierToSubscriptionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddTagsToResource provides a mock function with given fields: _a0
func (_m *MockFakeRDS) AddTagsToResource(_a0 *rds.AddTagsToResourceInput) (*rds.AddTagsToResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.AddTagsToResourceOutput
	if rf, ok := ret.Get(0).(func(*rds.AddTagsToResourceInput) *rds.AddTagsToResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.AddTagsToResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.AddTagsToResourceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AddTagsToResourceRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) AddTagsToResourceRequest(_a0 *rds.AddTagsToResourceInput) (*request.Request, *rds.AddTagsToResourceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.AddTagsToResourceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.AddTagsToResourceOutput
	if rf, ok := ret.Get(1).(func(*rds.AddTagsToResourceInput) *rds.AddTagsToResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.AddTagsToResourceOutput)
		}
	}

	return r0, r1
}

// AddTagsToResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) AddTagsToResourceWithContext(_a0 context.Context, _a1 *rds.AddTagsToResourceInput, _a2 ...request.Option) (*rds.AddTagsToResourceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.AddTagsToResourceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.AddTagsToResourceInput, ...request.Option) *rds.AddTagsToResourceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.AddTagsToResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.AddTagsToResourceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ApplyPendingMaintenanceAction provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ApplyPendingMaintenanceAction(_a0 *rds.ApplyPendingMaintenanceActionInput) (*rds.ApplyPendingMaintenanceActionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.ApplyPendingMaintenanceActionOutput
	if rf, ok := ret.Get(0).(func(*rds.ApplyPendingMaintenanceActionInput) *rds.ApplyPendingMaintenanceActionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ApplyPendingMaintenanceActionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ApplyPendingMaintenanceActionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ApplyPendingMaintenanceActionRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ApplyPendingMaintenanceActionRequest(_a0 *rds.ApplyPendingMaintenanceActionInput) (*request.Request, *rds.ApplyPendingMaintenanceActionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ApplyPendingMaintenanceActionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.ApplyPendingMaintenanceActionOutput
	if rf, ok := ret.Get(1).(func(*rds.ApplyPendingMaintenanceActionInput) *rds.ApplyPendingMaintenanceActionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.ApplyPendingMaintenanceActionOutput)
		}
	}

	return r0, r1
}

// ApplyPendingMaintenanceActionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ApplyPendingMaintenanceActionWithContext(_a0 context.Context, _a1 *rds.ApplyPendingMaintenanceActionInput, _a2 ...request.Option) (*rds.ApplyPendingMaintenanceActionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.ApplyPendingMaintenanceActionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ApplyPendingMaintenanceActionInput, ...request.Option) *rds.ApplyPendingMaintenanceActionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ApplyPendingMaintenanceActionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ApplyPendingMaintenanceActionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AuthorizeDBSecurityGroupIngress provides a mock function with given fields: _a0
func (_m *MockFakeRDS) AuthorizeDBSecurityGroupIngress(_a0 *rds.AuthorizeDBSecurityGroupIngressInput) (*rds.AuthorizeDBSecurityGroupIngressOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.AuthorizeDBSecurityGroupIngressOutput
	if rf, ok := ret.Get(0).(func(*rds.AuthorizeDBSecurityGroupIngressInput) *rds.AuthorizeDBSecurityGroupIngressOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.AuthorizeDBSecurityGroupIngressOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.AuthorizeDBSecurityGroupIngressInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AuthorizeDBSecurityGroupIngressRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) AuthorizeDBSecurityGroupIngressRequest(_a0 *rds.AuthorizeDBSecurityGroupIngressInput) (*request.Request, *rds.AuthorizeDBSecurityGroupIngressOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.AuthorizeDBSecurityGroupIngressInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.AuthorizeDBSecurityGroupIngressOutput
	if rf, ok := ret.Get(1).(func(*rds.AuthorizeDBSecurityGroupIngressInput) *rds.AuthorizeDBSecurityGroupIngressOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.AuthorizeDBSecurityGroupIngressOutput)
		}
	}

	return r0, r1
}

// AuthorizeDBSecurityGroupIngressWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) AuthorizeDBSecurityGroupIngressWithContext(_a0 context.Context, _a1 *rds.AuthorizeDBSecurityGroupIngressInput, _a2 ...request.Option) (*rds.AuthorizeDBSecurityGroupIngressOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.AuthorizeDBSecurityGroupIngressOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.AuthorizeDBSecurityGroupIngressInput, ...request.Option) *rds.AuthorizeDBSecurityGroupIngressOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.AuthorizeDBSecurityGroupIngressOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.AuthorizeDBSecurityGroupIngressInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// BacktrackDBCluster provides a mock function with given fields: _a0
func (_m *MockFakeRDS) BacktrackDBCluster(_a0 *rds.BacktrackDBClusterInput) (*rds.BacktrackDBClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.BacktrackDBClusterOutput
	if rf, ok := ret.Get(0).(func(*rds.BacktrackDBClusterInput) *rds.BacktrackDBClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.BacktrackDBClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.BacktrackDBClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// BacktrackDBClusterRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) BacktrackDBClusterRequest(_a0 *rds.BacktrackDBClusterInput) (*request.Request, *rds.BacktrackDBClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.BacktrackDBClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.BacktrackDBClusterOutput
	if rf, ok := ret.Get(1).(func(*rds.BacktrackDBClusterInput) *rds.BacktrackDBClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.BacktrackDBClusterOutput)
		}
	}

	return r0, r1
}

// BacktrackDBClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) BacktrackDBClusterWithContext(_a0 context.Context, _a1 *rds.BacktrackDBClusterInput, _a2 ...request.Option) (*rds.BacktrackDBClusterOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.BacktrackDBClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.BacktrackDBClusterInput, ...request.Option) *rds.BacktrackDBClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.BacktrackDBClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.BacktrackDBClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CancelExportTask provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CancelExportTask(_a0 *rds.CancelExportTaskInput) (*rds.CancelExportTaskOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CancelExportTaskOutput
	if rf, ok := ret.Get(0).(func(*rds.CancelExportTaskInput) *rds.CancelExportTaskOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CancelExportTaskOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CancelExportTaskInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CancelExportTaskRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CancelExportTaskRequest(_a0 *rds.CancelExportTaskInput) (*request.Request, *rds.CancelExportTaskOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CancelExportTaskInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CancelExportTaskOutput
	if rf, ok := ret.Get(1).(func(*rds.CancelExportTaskInput) *rds.CancelExportTaskOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CancelExportTaskOutput)
		}
	}

	return r0, r1
}

// CancelExportTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CancelExportTaskWithContext(_a0 context.Context, _a1 *rds.CancelExportTaskInput, _a2 ...request.Option) (*rds.CancelExportTaskOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CancelExportTaskOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CancelExportTaskInput, ...request.Option) *rds.CancelExportTaskOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CancelExportTaskOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CancelExportTaskInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CopyDBClusterParameterGroup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CopyDBClusterParameterGroup(_a0 *rds.CopyDBClusterParameterGroupInput) (*rds.CopyDBClusterParameterGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CopyDBClusterParameterGroupOutput
	if rf, ok := ret.Get(0).(func(*rds.CopyDBClusterParameterGroupInput) *rds.CopyDBClusterParameterGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CopyDBClusterParameterGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CopyDBClusterParameterGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CopyDBClusterParameterGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CopyDBClusterParameterGroupRequest(_a0 *rds.CopyDBClusterParameterGroupInput) (*request.Request, *rds.CopyDBClusterParameterGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CopyDBClusterParameterGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CopyDBClusterParameterGroupOutput
	if rf, ok := ret.Get(1).(func(*rds.CopyDBClusterParameterGroupInput) *rds.CopyDBClusterParameterGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CopyDBClusterParameterGroupOutput)
		}
	}

	return r0, r1
}

// CopyDBClusterParameterGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CopyDBClusterParameterGroupWithContext(_a0 context.Context, _a1 *rds.CopyDBClusterParameterGroupInput, _a2 ...request.Option) (*rds.CopyDBClusterParameterGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CopyDBClusterParameterGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CopyDBClusterParameterGroupInput, ...request.Option) *rds.CopyDBClusterParameterGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CopyDBClusterParameterGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CopyDBClusterParameterGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CopyDBClusterSnapshot provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CopyDBClusterSnapshot(_a0 *rds.CopyDBClusterSnapshotInput) (*rds.CopyDBClusterSnapshotOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CopyDBClusterSnapshotOutput
	if rf, ok := ret.Get(0).(func(*rds.CopyDBClusterSnapshotInput) *rds.CopyDBClusterSnapshotOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CopyDBClusterSnapshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CopyDBClusterSnapshotInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CopyDBClusterSnapshotRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CopyDBClusterSnapshotRequest(_a0 *rds.CopyDBClusterSnapshotInput) (*request.Request, *rds.CopyDBClusterSnapshotOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CopyDBClusterSnapshotInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CopyDBClusterSnapshotOutput
	if rf, ok := ret.Get(1).(func(*rds.CopyDBClusterSnapshotInput) *rds.CopyDBClusterSnapshotOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CopyDBClusterSnapshotOutput)
		}
	}

	return r0, r1
}

// CopyDBClusterSnapshotWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CopyDBClusterSnapshotWithContext(_a0 context.Context, _a1 *rds.CopyDBClusterSnapshotInput, _a2 ...request.Option) (*rds.CopyDBClusterSnapshotOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CopyDBClusterSnapshotOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CopyDBClusterSnapshotInput, ...request.Option) *rds.CopyDBClusterSnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CopyDBClusterSnapshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CopyDBClusterSnapshotInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CopyDBParameterGroup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CopyDBParameterGroup(_a0 *rds.CopyDBParameterGroupInput) (*rds.CopyDBParameterGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CopyDBParameterGroupOutput
	if rf, ok := ret.Get(0).(func(*rds.CopyDBParameterGroupInput) *rds.CopyDBParameterGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CopyDBParameterGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CopyDBParameterGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CopyDBParameterGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CopyDBParameterGroupRequest(_a0 *rds.CopyDBParameterGroupInput) (*request.Request, *rds.CopyDBParameterGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CopyDBParameterGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CopyDBParameterGroupOutput
	if rf, ok := ret.Get(1).(func(*rds.CopyDBParameterGroupInput) *rds.CopyDBParameterGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CopyDBParameterGroupOutput)
		}
	}

	return r0, r1
}

// CopyDBParameterGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CopyDBParameterGroupWithContext(_a0 context.Context, _a1 *rds.CopyDBParameterGroupInput, _a2 ...request.Option) (*rds.CopyDBParameterGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CopyDBParameterGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CopyDBParameterGroupInput, ...request.Option) *rds.CopyDBParameterGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CopyDBParameterGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CopyDBParameterGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CopyDBSnapshot provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CopyDBSnapshot(_a0 *rds.CopyDBSnapshotInput) (*rds.CopyDBSnapshotOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CopyDBSnapshotOutput
	if rf, ok := ret.Get(0).(func(*rds.CopyDBSnapshotInput) *rds.CopyDBSnapshotOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CopyDBSnapshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CopyDBSnapshotInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CopyDBSnapshotRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CopyDBSnapshotRequest(_a0 *rds.CopyDBSnapshotInput) (*request.Request, *rds.CopyDBSnapshotOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CopyDBSnapshotInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CopyDBSnapshotOutput
	if rf, ok := ret.Get(1).(func(*rds.CopyDBSnapshotInput) *rds.CopyDBSnapshotOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CopyDBSnapshotOutput)
		}
	}

	return r0, r1
}

// CopyDBSnapshotWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CopyDBSnapshotWithContext(_a0 context.Context, _a1 *rds.CopyDBSnapshotInput, _a2 ...request.Option) (*rds.CopyDBSnapshotOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CopyDBSnapshotOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CopyDBSnapshotInput, ...request.Option) *rds.CopyDBSnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CopyDBSnapshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CopyDBSnapshotInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CopyOptionGroup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CopyOptionGroup(_a0 *rds.CopyOptionGroupInput) (*rds.CopyOptionGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CopyOptionGroupOutput
	if rf, ok := ret.Get(0).(func(*rds.CopyOptionGroupInput) *rds.CopyOptionGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CopyOptionGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CopyOptionGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CopyOptionGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CopyOptionGroupRequest(_a0 *rds.CopyOptionGroupInput) (*request.Request, *rds.CopyOptionGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CopyOptionGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CopyOptionGroupOutput
	if rf, ok := ret.Get(1).(func(*rds.CopyOptionGroupInput) *rds.CopyOptionGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CopyOptionGroupOutput)
		}
	}

	return r0, r1
}

// CopyOptionGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CopyOptionGroupWithContext(_a0 context.Context, _a1 *rds.CopyOptionGroupInput, _a2 ...request.Option) (*rds.CopyOptionGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CopyOptionGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CopyOptionGroupInput, ...request.Option) *rds.CopyOptionGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CopyOptionGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CopyOptionGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateCustomAvailabilityZone provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateCustomAvailabilityZone(_a0 *rds.CreateCustomAvailabilityZoneInput) (*rds.CreateCustomAvailabilityZoneOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CreateCustomAvailabilityZoneOutput
	if rf, ok := ret.Get(0).(func(*rds.CreateCustomAvailabilityZoneInput) *rds.CreateCustomAvailabilityZoneOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateCustomAvailabilityZoneOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CreateCustomAvailabilityZoneInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateCustomAvailabilityZoneRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateCustomAvailabilityZoneRequest(_a0 *rds.CreateCustomAvailabilityZoneInput) (*request.Request, *rds.CreateCustomAvailabilityZoneOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CreateCustomAvailabilityZoneInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CreateCustomAvailabilityZoneOutput
	if rf, ok := ret.Get(1).(func(*rds.CreateCustomAvailabilityZoneInput) *rds.CreateCustomAvailabilityZoneOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CreateCustomAvailabilityZoneOutput)
		}
	}

	return r0, r1
}

// CreateCustomAvailabilityZoneWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CreateCustomAvailabilityZoneWithContext(_a0 context.Context, _a1 *rds.CreateCustomAvailabilityZoneInput, _a2 ...request.Option) (*rds.CreateCustomAvailabilityZoneOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CreateCustomAvailabilityZoneOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CreateCustomAvailabilityZoneInput, ...request.Option) *rds.CreateCustomAvailabilityZoneOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateCustomAvailabilityZoneOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CreateCustomAvailabilityZoneInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBCluster provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBCluster(_a0 *rds.CreateDBClusterInput) (*rds.CreateDBClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CreateDBClusterOutput
	if rf, ok := ret.Get(0).(func(*rds.CreateDBClusterInput) *rds.CreateDBClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CreateDBClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBClusterEndpoint provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBClusterEndpoint(_a0 *rds.CreateDBClusterEndpointInput) (*rds.CreateDBClusterEndpointOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CreateDBClusterEndpointOutput
	if rf, ok := ret.Get(0).(func(*rds.CreateDBClusterEndpointInput) *rds.CreateDBClusterEndpointOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBClusterEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CreateDBClusterEndpointInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBClusterEndpointRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBClusterEndpointRequest(_a0 *rds.CreateDBClusterEndpointInput) (*request.Request, *rds.CreateDBClusterEndpointOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CreateDBClusterEndpointInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CreateDBClusterEndpointOutput
	if rf, ok := ret.Get(1).(func(*rds.CreateDBClusterEndpointInput) *rds.CreateDBClusterEndpointOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CreateDBClusterEndpointOutput)
		}
	}

	return r0, r1
}

// CreateDBClusterEndpointWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CreateDBClusterEndpointWithContext(_a0 context.Context, _a1 *rds.CreateDBClusterEndpointInput, _a2 ...request.Option) (*rds.CreateDBClusterEndpointOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CreateDBClusterEndpointOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CreateDBClusterEndpointInput, ...request.Option) *rds.CreateDBClusterEndpointOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBClusterEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CreateDBClusterEndpointInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBClusterParameterGroup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBClusterParameterGroup(_a0 *rds.CreateDBClusterParameterGroupInput) (*rds.CreateDBClusterParameterGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CreateDBClusterParameterGroupOutput
	if rf, ok := ret.Get(0).(func(*rds.CreateDBClusterParameterGroupInput) *rds.CreateDBClusterParameterGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBClusterParameterGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CreateDBClusterParameterGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBClusterParameterGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBClusterParameterGroupRequest(_a0 *rds.CreateDBClusterParameterGroupInput) (*request.Request, *rds.CreateDBClusterParameterGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CreateDBClusterParameterGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CreateDBClusterParameterGroupOutput
	if rf, ok := ret.Get(1).(func(*rds.CreateDBClusterParameterGroupInput) *rds.CreateDBClusterParameterGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CreateDBClusterParameterGroupOutput)
		}
	}

	return r0, r1
}

// CreateDBClusterParameterGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CreateDBClusterParameterGroupWithContext(_a0 context.Context, _a1 *rds.CreateDBClusterParameterGroupInput, _a2 ...request.Option) (*rds.CreateDBClusterParameterGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CreateDBClusterParameterGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CreateDBClusterParameterGroupInput, ...request.Option) *rds.CreateDBClusterParameterGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBClusterParameterGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CreateDBClusterParameterGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBClusterRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBClusterRequest(_a0 *rds.CreateDBClusterInput) (*request.Request, *rds.CreateDBClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CreateDBClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CreateDBClusterOutput
	if rf, ok := ret.Get(1).(func(*rds.CreateDBClusterInput) *rds.CreateDBClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CreateDBClusterOutput)
		}
	}

	return r0, r1
}

// CreateDBClusterSnapshot provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBClusterSnapshot(_a0 *rds.CreateDBClusterSnapshotInput) (*rds.CreateDBClusterSnapshotOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CreateDBClusterSnapshotOutput
	if rf, ok := ret.Get(0).(func(*rds.CreateDBClusterSnapshotInput) *rds.CreateDBClusterSnapshotOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBClusterSnapshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CreateDBClusterSnapshotInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBClusterSnapshotRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBClusterSnapshotRequest(_a0 *rds.CreateDBClusterSnapshotInput) (*request.Request, *rds.CreateDBClusterSnapshotOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CreateDBClusterSnapshotInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CreateDBClusterSnapshotOutput
	if rf, ok := ret.Get(1).(func(*rds.CreateDBClusterSnapshotInput) *rds.CreateDBClusterSnapshotOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CreateDBClusterSnapshotOutput)
		}
	}

	return r0, r1
}

// CreateDBClusterSnapshotWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CreateDBClusterSnapshotWithContext(_a0 context.Context, _a1 *rds.CreateDBClusterSnapshotInput, _a2 ...request.Option) (*rds.CreateDBClusterSnapshotOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CreateDBClusterSnapshotOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CreateDBClusterSnapshotInput, ...request.Option) *rds.CreateDBClusterSnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBClusterSnapshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CreateDBClusterSnapshotInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CreateDBClusterWithContext(_a0 context.Context, _a1 *rds.CreateDBClusterInput, _a2 ...request.Option) (*rds.CreateDBClusterOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CreateDBClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CreateDBClusterInput, ...request.Option) *rds.CreateDBClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CreateDBClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBInstance provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBInstance(_a0 *rds.CreateDBInstanceInput) (*rds.CreateDBInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CreateDBInstanceOutput
	if rf, ok := ret.Get(0).(func(*rds.CreateDBInstanceInput) *rds.CreateDBInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CreateDBInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBInstanceReadReplica provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBInstanceReadReplica(_a0 *rds.CreateDBInstanceReadReplicaInput) (*rds.CreateDBInstanceReadReplicaOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CreateDBInstanceReadReplicaOutput
	if rf, ok := ret.Get(0).(func(*rds.CreateDBInstanceReadReplicaInput) *rds.CreateDBInstanceReadReplicaOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBInstanceReadReplicaOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CreateDBInstanceReadReplicaInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBInstanceReadReplicaRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBInstanceReadReplicaRequest(_a0 *rds.CreateDBInstanceReadReplicaInput) (*request.Request, *rds.CreateDBInstanceReadReplicaOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CreateDBInstanceReadReplicaInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CreateDBInstanceReadReplicaOutput
	if rf, ok := ret.Get(1).(func(*rds.CreateDBInstanceReadReplicaInput) *rds.CreateDBInstanceReadReplicaOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CreateDBInstanceReadReplicaOutput)
		}
	}

	return r0, r1
}

// CreateDBInstanceReadReplicaWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CreateDBInstanceReadReplicaWithContext(_a0 context.Context, _a1 *rds.CreateDBInstanceReadReplicaInput, _a2 ...request.Option) (*rds.CreateDBInstanceReadReplicaOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CreateDBInstanceReadReplicaOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CreateDBInstanceReadReplicaInput, ...request.Option) *rds.CreateDBInstanceReadReplicaOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBInstanceReadReplicaOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CreateDBInstanceReadReplicaInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBInstanceRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBInstanceRequest(_a0 *rds.CreateDBInstanceInput) (*request.Request, *rds.CreateDBInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CreateDBInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CreateDBInstanceOutput
	if rf, ok := ret.Get(1).(func(*rds.CreateDBInstanceInput) *rds.CreateDBInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CreateDBInstanceOutput)
		}
	}

	return r0, r1
}

// CreateDBInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CreateDBInstanceWithContext(_a0 context.Context, _a1 *rds.CreateDBInstanceInput, _a2 ...request.Option) (*rds.CreateDBInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CreateDBInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CreateDBInstanceInput, ...request.Option) *rds.CreateDBInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CreateDBInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBParameterGroup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBParameterGroup(_a0 *rds.CreateDBParameterGroupInput) (*rds.CreateDBParameterGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CreateDBParameterGroupOutput
	if rf, ok := ret.Get(0).(func(*rds.CreateDBParameterGroupInput) *rds.CreateDBParameterGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBParameterGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CreateDBParameterGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBParameterGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBParameterGroupRequest(_a0 *rds.CreateDBParameterGroupInput) (*request.Request, *rds.CreateDBParameterGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CreateDBParameterGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CreateDBParameterGroupOutput
	if rf, ok := ret.Get(1).(func(*rds.CreateDBParameterGroupInput) *rds.CreateDBParameterGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CreateDBParameterGroupOutput)
		}
	}

	return r0, r1
}

// CreateDBParameterGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CreateDBParameterGroupWithContext(_a0 context.Context, _a1 *rds.CreateDBParameterGroupInput, _a2 ...request.Option) (*rds.CreateDBParameterGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CreateDBParameterGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CreateDBParameterGroupInput, ...request.Option) *rds.CreateDBParameterGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBParameterGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CreateDBParameterGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBProxy provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBProxy(_a0 *rds.CreateDBProxyInput) (*rds.CreateDBProxyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CreateDBProxyOutput
	if rf, ok := ret.Get(0).(func(*rds.CreateDBProxyInput) *rds.CreateDBProxyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBProxyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CreateDBProxyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBProxyEndpoint provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBProxyEndpoint(_a0 *rds.CreateDBProxyEndpointInput) (*rds.CreateDBProxyEndpointOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CreateDBProxyEndpointOutput
	if rf, ok := ret.Get(0).(func(*rds.CreateDBProxyEndpointInput) *rds.CreateDBProxyEndpointOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBProxyEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CreateDBProxyEndpointInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBProxyEndpointRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBProxyEndpointRequest(_a0 *rds.CreateDBProxyEndpointInput) (*request.Request, *rds.CreateDBProxyEndpointOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CreateDBProxyEndpointInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CreateDBProxyEndpointOutput
	if rf, ok := ret.Get(1).(func(*rds.CreateDBProxyEndpointInput) *rds.CreateDBProxyEndpointOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CreateDBProxyEndpointOutput)
		}
	}

	return r0, r1
}

// CreateDBProxyEndpointWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CreateDBProxyEndpointWithContext(_a0 context.Context, _a1 *rds.CreateDBProxyEndpointInput, _a2 ...request.Option) (*rds.CreateDBProxyEndpointOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CreateDBProxyEndpointOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CreateDBProxyEndpointInput, ...request.Option) *rds.CreateDBProxyEndpointOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBProxyEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CreateDBProxyEndpointInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBProxyRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBProxyRequest(_a0 *rds.CreateDBProxyInput) (*request.Request, *rds.CreateDBProxyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CreateDBProxyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CreateDBProxyOutput
	if rf, ok := ret.Get(1).(func(*rds.CreateDBProxyInput) *rds.CreateDBProxyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CreateDBProxyOutput)
		}
	}

	return r0, r1
}

// CreateDBProxyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CreateDBProxyWithContext(_a0 context.Context, _a1 *rds.CreateDBProxyInput, _a2 ...request.Option) (*rds.CreateDBProxyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CreateDBProxyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CreateDBProxyInput, ...request.Option) *rds.CreateDBProxyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBProxyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CreateDBProxyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBSecurityGroup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBSecurityGroup(_a0 *rds.CreateDBSecurityGroupInput) (*rds.CreateDBSecurityGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CreateDBSecurityGroupOutput
	if rf, ok := ret.Get(0).(func(*rds.CreateDBSecurityGroupInput) *rds.CreateDBSecurityGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBSecurityGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CreateDBSecurityGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBSecurityGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBSecurityGroupRequest(_a0 *rds.CreateDBSecurityGroupInput) (*request.Request, *rds.CreateDBSecurityGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CreateDBSecurityGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CreateDBSecurityGroupOutput
	if rf, ok := ret.Get(1).(func(*rds.CreateDBSecurityGroupInput) *rds.CreateDBSecurityGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CreateDBSecurityGroupOutput)
		}
	}

	return r0, r1
}

// CreateDBSecurityGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CreateDBSecurityGroupWithContext(_a0 context.Context, _a1 *rds.CreateDBSecurityGroupInput, _a2 ...request.Option) (*rds.CreateDBSecurityGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CreateDBSecurityGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CreateDBSecurityGroupInput, ...request.Option) *rds.CreateDBSecurityGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBSecurityGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CreateDBSecurityGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBSnapshot provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBSnapshot(_a0 *rds.CreateDBSnapshotInput) (*rds.CreateDBSnapshotOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CreateDBSnapshotOutput
	if rf, ok := ret.Get(0).(func(*rds.CreateDBSnapshotInput) *rds.CreateDBSnapshotOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBSnapshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CreateDBSnapshotInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBSnapshotRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBSnapshotRequest(_a0 *rds.CreateDBSnapshotInput) (*request.Request, *rds.CreateDBSnapshotOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CreateDBSnapshotInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CreateDBSnapshotOutput
	if rf, ok := ret.Get(1).(func(*rds.CreateDBSnapshotInput) *rds.CreateDBSnapshotOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CreateDBSnapshotOutput)
		}
	}

	return r0, r1
}

// CreateDBSnapshotWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CreateDBSnapshotWithContext(_a0 context.Context, _a1 *rds.CreateDBSnapshotInput, _a2 ...request.Option) (*rds.CreateDBSnapshotOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CreateDBSnapshotOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CreateDBSnapshotInput, ...request.Option) *rds.CreateDBSnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBSnapshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CreateDBSnapshotInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBSubnetGroup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBSubnetGroup(_a0 *rds.CreateDBSubnetGroupInput) (*rds.CreateDBSubnetGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CreateDBSubnetGroupOutput
	if rf, ok := ret.Get(0).(func(*rds.CreateDBSubnetGroupInput) *rds.CreateDBSubnetGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBSubnetGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CreateDBSubnetGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateDBSubnetGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateDBSubnetGroupRequest(_a0 *rds.CreateDBSubnetGroupInput) (*request.Request, *rds.CreateDBSubnetGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CreateDBSubnetGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CreateDBSubnetGroupOutput
	if rf, ok := ret.Get(1).(func(*rds.CreateDBSubnetGroupInput) *rds.CreateDBSubnetGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CreateDBSubnetGroupOutput)
		}
	}

	return r0, r1
}

// CreateDBSubnetGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CreateDBSubnetGroupWithContext(_a0 context.Context, _a1 *rds.CreateDBSubnetGroupInput, _a2 ...request.Option) (*rds.CreateDBSubnetGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CreateDBSubnetGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CreateDBSubnetGroupInput, ...request.Option) *rds.CreateDBSubnetGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateDBSubnetGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CreateDBSubnetGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateEventSubscription provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateEventSubscription(_a0 *rds.CreateEventSubscriptionInput) (*rds.CreateEventSubscriptionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CreateEventSubscriptionOutput
	if rf, ok := ret.Get(0).(func(*rds.CreateEventSubscriptionInput) *rds.CreateEventSubscriptionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateEventSubscriptionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CreateEventSubscriptionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateEventSubscriptionRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateEventSubscriptionRequest(_a0 *rds.CreateEventSubscriptionInput) (*request.Request, *rds.CreateEventSubscriptionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CreateEventSubscriptionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CreateEventSubscriptionOutput
	if rf, ok := ret.Get(1).(func(*rds.CreateEventSubscriptionInput) *rds.CreateEventSubscriptionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CreateEventSubscriptionOutput)
		}
	}

	return r0, r1
}

// CreateEventSubscriptionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CreateEventSubscriptionWithContext(_a0 context.Context, _a1 *rds.CreateEventSubscriptionInput, _a2 ...request.Option) (*rds.CreateEventSubscriptionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CreateEventSubscriptionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CreateEventSubscriptionInput, ...request.Option) *rds.CreateEventSubscriptionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateEventSubscriptionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CreateEventSubscriptionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateGlobalCluster provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateGlobalCluster(_a0 *rds.CreateGlobalClusterInput) (*rds.CreateGlobalClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CreateGlobalClusterOutput
	if rf, ok := ret.Get(0).(func(*rds.CreateGlobalClusterInput) *rds.CreateGlobalClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateGlobalClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CreateGlobalClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateGlobalClusterRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateGlobalClusterRequest(_a0 *rds.CreateGlobalClusterInput) (*request.Request, *rds.CreateGlobalClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CreateGlobalClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CreateGlobalClusterOutput
	if rf, ok := ret.Get(1).(func(*rds.CreateGlobalClusterInput) *rds.CreateGlobalClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CreateGlobalClusterOutput)
		}
	}

	return r0, r1
}

// CreateGlobalClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CreateGlobalClusterWithContext(_a0 context.Context, _a1 *rds.CreateGlobalClusterInput, _a2 ...request.Option) (*rds.CreateGlobalClusterOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CreateGlobalClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CreateGlobalClusterInput, ...request.Option) *rds.CreateGlobalClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateGlobalClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CreateGlobalClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateOptionGroup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateOptionGroup(_a0 *rds.CreateOptionGroupInput) (*rds.CreateOptionGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.CreateOptionGroupOutput
	if rf, ok := ret.Get(0).(func(*rds.CreateOptionGroupInput) *rds.CreateOptionGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateOptionGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.CreateOptionGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateOptionGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) CreateOptionGroupRequest(_a0 *rds.CreateOptionGroupInput) (*request.Request, *rds.CreateOptionGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.CreateOptionGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.CreateOptionGroupOutput
	if rf, ok := ret.Get(1).(func(*rds.CreateOptionGroupInput) *rds.CreateOptionGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.CreateOptionGroupOutput)
		}
	}

	return r0, r1
}

// CreateOptionGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) CreateOptionGroupWithContext(_a0 context.Context, _a1 *rds.CreateOptionGroupInput, _a2 ...request.Option) (*rds.CreateOptionGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.CreateOptionGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.CreateOptionGroupInput, ...request.Option) *rds.CreateOptionGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.CreateOptionGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.CreateOptionGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteCustomAvailabilityZone provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteCustomAvailabilityZone(_a0 *rds.DeleteCustomAvailabilityZoneInput) (*rds.DeleteCustomAvailabilityZoneOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DeleteCustomAvailabilityZoneOutput
	if rf, ok := ret.Get(0).(func(*rds.DeleteCustomAvailabilityZoneInput) *rds.DeleteCustomAvailabilityZoneOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteCustomAvailabilityZoneOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DeleteCustomAvailabilityZoneInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteCustomAvailabilityZoneRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteCustomAvailabilityZoneRequest(_a0 *rds.DeleteCustomAvailabilityZoneInput) (*request.Request, *rds.DeleteCustomAvailabilityZoneOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DeleteCustomAvailabilityZoneInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DeleteCustomAvailabilityZoneOutput
	if rf, ok := ret.Get(1).(func(*rds.DeleteCustomAvailabilityZoneInput) *rds.DeleteCustomAvailabilityZoneOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DeleteCustomAvailabilityZoneOutput)
		}
	}

	return r0, r1
}

// DeleteCustomAvailabilityZoneWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DeleteCustomAvailabilityZoneWithContext(_a0 context.Context, _a1 *rds.DeleteCustomAvailabilityZoneInput, _a2 ...request.Option) (*rds.DeleteCustomAvailabilityZoneOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DeleteCustomAvailabilityZoneOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DeleteCustomAvailabilityZoneInput, ...request.Option) *rds.DeleteCustomAvailabilityZoneOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteCustomAvailabilityZoneOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DeleteCustomAvailabilityZoneInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBCluster provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBCluster(_a0 *rds.DeleteDBClusterInput) (*rds.DeleteDBClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DeleteDBClusterOutput
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBClusterInput) *rds.DeleteDBClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBClusterEndpoint provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBClusterEndpoint(_a0 *rds.DeleteDBClusterEndpointInput) (*rds.DeleteDBClusterEndpointOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DeleteDBClusterEndpointOutput
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBClusterEndpointInput) *rds.DeleteDBClusterEndpointOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBClusterEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBClusterEndpointInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBClusterEndpointRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBClusterEndpointRequest(_a0 *rds.DeleteDBClusterEndpointInput) (*request.Request, *rds.DeleteDBClusterEndpointOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBClusterEndpointInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DeleteDBClusterEndpointOutput
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBClusterEndpointInput) *rds.DeleteDBClusterEndpointOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DeleteDBClusterEndpointOutput)
		}
	}

	return r0, r1
}

// DeleteDBClusterEndpointWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DeleteDBClusterEndpointWithContext(_a0 context.Context, _a1 *rds.DeleteDBClusterEndpointInput, _a2 ...request.Option) (*rds.DeleteDBClusterEndpointOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DeleteDBClusterEndpointOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DeleteDBClusterEndpointInput, ...request.Option) *rds.DeleteDBClusterEndpointOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBClusterEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DeleteDBClusterEndpointInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBClusterParameterGroup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBClusterParameterGroup(_a0 *rds.DeleteDBClusterParameterGroupInput) (*rds.DeleteDBClusterParameterGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DeleteDBClusterParameterGroupOutput
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBClusterParameterGroupInput) *rds.DeleteDBClusterParameterGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBClusterParameterGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBClusterParameterGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBClusterParameterGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBClusterParameterGroupRequest(_a0 *rds.DeleteDBClusterParameterGroupInput) (*request.Request, *rds.DeleteDBClusterParameterGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBClusterParameterGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DeleteDBClusterParameterGroupOutput
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBClusterParameterGroupInput) *rds.DeleteDBClusterParameterGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DeleteDBClusterParameterGroupOutput)
		}
	}

	return r0, r1
}

// DeleteDBClusterParameterGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DeleteDBClusterParameterGroupWithContext(_a0 context.Context, _a1 *rds.DeleteDBClusterParameterGroupInput, _a2 ...request.Option) (*rds.DeleteDBClusterParameterGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DeleteDBClusterParameterGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DeleteDBClusterParameterGroupInput, ...request.Option) *rds.DeleteDBClusterParameterGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBClusterParameterGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DeleteDBClusterParameterGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBClusterRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBClusterRequest(_a0 *rds.DeleteDBClusterInput) (*request.Request, *rds.DeleteDBClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DeleteDBClusterOutput
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBClusterInput) *rds.DeleteDBClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DeleteDBClusterOutput)
		}
	}

	return r0, r1
}

// DeleteDBClusterSnapshot provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBClusterSnapshot(_a0 *rds.DeleteDBClusterSnapshotInput) (*rds.DeleteDBClusterSnapshotOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DeleteDBClusterSnapshotOutput
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBClusterSnapshotInput) *rds.DeleteDBClusterSnapshotOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBClusterSnapshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBClusterSnapshotInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBClusterSnapshotRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBClusterSnapshotRequest(_a0 *rds.DeleteDBClusterSnapshotInput) (*request.Request, *rds.DeleteDBClusterSnapshotOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBClusterSnapshotInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DeleteDBClusterSnapshotOutput
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBClusterSnapshotInput) *rds.DeleteDBClusterSnapshotOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DeleteDBClusterSnapshotOutput)
		}
	}

	return r0, r1
}

// DeleteDBClusterSnapshotWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DeleteDBClusterSnapshotWithContext(_a0 context.Context, _a1 *rds.DeleteDBClusterSnapshotInput, _a2 ...request.Option) (*rds.DeleteDBClusterSnapshotOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DeleteDBClusterSnapshotOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DeleteDBClusterSnapshotInput, ...request.Option) *rds.DeleteDBClusterSnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBClusterSnapshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DeleteDBClusterSnapshotInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DeleteDBClusterWithContext(_a0 context.Context, _a1 *rds.DeleteDBClusterInput, _a2 ...request.Option) (*rds.DeleteDBClusterOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DeleteDBClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DeleteDBClusterInput, ...request.Option) *rds.DeleteDBClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DeleteDBClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBInstance provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBInstance(_a0 *rds.DeleteDBInstanceInput) (*rds.DeleteDBInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DeleteDBInstanceOutput
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBInstanceInput) *rds.DeleteDBInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBInstanceAutomatedBackup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBInstanceAutomatedBackup(_a0 *rds.DeleteDBInstanceAutomatedBackupInput) (*rds.DeleteDBInstanceAutomatedBackupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DeleteDBInstanceAutomatedBackupOutput
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBInstanceAutomatedBackupInput) *rds.DeleteDBInstanceAutomatedBackupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBInstanceAutomatedBackupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBInstanceAutomatedBackupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBInstanceAutomatedBackupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBInstanceAutomatedBackupRequest(_a0 *rds.DeleteDBInstanceAutomatedBackupInput) (*request.Request, *rds.DeleteDBInstanceAutomatedBackupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBInstanceAutomatedBackupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DeleteDBInstanceAutomatedBackupOutput
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBInstanceAutomatedBackupInput) *rds.DeleteDBInstanceAutomatedBackupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DeleteDBInstanceAutomatedBackupOutput)
		}
	}

	return r0, r1
}

// DeleteDBInstanceAutomatedBackupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DeleteDBInstanceAutomatedBackupWithContext(_a0 context.Context, _a1 *rds.DeleteDBInstanceAutomatedBackupInput, _a2 ...request.Option) (*rds.DeleteDBInstanceAutomatedBackupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DeleteDBInstanceAutomatedBackupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DeleteDBInstanceAutomatedBackupInput, ...request.Option) *rds.DeleteDBInstanceAutomatedBackupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBInstanceAutomatedBackupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DeleteDBInstanceAutomatedBackupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBInstanceRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBInstanceRequest(_a0 *rds.DeleteDBInstanceInput) (*request.Request, *rds.DeleteDBInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DeleteDBInstanceOutput
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBInstanceInput) *rds.DeleteDBInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DeleteDBInstanceOutput)
		}
	}

	return r0, r1
}

// DeleteDBInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DeleteDBInstanceWithContext(_a0 context.Context, _a1 *rds.DeleteDBInstanceInput, _a2 ...request.Option) (*rds.DeleteDBInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DeleteDBInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DeleteDBInstanceInput, ...request.Option) *rds.DeleteDBInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DeleteDBInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBParameterGroup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBParameterGroup(_a0 *rds.DeleteDBParameterGroupInput) (*rds.DeleteDBParameterGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DeleteDBParameterGroupOutput
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBParameterGroupInput) *rds.DeleteDBParameterGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBParameterGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBParameterGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBParameterGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBParameterGroupRequest(_a0 *rds.DeleteDBParameterGroupInput) (*request.Request, *rds.DeleteDBParameterGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBParameterGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DeleteDBParameterGroupOutput
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBParameterGroupInput) *rds.DeleteDBParameterGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DeleteDBParameterGroupOutput)
		}
	}

	return r0, r1
}

// DeleteDBParameterGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DeleteDBParameterGroupWithContext(_a0 context.Context, _a1 *rds.DeleteDBParameterGroupInput, _a2 ...request.Option) (*rds.DeleteDBParameterGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DeleteDBParameterGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DeleteDBParameterGroupInput, ...request.Option) *rds.DeleteDBParameterGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBParameterGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DeleteDBParameterGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBProxy provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBProxy(_a0 *rds.DeleteDBProxyInput) (*rds.DeleteDBProxyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DeleteDBProxyOutput
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBProxyInput) *rds.DeleteDBProxyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBProxyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBProxyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBProxyEndpoint provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBProxyEndpoint(_a0 *rds.DeleteDBProxyEndpointInput) (*rds.DeleteDBProxyEndpointOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DeleteDBProxyEndpointOutput
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBProxyEndpointInput) *rds.DeleteDBProxyEndpointOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBProxyEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBProxyEndpointInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBProxyEndpointRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBProxyEndpointRequest(_a0 *rds.DeleteDBProxyEndpointInput) (*request.Request, *rds.DeleteDBProxyEndpointOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBProxyEndpointInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DeleteDBProxyEndpointOutput
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBProxyEndpointInput) *rds.DeleteDBProxyEndpointOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DeleteDBProxyEndpointOutput)
		}
	}

	return r0, r1
}

// DeleteDBProxyEndpointWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DeleteDBProxyEndpointWithContext(_a0 context.Context, _a1 *rds.DeleteDBProxyEndpointInput, _a2 ...request.Option) (*rds.DeleteDBProxyEndpointOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DeleteDBProxyEndpointOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DeleteDBProxyEndpointInput, ...request.Option) *rds.DeleteDBProxyEndpointOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBProxyEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DeleteDBProxyEndpointInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBProxyRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBProxyRequest(_a0 *rds.DeleteDBProxyInput) (*request.Request, *rds.DeleteDBProxyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBProxyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DeleteDBProxyOutput
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBProxyInput) *rds.DeleteDBProxyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DeleteDBProxyOutput)
		}
	}

	return r0, r1
}

// DeleteDBProxyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DeleteDBProxyWithContext(_a0 context.Context, _a1 *rds.DeleteDBProxyInput, _a2 ...request.Option) (*rds.DeleteDBProxyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DeleteDBProxyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DeleteDBProxyInput, ...request.Option) *rds.DeleteDBProxyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBProxyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DeleteDBProxyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBSecurityGroup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBSecurityGroup(_a0 *rds.DeleteDBSecurityGroupInput) (*rds.DeleteDBSecurityGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DeleteDBSecurityGroupOutput
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBSecurityGroupInput) *rds.DeleteDBSecurityGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBSecurityGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBSecurityGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBSecurityGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBSecurityGroupRequest(_a0 *rds.DeleteDBSecurityGroupInput) (*request.Request, *rds.DeleteDBSecurityGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBSecurityGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DeleteDBSecurityGroupOutput
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBSecurityGroupInput) *rds.DeleteDBSecurityGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DeleteDBSecurityGroupOutput)
		}
	}

	return r0, r1
}

// DeleteDBSecurityGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DeleteDBSecurityGroupWithContext(_a0 context.Context, _a1 *rds.DeleteDBSecurityGroupInput, _a2 ...request.Option) (*rds.DeleteDBSecurityGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DeleteDBSecurityGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DeleteDBSecurityGroupInput, ...request.Option) *rds.DeleteDBSecurityGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBSecurityGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DeleteDBSecurityGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBSnapshot provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBSnapshot(_a0 *rds.DeleteDBSnapshotInput) (*rds.DeleteDBSnapshotOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DeleteDBSnapshotOutput
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBSnapshotInput) *rds.DeleteDBSnapshotOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBSnapshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBSnapshotInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBSnapshotRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBSnapshotRequest(_a0 *rds.DeleteDBSnapshotInput) (*request.Request, *rds.DeleteDBSnapshotOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBSnapshotInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DeleteDBSnapshotOutput
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBSnapshotInput) *rds.DeleteDBSnapshotOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DeleteDBSnapshotOutput)
		}
	}

	return r0, r1
}

// DeleteDBSnapshotWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DeleteDBSnapshotWithContext(_a0 context.Context, _a1 *rds.DeleteDBSnapshotInput, _a2 ...request.Option) (*rds.DeleteDBSnapshotOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DeleteDBSnapshotOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DeleteDBSnapshotInput, ...request.Option) *rds.DeleteDBSnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBSnapshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DeleteDBSnapshotInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBSubnetGroup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBSubnetGroup(_a0 *rds.DeleteDBSubnetGroupInput) (*rds.DeleteDBSubnetGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DeleteDBSubnetGroupOutput
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBSubnetGroupInput) *rds.DeleteDBSubnetGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBSubnetGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBSubnetGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteDBSubnetGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteDBSubnetGroupRequest(_a0 *rds.DeleteDBSubnetGroupInput) (*request.Request, *rds.DeleteDBSubnetGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DeleteDBSubnetGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DeleteDBSubnetGroupOutput
	if rf, ok := ret.Get(1).(func(*rds.DeleteDBSubnetGroupInput) *rds.DeleteDBSubnetGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DeleteDBSubnetGroupOutput)
		}
	}

	return r0, r1
}

// DeleteDBSubnetGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DeleteDBSubnetGroupWithContext(_a0 context.Context, _a1 *rds.DeleteDBSubnetGroupInput, _a2 ...request.Option) (*rds.DeleteDBSubnetGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DeleteDBSubnetGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DeleteDBSubnetGroupInput, ...request.Option) *rds.DeleteDBSubnetGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteDBSubnetGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DeleteDBSubnetGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteEventSubscription provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteEventSubscription(_a0 *rds.DeleteEventSubscriptionInput) (*rds.DeleteEventSubscriptionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DeleteEventSubscriptionOutput
	if rf, ok := ret.Get(0).(func(*rds.DeleteEventSubscriptionInput) *rds.DeleteEventSubscriptionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteEventSubscriptionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DeleteEventSubscriptionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteEventSubscriptionRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteEventSubscriptionRequest(_a0 *rds.DeleteEventSubscriptionInput) (*request.Request, *rds.DeleteEventSubscriptionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DeleteEventSubscriptionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DeleteEventSubscriptionOutput
	if rf, ok := ret.Get(1).(func(*rds.DeleteEventSubscriptionInput) *rds.DeleteEventSubscriptionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DeleteEventSubscriptionOutput)
		}
	}

	return r0, r1
}

// DeleteEventSubscriptionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DeleteEventSubscriptionWithContext(_a0 context.Context, _a1 *rds.DeleteEventSubscriptionInput, _a2 ...request.Option) (*rds.DeleteEventSubscriptionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DeleteEventSubscriptionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DeleteEventSubscriptionInput, ...request.Option) *rds.DeleteEventSubscriptionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteEventSubscriptionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DeleteEventSubscriptionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteGlobalCluster provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteGlobalCluster(_a0 *rds.DeleteGlobalClusterInput) (*rds.DeleteGlobalClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DeleteGlobalClusterOutput
	if rf, ok := ret.Get(0).(func(*rds.DeleteGlobalClusterInput) *rds.DeleteGlobalClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteGlobalClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DeleteGlobalClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteGlobalClusterRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteGlobalClusterRequest(_a0 *rds.DeleteGlobalClusterInput) (*request.Request, *rds.DeleteGlobalClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DeleteGlobalClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DeleteGlobalClusterOutput
	if rf, ok := ret.Get(1).(func(*rds.DeleteGlobalClusterInput) *rds.DeleteGlobalClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DeleteGlobalClusterOutput)
		}
	}

	return r0, r1
}

// DeleteGlobalClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DeleteGlobalClusterWithContext(_a0 context.Context, _a1 *rds.DeleteGlobalClusterInput, _a2 ...request.Option) (*rds.DeleteGlobalClusterOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DeleteGlobalClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DeleteGlobalClusterInput, ...request.Option) *rds.DeleteGlobalClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteGlobalClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DeleteGlobalClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteInstallationMedia provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteInstallationMedia(_a0 *rds.DeleteInstallationMediaInput) (*rds.DeleteInstallationMediaOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DeleteInstallationMediaOutput
	if rf, ok := ret.Get(0).(func(*rds.DeleteInstallationMediaInput) *rds.DeleteInstallationMediaOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteInstallationMediaOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DeleteInstallationMediaInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteInstallationMediaRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteInstallationMediaRequest(_a0 *rds.DeleteInstallationMediaInput) (*request.Request, *rds.DeleteInstallationMediaOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DeleteInstallationMediaInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DeleteInstallationMediaOutput
	if rf, ok := ret.Get(1).(func(*rds.DeleteInstallationMediaInput) *rds.DeleteInstallationMediaOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DeleteInstallationMediaOutput)
		}
	}

	return r0, r1
}

// DeleteInstallationMediaWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DeleteInstallationMediaWithContext(_a0 context.Context, _a1 *rds.DeleteInstallationMediaInput, _a2 ...request.Option) (*rds.DeleteInstallationMediaOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DeleteInstallationMediaOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DeleteInstallationMediaInput, ...request.Option) *rds.DeleteInstallationMediaOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteInstallationMediaOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DeleteInstallationMediaInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteOptionGroup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteOptionGroup(_a0 *rds.DeleteOptionGroupInput) (*rds.DeleteOptionGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DeleteOptionGroupOutput
	if rf, ok := ret.Get(0).(func(*rds.DeleteOptionGroupInput) *rds.DeleteOptionGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteOptionGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DeleteOptionGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteOptionGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeleteOptionGroupRequest(_a0 *rds.DeleteOptionGroupInput) (*request.Request, *rds.DeleteOptionGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DeleteOptionGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DeleteOptionGroupOutput
	if rf, ok := ret.Get(1).(func(*rds.DeleteOptionGroupInput) *rds.DeleteOptionGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DeleteOptionGroupOutput)
		}
	}

	return r0, r1
}

// DeleteOptionGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DeleteOptionGroupWithContext(_a0 context.Context, _a1 *rds.DeleteOptionGroupInput, _a2 ...request.Option) (*rds.DeleteOptionGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DeleteOptionGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DeleteOptionGroupInput, ...request.Option) *rds.DeleteOptionGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeleteOptionGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DeleteOptionGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeregisterDBProxyTargets provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeregisterDBProxyTargets(_a0 *rds.DeregisterDBProxyTargetsInput) (*rds.DeregisterDBProxyTargetsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DeregisterDBProxyTargetsOutput
	if rf, ok := ret.Get(0).(func(*rds.DeregisterDBProxyTargetsInput) *rds.DeregisterDBProxyTargetsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeregisterDBProxyTargetsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DeregisterDBProxyTargetsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeregisterDBProxyTargetsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DeregisterDBProxyTargetsRequest(_a0 *rds.DeregisterDBProxyTargetsInput) (*request.Request, *rds.DeregisterDBProxyTargetsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DeregisterDBProxyTargetsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DeregisterDBProxyTargetsOutput
	if rf, ok := ret.Get(1).(func(*rds.DeregisterDBProxyTargetsInput) *rds.DeregisterDBProxyTargetsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DeregisterDBProxyTargetsOutput)
		}
	}

	return r0, r1
}

// DeregisterDBProxyTargetsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DeregisterDBProxyTargetsWithContext(_a0 context.Context, _a1 *rds.DeregisterDBProxyTargetsInput, _a2 ...request.Option) (*rds.DeregisterDBProxyTargetsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DeregisterDBProxyTargetsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DeregisterDBProxyTargetsInput, ...request.Option) *rds.DeregisterDBProxyTargetsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DeregisterDBProxyTargetsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DeregisterDBProxyTargetsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeAccountAttributes provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeAccountAttributes(_a0 *rds.DescribeAccountAttributesInput) (*rds.DescribeAccountAttributesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeAccountAttributesOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeAccountAttributesInput) *rds.DescribeAccountAttributesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeAccountAttributesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeAccountAttributesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeAccountAttributesRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeAccountAttributesRequest(_a0 *rds.DescribeAccountAttributesInput) (*request.Request, *rds.DescribeAccountAttributesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeAccountAttributesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeAccountAttributesOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeAccountAttributesInput) *rds.DescribeAccountAttributesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeAccountAttributesOutput)
		}
	}

	return r0, r1
}

// DescribeAccountAttributesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeAccountAttributesWithContext(_a0 context.Context, _a1 *rds.DescribeAccountAttributesInput, _a2 ...request.Option) (*rds.DescribeAccountAttributesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeAccountAttributesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeAccountAttributesInput, ...request.Option) *rds.DescribeAccountAttributesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeAccountAttributesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeAccountAttributesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeCertificates provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeCertificates(_a0 *rds.DescribeCertificatesInput) (*rds.DescribeCertificatesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeCertificatesOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeCertificatesInput) *rds.DescribeCertificatesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeCertificatesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeCertificatesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeCertificatesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeCertificatesPages(_a0 *rds.DescribeCertificatesInput, _a1 func(*rds.DescribeCertificatesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeCertificatesInput, func(*rds.DescribeCertificatesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeCertificatesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeCertificatesPagesWithContext(_a0 context.Context, _a1 *rds.DescribeCertificatesInput, _a2 func(*rds.DescribeCertificatesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeCertificatesInput, func(*rds.DescribeCertificatesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeCertificatesRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeCertificatesRequest(_a0 *rds.DescribeCertificatesInput) (*request.Request, *rds.DescribeCertificatesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeCertificatesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeCertificatesOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeCertificatesInput) *rds.DescribeCertificatesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeCertificatesOutput)
		}
	}

	return r0, r1
}

// DescribeCertificatesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeCertificatesWithContext(_a0 context.Context, _a1 *rds.DescribeCertificatesInput, _a2 ...request.Option) (*rds.DescribeCertificatesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeCertificatesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeCertificatesInput, ...request.Option) *rds.DescribeCertificatesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeCertificatesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeCertificatesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeCustomAvailabilityZones provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeCustomAvailabilityZones(_a0 *rds.DescribeCustomAvailabilityZonesInput) (*rds.DescribeCustomAvailabilityZonesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeCustomAvailabilityZonesOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeCustomAvailabilityZonesInput) *rds.DescribeCustomAvailabilityZonesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeCustomAvailabilityZonesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeCustomAvailabilityZonesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeCustomAvailabilityZonesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeCustomAvailabilityZonesPages(_a0 *rds.DescribeCustomAvailabilityZonesInput, _a1 func(*rds.DescribeCustomAvailabilityZonesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeCustomAvailabilityZonesInput, func(*rds.DescribeCustomAvailabilityZonesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeCustomAvailabilityZonesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeCustomAvailabilityZonesPagesWithContext(_a0 context.Context, _a1 *rds.DescribeCustomAvailabilityZonesInput, _a2 func(*rds.DescribeCustomAvailabilityZonesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeCustomAvailabilityZonesInput, func(*rds.DescribeCustomAvailabilityZonesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeCustomAvailabilityZonesRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeCustomAvailabilityZonesRequest(_a0 *rds.DescribeCustomAvailabilityZonesInput) (*request.Request, *rds.DescribeCustomAvailabilityZonesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeCustomAvailabilityZonesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeCustomAvailabilityZonesOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeCustomAvailabilityZonesInput) *rds.DescribeCustomAvailabilityZonesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeCustomAvailabilityZonesOutput)
		}
	}

	return r0, r1
}

// DescribeCustomAvailabilityZonesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeCustomAvailabilityZonesWithContext(_a0 context.Context, _a1 *rds.DescribeCustomAvailabilityZonesInput, _a2 ...request.Option) (*rds.DescribeCustomAvailabilityZonesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeCustomAvailabilityZonesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeCustomAvailabilityZonesInput, ...request.Option) *rds.DescribeCustomAvailabilityZonesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeCustomAvailabilityZonesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeCustomAvailabilityZonesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBClusterBacktracks provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBClusterBacktracks(_a0 *rds.DescribeDBClusterBacktracksInput) (*rds.DescribeDBClusterBacktracksOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBClusterBacktracksOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClusterBacktracksInput) *rds.DescribeDBClusterBacktracksOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBClusterBacktracksOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBClusterBacktracksInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBClusterBacktracksPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeDBClusterBacktracksPages(_a0 *rds.DescribeDBClusterBacktracksInput, _a1 func(*rds.DescribeDBClusterBacktracksOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClusterBacktracksInput, func(*rds.DescribeDBClusterBacktracksOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBClusterBacktracksPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeDBClusterBacktracksPagesWithContext(_a0 context.Context, _a1 *rds.DescribeDBClusterBacktracksInput, _a2 func(*rds.DescribeDBClusterBacktracksOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBClusterBacktracksInput, func(*rds.DescribeDBClusterBacktracksOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBClusterBacktracksRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBClusterBacktracksRequest(_a0 *rds.DescribeDBClusterBacktracksInput) (*request.Request, *rds.DescribeDBClusterBacktracksOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClusterBacktracksInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBClusterBacktracksOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBClusterBacktracksInput) *rds.DescribeDBClusterBacktracksOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBClusterBacktracksOutput)
		}
	}

	return r0, r1
}

// DescribeDBClusterBacktracksWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBClusterBacktracksWithContext(_a0 context.Context, _a1 *rds.DescribeDBClusterBacktracksInput, _a2 ...request.Option) (*rds.DescribeDBClusterBacktracksOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBClusterBacktracksOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBClusterBacktracksInput, ...request.Option) *rds.DescribeDBClusterBacktracksOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBClusterBacktracksOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBClusterBacktracksInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBClusterEndpoints provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBClusterEndpoints(_a0 *rds.DescribeDBClusterEndpointsInput) (*rds.DescribeDBClusterEndpointsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBClusterEndpointsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClusterEndpointsInput) *rds.DescribeDBClusterEndpointsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBClusterEndpointsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBClusterEndpointsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBClusterEndpointsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeDBClusterEndpointsPages(_a0 *rds.DescribeDBClusterEndpointsInput, _a1 func(*rds.DescribeDBClusterEndpointsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClusterEndpointsInput, func(*rds.DescribeDBClusterEndpointsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBClusterEndpointsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeDBClusterEndpointsPagesWithContext(_a0 context.Context, _a1 *rds.DescribeDBClusterEndpointsInput, _a2 func(*rds.DescribeDBClusterEndpointsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBClusterEndpointsInput, func(*rds.DescribeDBClusterEndpointsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBClusterEndpointsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBClusterEndpointsRequest(_a0 *rds.DescribeDBClusterEndpointsInput) (*request.Request, *rds.DescribeDBClusterEndpointsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClusterEndpointsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBClusterEndpointsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBClusterEndpointsInput) *rds.DescribeDBClusterEndpointsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBClusterEndpointsOutput)
		}
	}

	return r0, r1
}

// DescribeDBClusterEndpointsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBClusterEndpointsWithContext(_a0 context.Context, _a1 *rds.DescribeDBClusterEndpointsInput, _a2 ...request.Option) (*rds.DescribeDBClusterEndpointsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBClusterEndpointsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBClusterEndpointsInput, ...request.Option) *rds.DescribeDBClusterEndpointsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBClusterEndpointsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBClusterEndpointsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBClusterParameterGroups provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBClusterParameterGroups(_a0 *rds.DescribeDBClusterParameterGroupsInput) (*rds.DescribeDBClusterParameterGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBClusterParameterGroupsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClusterParameterGroupsInput) *rds.DescribeDBClusterParameterGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBClusterParameterGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBClusterParameterGroupsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBClusterParameterGroupsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeDBClusterParameterGroupsPages(_a0 *rds.DescribeDBClusterParameterGroupsInput, _a1 func(*rds.DescribeDBClusterParameterGroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClusterParameterGroupsInput, func(*rds.DescribeDBClusterParameterGroupsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBClusterParameterGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeDBClusterParameterGroupsPagesWithContext(_a0 context.Context, _a1 *rds.DescribeDBClusterParameterGroupsInput, _a2 func(*rds.DescribeDBClusterParameterGroupsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBClusterParameterGroupsInput, func(*rds.DescribeDBClusterParameterGroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBClusterParameterGroupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBClusterParameterGroupsRequest(_a0 *rds.DescribeDBClusterParameterGroupsInput) (*request.Request, *rds.DescribeDBClusterParameterGroupsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClusterParameterGroupsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBClusterParameterGroupsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBClusterParameterGroupsInput) *rds.DescribeDBClusterParameterGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBClusterParameterGroupsOutput)
		}
	}

	return r0, r1
}

// DescribeDBClusterParameterGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBClusterParameterGroupsWithContext(_a0 context.Context, _a1 *rds.DescribeDBClusterParameterGroupsInput, _a2 ...request.Option) (*rds.DescribeDBClusterParameterGroupsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBClusterParameterGroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBClusterParameterGroupsInput, ...request.Option) *rds.DescribeDBClusterParameterGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBClusterParameterGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBClusterParameterGroupsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBClusterParameters provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBClusterParameters(_a0 *rds.DescribeDBClusterParametersInput) (*rds.DescribeDBClusterParametersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBClusterParametersOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClusterParametersInput) *rds.DescribeDBClusterParametersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBClusterParametersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBClusterParametersInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBClusterParametersPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeDBClusterParametersPages(_a0 *rds.DescribeDBClusterParametersInput, _a1 func(*rds.DescribeDBClusterParametersOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClusterParametersInput, func(*rds.DescribeDBClusterParametersOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBClusterParametersPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeDBClusterParametersPagesWithContext(_a0 context.Context, _a1 *rds.DescribeDBClusterParametersInput, _a2 func(*rds.DescribeDBClusterParametersOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBClusterParametersInput, func(*rds.DescribeDBClusterParametersOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBClusterParametersRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBClusterParametersRequest(_a0 *rds.DescribeDBClusterParametersInput) (*request.Request, *rds.DescribeDBClusterParametersOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClusterParametersInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBClusterParametersOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBClusterParametersInput) *rds.DescribeDBClusterParametersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBClusterParametersOutput)
		}
	}

	return r0, r1
}

// DescribeDBClusterParametersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBClusterParametersWithContext(_a0 context.Context, _a1 *rds.DescribeDBClusterParametersInput, _a2 ...request.Option) (*rds.DescribeDBClusterParametersOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBClusterParametersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBClusterParametersInput, ...request.Option) *rds.DescribeDBClusterParametersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBClusterParametersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBClusterParametersInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBClusterSnapshotAttributes provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBClusterSnapshotAttributes(_a0 *rds.DescribeDBClusterSnapshotAttributesInput) (*rds.DescribeDBClusterSnapshotAttributesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBClusterSnapshotAttributesOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClusterSnapshotAttributesInput) *rds.DescribeDBClusterSnapshotAttributesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBClusterSnapshotAttributesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBClusterSnapshotAttributesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBClusterSnapshotAttributesRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBClusterSnapshotAttributesRequest(_a0 *rds.DescribeDBClusterSnapshotAttributesInput) (*request.Request, *rds.DescribeDBClusterSnapshotAttributesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClusterSnapshotAttributesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBClusterSnapshotAttributesOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBClusterSnapshotAttributesInput) *rds.DescribeDBClusterSnapshotAttributesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBClusterSnapshotAttributesOutput)
		}
	}

	return r0, r1
}

// DescribeDBClusterSnapshotAttributesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBClusterSnapshotAttributesWithContext(_a0 context.Context, _a1 *rds.DescribeDBClusterSnapshotAttributesInput, _a2 ...request.Option) (*rds.DescribeDBClusterSnapshotAttributesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBClusterSnapshotAttributesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBClusterSnapshotAttributesInput, ...request.Option) *rds.DescribeDBClusterSnapshotAttributesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBClusterSnapshotAttributesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBClusterSnapshotAttributesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBClusterSnapshots provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBClusterSnapshots(_a0 *rds.DescribeDBClusterSnapshotsInput) (*rds.DescribeDBClusterSnapshotsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBClusterSnapshotsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClusterSnapshotsInput) *rds.DescribeDBClusterSnapshotsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBClusterSnapshotsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBClusterSnapshotsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBClusterSnapshotsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeDBClusterSnapshotsPages(_a0 *rds.DescribeDBClusterSnapshotsInput, _a1 func(*rds.DescribeDBClusterSnapshotsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClusterSnapshotsInput, func(*rds.DescribeDBClusterSnapshotsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBClusterSnapshotsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeDBClusterSnapshotsPagesWithContext(_a0 context.Context, _a1 *rds.DescribeDBClusterSnapshotsInput, _a2 func(*rds.DescribeDBClusterSnapshotsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBClusterSnapshotsInput, func(*rds.DescribeDBClusterSnapshotsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBClusterSnapshotsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBClusterSnapshotsRequest(_a0 *rds.DescribeDBClusterSnapshotsInput) (*request.Request, *rds.DescribeDBClusterSnapshotsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClusterSnapshotsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBClusterSnapshotsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBClusterSnapshotsInput) *rds.DescribeDBClusterSnapshotsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBClusterSnapshotsOutput)
		}
	}

	return r0, r1
}

// DescribeDBClusterSnapshotsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBClusterSnapshotsWithContext(_a0 context.Context, _a1 *rds.DescribeDBClusterSnapshotsInput, _a2 ...request.Option) (*rds.DescribeDBClusterSnapshotsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBClusterSnapshotsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBClusterSnapshotsInput, ...request.Option) *rds.DescribeDBClusterSnapshotsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBClusterSnapshotsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBClusterSnapshotsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBClusters provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBClusters(_a0 *rds.DescribeDBClustersInput) (*rds.DescribeDBClustersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBClustersOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClustersInput) *rds.DescribeDBClustersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBClustersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBClustersInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBClustersPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeDBClustersPages(_a0 *rds.DescribeDBClustersInput, _a1 func(*rds.DescribeDBClustersOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClustersInput, func(*rds.DescribeDBClustersOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBClustersPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeDBClustersPagesWithContext(_a0 context.Context, _a1 *rds.DescribeDBClustersInput, _a2 func(*rds.DescribeDBClustersOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBClustersInput, func(*rds.DescribeDBClustersOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBClustersRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBClustersRequest(_a0 *rds.DescribeDBClustersInput) (*request.Request, *rds.DescribeDBClustersOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClustersInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBClustersOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBClustersInput) *rds.DescribeDBClustersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBClustersOutput)
		}
	}

	return r0, r1
}

// DescribeDBClustersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBClustersWithContext(_a0 context.Context, _a1 *rds.DescribeDBClustersInput, _a2 ...request.Option) (*rds.DescribeDBClustersOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBClustersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBClustersInput, ...request.Option) *rds.DescribeDBClustersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBClustersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBClustersInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBEngineVersions provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBEngineVersions(_a0 *rds.DescribeDBEngineVersionsInput) (*rds.DescribeDBEngineVersionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBEngineVersionsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBEngineVersionsInput) *rds.DescribeDBEngineVersionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBEngineVersionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBEngineVersionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBEngineVersionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeDBEngineVersionsPages(_a0 *rds.DescribeDBEngineVersionsInput, _a1 func(*rds.DescribeDBEngineVersionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBEngineVersionsInput, func(*rds.DescribeDBEngineVersionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBEngineVersionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeDBEngineVersionsPagesWithContext(_a0 context.Context, _a1 *rds.DescribeDBEngineVersionsInput, _a2 func(*rds.DescribeDBEngineVersionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBEngineVersionsInput, func(*rds.DescribeDBEngineVersionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBEngineVersionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBEngineVersionsRequest(_a0 *rds.DescribeDBEngineVersionsInput) (*request.Request, *rds.DescribeDBEngineVersionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBEngineVersionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBEngineVersionsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBEngineVersionsInput) *rds.DescribeDBEngineVersionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBEngineVersionsOutput)
		}
	}

	return r0, r1
}

// DescribeDBEngineVersionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBEngineVersionsWithContext(_a0 context.Context, _a1 *rds.DescribeDBEngineVersionsInput, _a2 ...request.Option) (*rds.DescribeDBEngineVersionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBEngineVersionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBEngineVersionsInput, ...request.Option) *rds.DescribeDBEngineVersionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBEngineVersionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBEngineVersionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBInstanceAutomatedBackups provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBInstanceAutomatedBackups(_a0 *rds.DescribeDBInstanceAutomatedBackupsInput) (*rds.DescribeDBInstanceAutomatedBackupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBInstanceAutomatedBackupsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBInstanceAutomatedBackupsInput) *rds.DescribeDBInstanceAutomatedBackupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBInstanceAutomatedBackupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBInstanceAutomatedBackupsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBInstanceAutomatedBackupsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeDBInstanceAutomatedBackupsPages(_a0 *rds.DescribeDBInstanceAutomatedBackupsInput, _a1 func(*rds.DescribeDBInstanceAutomatedBackupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBInstanceAutomatedBackupsInput, func(*rds.DescribeDBInstanceAutomatedBackupsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBInstanceAutomatedBackupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeDBInstanceAutomatedBackupsPagesWithContext(_a0 context.Context, _a1 *rds.DescribeDBInstanceAutomatedBackupsInput, _a2 func(*rds.DescribeDBInstanceAutomatedBackupsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBInstanceAutomatedBackupsInput, func(*rds.DescribeDBInstanceAutomatedBackupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBInstanceAutomatedBackupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBInstanceAutomatedBackupsRequest(_a0 *rds.DescribeDBInstanceAutomatedBackupsInput) (*request.Request, *rds.DescribeDBInstanceAutomatedBackupsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBInstanceAutomatedBackupsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBInstanceAutomatedBackupsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBInstanceAutomatedBackupsInput) *rds.DescribeDBInstanceAutomatedBackupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBInstanceAutomatedBackupsOutput)
		}
	}

	return r0, r1
}

// DescribeDBInstanceAutomatedBackupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBInstanceAutomatedBackupsWithContext(_a0 context.Context, _a1 *rds.DescribeDBInstanceAutomatedBackupsInput, _a2 ...request.Option) (*rds.DescribeDBInstanceAutomatedBackupsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBInstanceAutomatedBackupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBInstanceAutomatedBackupsInput, ...request.Option) *rds.DescribeDBInstanceAutomatedBackupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBInstanceAutomatedBackupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBInstanceAutomatedBackupsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBInstances provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBInstances(_a0 *rds.DescribeDBInstancesInput) (*rds.DescribeDBInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBInstancesOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBInstancesInput) *rds.DescribeDBInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBInstancesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBInstancesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeDBInstancesPages(_a0 *rds.DescribeDBInstancesInput, _a1 func(*rds.DescribeDBInstancesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBInstancesInput, func(*rds.DescribeDBInstancesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBInstancesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeDBInstancesPagesWithContext(_a0 context.Context, _a1 *rds.DescribeDBInstancesInput, _a2 func(*rds.DescribeDBInstancesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBInstancesInput, func(*rds.DescribeDBInstancesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBInstancesRequest(_a0 *rds.DescribeDBInstancesInput) (*request.Request, *rds.DescribeDBInstancesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBInstancesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBInstancesOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBInstancesInput) *rds.DescribeDBInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBInstancesOutput)
		}
	}

	return r0, r1
}

// DescribeDBInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBInstancesWithContext(_a0 context.Context, _a1 *rds.DescribeDBInstancesInput, _a2 ...request.Option) (*rds.DescribeDBInstancesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBInstancesInput, ...request.Option) *rds.DescribeDBInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBInstancesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBLogFiles provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBLogFiles(_a0 *rds.DescribeDBLogFilesInput) (*rds.DescribeDBLogFilesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBLogFilesOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBLogFilesInput) *rds.DescribeDBLogFilesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBLogFilesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBLogFilesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBLogFilesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeDBLogFilesPages(_a0 *rds.DescribeDBLogFilesInput, _a1 func(*rds.DescribeDBLogFilesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBLogFilesInput, func(*rds.DescribeDBLogFilesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBLogFilesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeDBLogFilesPagesWithContext(_a0 context.Context, _a1 *rds.DescribeDBLogFilesInput, _a2 func(*rds.DescribeDBLogFilesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBLogFilesInput, func(*rds.DescribeDBLogFilesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBLogFilesRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBLogFilesRequest(_a0 *rds.DescribeDBLogFilesInput) (*request.Request, *rds.DescribeDBLogFilesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBLogFilesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBLogFilesOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBLogFilesInput) *rds.DescribeDBLogFilesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBLogFilesOutput)
		}
	}

	return r0, r1
}

// DescribeDBLogFilesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBLogFilesWithContext(_a0 context.Context, _a1 *rds.DescribeDBLogFilesInput, _a2 ...request.Option) (*rds.DescribeDBLogFilesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBLogFilesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBLogFilesInput, ...request.Option) *rds.DescribeDBLogFilesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBLogFilesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBLogFilesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBParameterGroups provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBParameterGroups(_a0 *rds.DescribeDBParameterGroupsInput) (*rds.DescribeDBParameterGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBParameterGroupsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBParameterGroupsInput) *rds.DescribeDBParameterGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBParameterGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBParameterGroupsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBParameterGroupsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeDBParameterGroupsPages(_a0 *rds.DescribeDBParameterGroupsInput, _a1 func(*rds.DescribeDBParameterGroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBParameterGroupsInput, func(*rds.DescribeDBParameterGroupsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBParameterGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeDBParameterGroupsPagesWithContext(_a0 context.Context, _a1 *rds.DescribeDBParameterGroupsInput, _a2 func(*rds.DescribeDBParameterGroupsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBParameterGroupsInput, func(*rds.DescribeDBParameterGroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBParameterGroupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBParameterGroupsRequest(_a0 *rds.DescribeDBParameterGroupsInput) (*request.Request, *rds.DescribeDBParameterGroupsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBParameterGroupsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBParameterGroupsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBParameterGroupsInput) *rds.DescribeDBParameterGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBParameterGroupsOutput)
		}
	}

	return r0, r1
}

// DescribeDBParameterGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBParameterGroupsWithContext(_a0 context.Context, _a1 *rds.DescribeDBParameterGroupsInput, _a2 ...request.Option) (*rds.DescribeDBParameterGroupsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBParameterGroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBParameterGroupsInput, ...request.Option) *rds.DescribeDBParameterGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBParameterGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBParameterGroupsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBParameters provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBParameters(_a0 *rds.DescribeDBParametersInput) (*rds.DescribeDBParametersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBParametersOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBParametersInput) *rds.DescribeDBParametersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBParametersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBParametersInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBParametersPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeDBParametersPages(_a0 *rds.DescribeDBParametersInput, _a1 func(*rds.DescribeDBParametersOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBParametersInput, func(*rds.DescribeDBParametersOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBParametersPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeDBParametersPagesWithContext(_a0 context.Context, _a1 *rds.DescribeDBParametersInput, _a2 func(*rds.DescribeDBParametersOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBParametersInput, func(*rds.DescribeDBParametersOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBParametersRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBParametersRequest(_a0 *rds.DescribeDBParametersInput) (*request.Request, *rds.DescribeDBParametersOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBParametersInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBParametersOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBParametersInput) *rds.DescribeDBParametersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBParametersOutput)
		}
	}

	return r0, r1
}

// DescribeDBParametersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBParametersWithContext(_a0 context.Context, _a1 *rds.DescribeDBParametersInput, _a2 ...request.Option) (*rds.DescribeDBParametersOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBParametersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBParametersInput, ...request.Option) *rds.DescribeDBParametersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBParametersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBParametersInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBProxies provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBProxies(_a0 *rds.DescribeDBProxiesInput) (*rds.DescribeDBProxiesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBProxiesOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBProxiesInput) *rds.DescribeDBProxiesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBProxiesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBProxiesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBProxiesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeDBProxiesPages(_a0 *rds.DescribeDBProxiesInput, _a1 func(*rds.DescribeDBProxiesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBProxiesInput, func(*rds.DescribeDBProxiesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBProxiesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeDBProxiesPagesWithContext(_a0 context.Context, _a1 *rds.DescribeDBProxiesInput, _a2 func(*rds.DescribeDBProxiesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBProxiesInput, func(*rds.DescribeDBProxiesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBProxiesRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBProxiesRequest(_a0 *rds.DescribeDBProxiesInput) (*request.Request, *rds.DescribeDBProxiesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBProxiesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBProxiesOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBProxiesInput) *rds.DescribeDBProxiesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBProxiesOutput)
		}
	}

	return r0, r1
}

// DescribeDBProxiesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBProxiesWithContext(_a0 context.Context, _a1 *rds.DescribeDBProxiesInput, _a2 ...request.Option) (*rds.DescribeDBProxiesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBProxiesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBProxiesInput, ...request.Option) *rds.DescribeDBProxiesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBProxiesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBProxiesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBProxyEndpoints provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBProxyEndpoints(_a0 *rds.DescribeDBProxyEndpointsInput) (*rds.DescribeDBProxyEndpointsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBProxyEndpointsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBProxyEndpointsInput) *rds.DescribeDBProxyEndpointsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBProxyEndpointsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBProxyEndpointsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBProxyEndpointsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeDBProxyEndpointsPages(_a0 *rds.DescribeDBProxyEndpointsInput, _a1 func(*rds.DescribeDBProxyEndpointsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBProxyEndpointsInput, func(*rds.DescribeDBProxyEndpointsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBProxyEndpointsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeDBProxyEndpointsPagesWithContext(_a0 context.Context, _a1 *rds.DescribeDBProxyEndpointsInput, _a2 func(*rds.DescribeDBProxyEndpointsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBProxyEndpointsInput, func(*rds.DescribeDBProxyEndpointsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBProxyEndpointsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBProxyEndpointsRequest(_a0 *rds.DescribeDBProxyEndpointsInput) (*request.Request, *rds.DescribeDBProxyEndpointsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBProxyEndpointsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBProxyEndpointsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBProxyEndpointsInput) *rds.DescribeDBProxyEndpointsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBProxyEndpointsOutput)
		}
	}

	return r0, r1
}

// DescribeDBProxyEndpointsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBProxyEndpointsWithContext(_a0 context.Context, _a1 *rds.DescribeDBProxyEndpointsInput, _a2 ...request.Option) (*rds.DescribeDBProxyEndpointsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBProxyEndpointsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBProxyEndpointsInput, ...request.Option) *rds.DescribeDBProxyEndpointsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBProxyEndpointsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBProxyEndpointsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBProxyTargetGroups provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBProxyTargetGroups(_a0 *rds.DescribeDBProxyTargetGroupsInput) (*rds.DescribeDBProxyTargetGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBProxyTargetGroupsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBProxyTargetGroupsInput) *rds.DescribeDBProxyTargetGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBProxyTargetGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBProxyTargetGroupsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBProxyTargetGroupsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeDBProxyTargetGroupsPages(_a0 *rds.DescribeDBProxyTargetGroupsInput, _a1 func(*rds.DescribeDBProxyTargetGroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBProxyTargetGroupsInput, func(*rds.DescribeDBProxyTargetGroupsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBProxyTargetGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeDBProxyTargetGroupsPagesWithContext(_a0 context.Context, _a1 *rds.DescribeDBProxyTargetGroupsInput, _a2 func(*rds.DescribeDBProxyTargetGroupsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBProxyTargetGroupsInput, func(*rds.DescribeDBProxyTargetGroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBProxyTargetGroupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBProxyTargetGroupsRequest(_a0 *rds.DescribeDBProxyTargetGroupsInput) (*request.Request, *rds.DescribeDBProxyTargetGroupsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBProxyTargetGroupsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBProxyTargetGroupsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBProxyTargetGroupsInput) *rds.DescribeDBProxyTargetGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBProxyTargetGroupsOutput)
		}
	}

	return r0, r1
}

// DescribeDBProxyTargetGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBProxyTargetGroupsWithContext(_a0 context.Context, _a1 *rds.DescribeDBProxyTargetGroupsInput, _a2 ...request.Option) (*rds.DescribeDBProxyTargetGroupsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBProxyTargetGroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBProxyTargetGroupsInput, ...request.Option) *rds.DescribeDBProxyTargetGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBProxyTargetGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBProxyTargetGroupsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBProxyTargets provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBProxyTargets(_a0 *rds.DescribeDBProxyTargetsInput) (*rds.DescribeDBProxyTargetsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBProxyTargetsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBProxyTargetsInput) *rds.DescribeDBProxyTargetsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBProxyTargetsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBProxyTargetsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBProxyTargetsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeDBProxyTargetsPages(_a0 *rds.DescribeDBProxyTargetsInput, _a1 func(*rds.DescribeDBProxyTargetsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBProxyTargetsInput, func(*rds.DescribeDBProxyTargetsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBProxyTargetsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeDBProxyTargetsPagesWithContext(_a0 context.Context, _a1 *rds.DescribeDBProxyTargetsInput, _a2 func(*rds.DescribeDBProxyTargetsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBProxyTargetsInput, func(*rds.DescribeDBProxyTargetsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBProxyTargetsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBProxyTargetsRequest(_a0 *rds.DescribeDBProxyTargetsInput) (*request.Request, *rds.DescribeDBProxyTargetsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBProxyTargetsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBProxyTargetsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBProxyTargetsInput) *rds.DescribeDBProxyTargetsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBProxyTargetsOutput)
		}
	}

	return r0, r1
}

// DescribeDBProxyTargetsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBProxyTargetsWithContext(_a0 context.Context, _a1 *rds.DescribeDBProxyTargetsInput, _a2 ...request.Option) (*rds.DescribeDBProxyTargetsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBProxyTargetsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBProxyTargetsInput, ...request.Option) *rds.DescribeDBProxyTargetsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBProxyTargetsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBProxyTargetsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBSecurityGroups provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBSecurityGroups(_a0 *rds.DescribeDBSecurityGroupsInput) (*rds.DescribeDBSecurityGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBSecurityGroupsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBSecurityGroupsInput) *rds.DescribeDBSecurityGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBSecurityGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBSecurityGroupsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBSecurityGroupsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeDBSecurityGroupsPages(_a0 *rds.DescribeDBSecurityGroupsInput, _a1 func(*rds.DescribeDBSecurityGroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBSecurityGroupsInput, func(*rds.DescribeDBSecurityGroupsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBSecurityGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeDBSecurityGroupsPagesWithContext(_a0 context.Context, _a1 *rds.DescribeDBSecurityGroupsInput, _a2 func(*rds.DescribeDBSecurityGroupsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBSecurityGroupsInput, func(*rds.DescribeDBSecurityGroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBSecurityGroupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBSecurityGroupsRequest(_a0 *rds.DescribeDBSecurityGroupsInput) (*request.Request, *rds.DescribeDBSecurityGroupsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBSecurityGroupsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBSecurityGroupsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBSecurityGroupsInput) *rds.DescribeDBSecurityGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBSecurityGroupsOutput)
		}
	}

	return r0, r1
}

// DescribeDBSecurityGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBSecurityGroupsWithContext(_a0 context.Context, _a1 *rds.DescribeDBSecurityGroupsInput, _a2 ...request.Option) (*rds.DescribeDBSecurityGroupsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBSecurityGroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBSecurityGroupsInput, ...request.Option) *rds.DescribeDBSecurityGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBSecurityGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBSecurityGroupsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBSnapshotAttributes provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBSnapshotAttributes(_a0 *rds.DescribeDBSnapshotAttributesInput) (*rds.DescribeDBSnapshotAttributesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBSnapshotAttributesOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBSnapshotAttributesInput) *rds.DescribeDBSnapshotAttributesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBSnapshotAttributesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBSnapshotAttributesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBSnapshotAttributesRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBSnapshotAttributesRequest(_a0 *rds.DescribeDBSnapshotAttributesInput) (*request.Request, *rds.DescribeDBSnapshotAttributesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBSnapshotAttributesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBSnapshotAttributesOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBSnapshotAttributesInput) *rds.DescribeDBSnapshotAttributesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBSnapshotAttributesOutput)
		}
	}

	return r0, r1
}

// DescribeDBSnapshotAttributesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBSnapshotAttributesWithContext(_a0 context.Context, _a1 *rds.DescribeDBSnapshotAttributesInput, _a2 ...request.Option) (*rds.DescribeDBSnapshotAttributesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBSnapshotAttributesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBSnapshotAttributesInput, ...request.Option) *rds.DescribeDBSnapshotAttributesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBSnapshotAttributesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBSnapshotAttributesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBSnapshots provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBSnapshots(_a0 *rds.DescribeDBSnapshotsInput) (*rds.DescribeDBSnapshotsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBSnapshotsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBSnapshotsInput) *rds.DescribeDBSnapshotsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBSnapshotsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBSnapshotsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBSnapshotsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeDBSnapshotsPages(_a0 *rds.DescribeDBSnapshotsInput, _a1 func(*rds.DescribeDBSnapshotsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBSnapshotsInput, func(*rds.DescribeDBSnapshotsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBSnapshotsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeDBSnapshotsPagesWithContext(_a0 context.Context, _a1 *rds.DescribeDBSnapshotsInput, _a2 func(*rds.DescribeDBSnapshotsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBSnapshotsInput, func(*rds.DescribeDBSnapshotsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBSnapshotsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBSnapshotsRequest(_a0 *rds.DescribeDBSnapshotsInput) (*request.Request, *rds.DescribeDBSnapshotsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBSnapshotsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBSnapshotsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBSnapshotsInput) *rds.DescribeDBSnapshotsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBSnapshotsOutput)
		}
	}

	return r0, r1
}

// DescribeDBSnapshotsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBSnapshotsWithContext(_a0 context.Context, _a1 *rds.DescribeDBSnapshotsInput, _a2 ...request.Option) (*rds.DescribeDBSnapshotsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBSnapshotsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBSnapshotsInput, ...request.Option) *rds.DescribeDBSnapshotsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBSnapshotsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBSnapshotsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBSubnetGroups provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBSubnetGroups(_a0 *rds.DescribeDBSubnetGroupsInput) (*rds.DescribeDBSubnetGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeDBSubnetGroupsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBSubnetGroupsInput) *rds.DescribeDBSubnetGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBSubnetGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBSubnetGroupsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeDBSubnetGroupsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeDBSubnetGroupsPages(_a0 *rds.DescribeDBSubnetGroupsInput, _a1 func(*rds.DescribeDBSubnetGroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBSubnetGroupsInput, func(*rds.DescribeDBSubnetGroupsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBSubnetGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeDBSubnetGroupsPagesWithContext(_a0 context.Context, _a1 *rds.DescribeDBSubnetGroupsInput, _a2 func(*rds.DescribeDBSubnetGroupsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBSubnetGroupsInput, func(*rds.DescribeDBSubnetGroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeDBSubnetGroupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeDBSubnetGroupsRequest(_a0 *rds.DescribeDBSubnetGroupsInput) (*request.Request, *rds.DescribeDBSubnetGroupsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBSubnetGroupsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeDBSubnetGroupsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeDBSubnetGroupsInput) *rds.DescribeDBSubnetGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeDBSubnetGroupsOutput)
		}
	}

	return r0, r1
}

// DescribeDBSubnetGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeDBSubnetGroupsWithContext(_a0 context.Context, _a1 *rds.DescribeDBSubnetGroupsInput, _a2 ...request.Option) (*rds.DescribeDBSubnetGroupsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeDBSubnetGroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBSubnetGroupsInput, ...request.Option) *rds.DescribeDBSubnetGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeDBSubnetGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeDBSubnetGroupsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeEngineDefaultClusterParameters provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeEngineDefaultClusterParameters(_a0 *rds.DescribeEngineDefaultClusterParametersInput) (*rds.DescribeEngineDefaultClusterParametersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeEngineDefaultClusterParametersOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeEngineDefaultClusterParametersInput) *rds.DescribeEngineDefaultClusterParametersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeEngineDefaultClusterParametersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeEngineDefaultClusterParametersInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeEngineDefaultClusterParametersRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeEngineDefaultClusterParametersRequest(_a0 *rds.DescribeEngineDefaultClusterParametersInput) (*request.Request, *rds.DescribeEngineDefaultClusterParametersOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeEngineDefaultClusterParametersInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeEngineDefaultClusterParametersOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeEngineDefaultClusterParametersInput) *rds.DescribeEngineDefaultClusterParametersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeEngineDefaultClusterParametersOutput)
		}
	}

	return r0, r1
}

// DescribeEngineDefaultClusterParametersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeEngineDefaultClusterParametersWithContext(_a0 context.Context, _a1 *rds.DescribeEngineDefaultClusterParametersInput, _a2 ...request.Option) (*rds.DescribeEngineDefaultClusterParametersOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeEngineDefaultClusterParametersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeEngineDefaultClusterParametersInput, ...request.Option) *rds.DescribeEngineDefaultClusterParametersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeEngineDefaultClusterParametersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeEngineDefaultClusterParametersInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeEngineDefaultParameters provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeEngineDefaultParameters(_a0 *rds.DescribeEngineDefaultParametersInput) (*rds.DescribeEngineDefaultParametersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeEngineDefaultParametersOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeEngineDefaultParametersInput) *rds.DescribeEngineDefaultParametersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeEngineDefaultParametersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeEngineDefaultParametersInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeEngineDefaultParametersPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeEngineDefaultParametersPages(_a0 *rds.DescribeEngineDefaultParametersInput, _a1 func(*rds.DescribeEngineDefaultParametersOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeEngineDefaultParametersInput, func(*rds.DescribeEngineDefaultParametersOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeEngineDefaultParametersPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeEngineDefaultParametersPagesWithContext(_a0 context.Context, _a1 *rds.DescribeEngineDefaultParametersInput, _a2 func(*rds.DescribeEngineDefaultParametersOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeEngineDefaultParametersInput, func(*rds.DescribeEngineDefaultParametersOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeEngineDefaultParametersRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeEngineDefaultParametersRequest(_a0 *rds.DescribeEngineDefaultParametersInput) (*request.Request, *rds.DescribeEngineDefaultParametersOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeEngineDefaultParametersInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeEngineDefaultParametersOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeEngineDefaultParametersInput) *rds.DescribeEngineDefaultParametersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeEngineDefaultParametersOutput)
		}
	}

	return r0, r1
}

// DescribeEngineDefaultParametersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeEngineDefaultParametersWithContext(_a0 context.Context, _a1 *rds.DescribeEngineDefaultParametersInput, _a2 ...request.Option) (*rds.DescribeEngineDefaultParametersOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeEngineDefaultParametersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeEngineDefaultParametersInput, ...request.Option) *rds.DescribeEngineDefaultParametersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeEngineDefaultParametersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeEngineDefaultParametersInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeEventCategories provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeEventCategories(_a0 *rds.DescribeEventCategoriesInput) (*rds.DescribeEventCategoriesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeEventCategoriesOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeEventCategoriesInput) *rds.DescribeEventCategoriesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeEventCategoriesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeEventCategoriesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeEventCategoriesRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeEventCategoriesRequest(_a0 *rds.DescribeEventCategoriesInput) (*request.Request, *rds.DescribeEventCategoriesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeEventCategoriesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeEventCategoriesOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeEventCategoriesInput) *rds.DescribeEventCategoriesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeEventCategoriesOutput)
		}
	}

	return r0, r1
}

// DescribeEventCategoriesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeEventCategoriesWithContext(_a0 context.Context, _a1 *rds.DescribeEventCategoriesInput, _a2 ...request.Option) (*rds.DescribeEventCategoriesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeEventCategoriesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeEventCategoriesInput, ...request.Option) *rds.DescribeEventCategoriesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeEventCategoriesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeEventCategoriesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeEventSubscriptions provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeEventSubscriptions(_a0 *rds.DescribeEventSubscriptionsInput) (*rds.DescribeEventSubscriptionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeEventSubscriptionsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeEventSubscriptionsInput) *rds.DescribeEventSubscriptionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeEventSubscriptionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeEventSubscriptionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeEventSubscriptionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeEventSubscriptionsPages(_a0 *rds.DescribeEventSubscriptionsInput, _a1 func(*rds.DescribeEventSubscriptionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeEventSubscriptionsInput, func(*rds.DescribeEventSubscriptionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeEventSubscriptionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeEventSubscriptionsPagesWithContext(_a0 context.Context, _a1 *rds.DescribeEventSubscriptionsInput, _a2 func(*rds.DescribeEventSubscriptionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeEventSubscriptionsInput, func(*rds.DescribeEventSubscriptionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeEventSubscriptionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeEventSubscriptionsRequest(_a0 *rds.DescribeEventSubscriptionsInput) (*request.Request, *rds.DescribeEventSubscriptionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeEventSubscriptionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeEventSubscriptionsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeEventSubscriptionsInput) *rds.DescribeEventSubscriptionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeEventSubscriptionsOutput)
		}
	}

	return r0, r1
}

// DescribeEventSubscriptionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeEventSubscriptionsWithContext(_a0 context.Context, _a1 *rds.DescribeEventSubscriptionsInput, _a2 ...request.Option) (*rds.DescribeEventSubscriptionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeEventSubscriptionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeEventSubscriptionsInput, ...request.Option) *rds.DescribeEventSubscriptionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeEventSubscriptionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeEventSubscriptionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeEvents provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeEvents(_a0 *rds.DescribeEventsInput) (*rds.DescribeEventsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeEventsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeEventsInput) *rds.DescribeEventsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeEventsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeEventsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeEventsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeEventsPages(_a0 *rds.DescribeEventsInput, _a1 func(*rds.DescribeEventsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeEventsInput, func(*rds.DescribeEventsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeEventsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeEventsPagesWithContext(_a0 context.Context, _a1 *rds.DescribeEventsInput, _a2 func(*rds.DescribeEventsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeEventsInput, func(*rds.DescribeEventsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeEventsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeEventsRequest(_a0 *rds.DescribeEventsInput) (*request.Request, *rds.DescribeEventsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeEventsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeEventsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeEventsInput) *rds.DescribeEventsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeEventsOutput)
		}
	}

	return r0, r1
}

// DescribeEventsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeEventsWithContext(_a0 context.Context, _a1 *rds.DescribeEventsInput, _a2 ...request.Option) (*rds.DescribeEventsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeEventsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeEventsInput, ...request.Option) *rds.DescribeEventsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeEventsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeEventsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeExportTasks provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeExportTasks(_a0 *rds.DescribeExportTasksInput) (*rds.DescribeExportTasksOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeExportTasksOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeExportTasksInput) *rds.DescribeExportTasksOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeExportTasksOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeExportTasksInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeExportTasksPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeExportTasksPages(_a0 *rds.DescribeExportTasksInput, _a1 func(*rds.DescribeExportTasksOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeExportTasksInput, func(*rds.DescribeExportTasksOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeExportTasksPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeExportTasksPagesWithContext(_a0 context.Context, _a1 *rds.DescribeExportTasksInput, _a2 func(*rds.DescribeExportTasksOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeExportTasksInput, func(*rds.DescribeExportTasksOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeExportTasksRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeExportTasksRequest(_a0 *rds.DescribeExportTasksInput) (*request.Request, *rds.DescribeExportTasksOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeExportTasksInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeExportTasksOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeExportTasksInput) *rds.DescribeExportTasksOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeExportTasksOutput)
		}
	}

	return r0, r1
}

// DescribeExportTasksWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeExportTasksWithContext(_a0 context.Context, _a1 *rds.DescribeExportTasksInput, _a2 ...request.Option) (*rds.DescribeExportTasksOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeExportTasksOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeExportTasksInput, ...request.Option) *rds.DescribeExportTasksOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeExportTasksOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeExportTasksInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeGlobalClusters provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeGlobalClusters(_a0 *rds.DescribeGlobalClustersInput) (*rds.DescribeGlobalClustersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeGlobalClustersOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeGlobalClustersInput) *rds.DescribeGlobalClustersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeGlobalClustersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeGlobalClustersInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeGlobalClustersPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeGlobalClustersPages(_a0 *rds.DescribeGlobalClustersInput, _a1 func(*rds.DescribeGlobalClustersOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeGlobalClustersInput, func(*rds.DescribeGlobalClustersOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeGlobalClustersPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeGlobalClustersPagesWithContext(_a0 context.Context, _a1 *rds.DescribeGlobalClustersInput, _a2 func(*rds.DescribeGlobalClustersOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeGlobalClustersInput, func(*rds.DescribeGlobalClustersOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeGlobalClustersRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeGlobalClustersRequest(_a0 *rds.DescribeGlobalClustersInput) (*request.Request, *rds.DescribeGlobalClustersOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeGlobalClustersInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeGlobalClustersOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeGlobalClustersInput) *rds.DescribeGlobalClustersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeGlobalClustersOutput)
		}
	}

	return r0, r1
}

// DescribeGlobalClustersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeGlobalClustersWithContext(_a0 context.Context, _a1 *rds.DescribeGlobalClustersInput, _a2 ...request.Option) (*rds.DescribeGlobalClustersOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeGlobalClustersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeGlobalClustersInput, ...request.Option) *rds.DescribeGlobalClustersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeGlobalClustersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeGlobalClustersInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeInstallationMedia provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeInstallationMedia(_a0 *rds.DescribeInstallationMediaInput) (*rds.DescribeInstallationMediaOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeInstallationMediaOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeInstallationMediaInput) *rds.DescribeInstallationMediaOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeInstallationMediaOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeInstallationMediaInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeInstallationMediaPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeInstallationMediaPages(_a0 *rds.DescribeInstallationMediaInput, _a1 func(*rds.DescribeInstallationMediaOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeInstallationMediaInput, func(*rds.DescribeInstallationMediaOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeInstallationMediaPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeInstallationMediaPagesWithContext(_a0 context.Context, _a1 *rds.DescribeInstallationMediaInput, _a2 func(*rds.DescribeInstallationMediaOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeInstallationMediaInput, func(*rds.DescribeInstallationMediaOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeInstallationMediaRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeInstallationMediaRequest(_a0 *rds.DescribeInstallationMediaInput) (*request.Request, *rds.DescribeInstallationMediaOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeInstallationMediaInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeInstallationMediaOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeInstallationMediaInput) *rds.DescribeInstallationMediaOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeInstallationMediaOutput)
		}
	}

	return r0, r1
}

// DescribeInstallationMediaWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeInstallationMediaWithContext(_a0 context.Context, _a1 *rds.DescribeInstallationMediaInput, _a2 ...request.Option) (*rds.DescribeInstallationMediaOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeInstallationMediaOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeInstallationMediaInput, ...request.Option) *rds.DescribeInstallationMediaOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeInstallationMediaOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeInstallationMediaInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeOptionGroupOptions provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeOptionGroupOptions(_a0 *rds.DescribeOptionGroupOptionsInput) (*rds.DescribeOptionGroupOptionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeOptionGroupOptionsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeOptionGroupOptionsInput) *rds.DescribeOptionGroupOptionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeOptionGroupOptionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeOptionGroupOptionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeOptionGroupOptionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeOptionGroupOptionsPages(_a0 *rds.DescribeOptionGroupOptionsInput, _a1 func(*rds.DescribeOptionGroupOptionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeOptionGroupOptionsInput, func(*rds.DescribeOptionGroupOptionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeOptionGroupOptionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeOptionGroupOptionsPagesWithContext(_a0 context.Context, _a1 *rds.DescribeOptionGroupOptionsInput, _a2 func(*rds.DescribeOptionGroupOptionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeOptionGroupOptionsInput, func(*rds.DescribeOptionGroupOptionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeOptionGroupOptionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeOptionGroupOptionsRequest(_a0 *rds.DescribeOptionGroupOptionsInput) (*request.Request, *rds.DescribeOptionGroupOptionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeOptionGroupOptionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeOptionGroupOptionsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeOptionGroupOptionsInput) *rds.DescribeOptionGroupOptionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeOptionGroupOptionsOutput)
		}
	}

	return r0, r1
}

// DescribeOptionGroupOptionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeOptionGroupOptionsWithContext(_a0 context.Context, _a1 *rds.DescribeOptionGroupOptionsInput, _a2 ...request.Option) (*rds.DescribeOptionGroupOptionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeOptionGroupOptionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeOptionGroupOptionsInput, ...request.Option) *rds.DescribeOptionGroupOptionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeOptionGroupOptionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeOptionGroupOptionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeOptionGroups provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeOptionGroups(_a0 *rds.DescribeOptionGroupsInput) (*rds.DescribeOptionGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeOptionGroupsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeOptionGroupsInput) *rds.DescribeOptionGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeOptionGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeOptionGroupsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeOptionGroupsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeOptionGroupsPages(_a0 *rds.DescribeOptionGroupsInput, _a1 func(*rds.DescribeOptionGroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeOptionGroupsInput, func(*rds.DescribeOptionGroupsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeOptionGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeOptionGroupsPagesWithContext(_a0 context.Context, _a1 *rds.DescribeOptionGroupsInput, _a2 func(*rds.DescribeOptionGroupsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeOptionGroupsInput, func(*rds.DescribeOptionGroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeOptionGroupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeOptionGroupsRequest(_a0 *rds.DescribeOptionGroupsInput) (*request.Request, *rds.DescribeOptionGroupsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeOptionGroupsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeOptionGroupsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeOptionGroupsInput) *rds.DescribeOptionGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeOptionGroupsOutput)
		}
	}

	return r0, r1
}

// DescribeOptionGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeOptionGroupsWithContext(_a0 context.Context, _a1 *rds.DescribeOptionGroupsInput, _a2 ...request.Option) (*rds.DescribeOptionGroupsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeOptionGroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeOptionGroupsInput, ...request.Option) *rds.DescribeOptionGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeOptionGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeOptionGroupsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeOrderableDBInstanceOptions provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeOrderableDBInstanceOptions(_a0 *rds.DescribeOrderableDBInstanceOptionsInput) (*rds.DescribeOrderableDBInstanceOptionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeOrderableDBInstanceOptionsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeOrderableDBInstanceOptionsInput) *rds.DescribeOrderableDBInstanceOptionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeOrderableDBInstanceOptionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeOrderableDBInstanceOptionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeOrderableDBInstanceOptionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeOrderableDBInstanceOptionsPages(_a0 *rds.DescribeOrderableDBInstanceOptionsInput, _a1 func(*rds.DescribeOrderableDBInstanceOptionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeOrderableDBInstanceOptionsInput, func(*rds.DescribeOrderableDBInstanceOptionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeOrderableDBInstanceOptionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeOrderableDBInstanceOptionsPagesWithContext(_a0 context.Context, _a1 *rds.DescribeOrderableDBInstanceOptionsInput, _a2 func(*rds.DescribeOrderableDBInstanceOptionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeOrderableDBInstanceOptionsInput, func(*rds.DescribeOrderableDBInstanceOptionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeOrderableDBInstanceOptionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeOrderableDBInstanceOptionsRequest(_a0 *rds.DescribeOrderableDBInstanceOptionsInput) (*request.Request, *rds.DescribeOrderableDBInstanceOptionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeOrderableDBInstanceOptionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeOrderableDBInstanceOptionsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeOrderableDBInstanceOptionsInput) *rds.DescribeOrderableDBInstanceOptionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeOrderableDBInstanceOptionsOutput)
		}
	}

	return r0, r1
}

// DescribeOrderableDBInstanceOptionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeOrderableDBInstanceOptionsWithContext(_a0 context.Context, _a1 *rds.DescribeOrderableDBInstanceOptionsInput, _a2 ...request.Option) (*rds.DescribeOrderableDBInstanceOptionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeOrderableDBInstanceOptionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeOrderableDBInstanceOptionsInput, ...request.Option) *rds.DescribeOrderableDBInstanceOptionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeOrderableDBInstanceOptionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeOrderableDBInstanceOptionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribePendingMaintenanceActions provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribePendingMaintenanceActions(_a0 *rds.DescribePendingMaintenanceActionsInput) (*rds.DescribePendingMaintenanceActionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribePendingMaintenanceActionsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribePendingMaintenanceActionsInput) *rds.DescribePendingMaintenanceActionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribePendingMaintenanceActionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribePendingMaintenanceActionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribePendingMaintenanceActionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribePendingMaintenanceActionsPages(_a0 *rds.DescribePendingMaintenanceActionsInput, _a1 func(*rds.DescribePendingMaintenanceActionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribePendingMaintenanceActionsInput, func(*rds.DescribePendingMaintenanceActionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribePendingMaintenanceActionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribePendingMaintenanceActionsPagesWithContext(_a0 context.Context, _a1 *rds.DescribePendingMaintenanceActionsInput, _a2 func(*rds.DescribePendingMaintenanceActionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribePendingMaintenanceActionsInput, func(*rds.DescribePendingMaintenanceActionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribePendingMaintenanceActionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribePendingMaintenanceActionsRequest(_a0 *rds.DescribePendingMaintenanceActionsInput) (*request.Request, *rds.DescribePendingMaintenanceActionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribePendingMaintenanceActionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribePendingMaintenanceActionsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribePendingMaintenanceActionsInput) *rds.DescribePendingMaintenanceActionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribePendingMaintenanceActionsOutput)
		}
	}

	return r0, r1
}

// DescribePendingMaintenanceActionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribePendingMaintenanceActionsWithContext(_a0 context.Context, _a1 *rds.DescribePendingMaintenanceActionsInput, _a2 ...request.Option) (*rds.DescribePendingMaintenanceActionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribePendingMaintenanceActionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribePendingMaintenanceActionsInput, ...request.Option) *rds.DescribePendingMaintenanceActionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribePendingMaintenanceActionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribePendingMaintenanceActionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeReservedDBInstances provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeReservedDBInstances(_a0 *rds.DescribeReservedDBInstancesInput) (*rds.DescribeReservedDBInstancesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeReservedDBInstancesOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeReservedDBInstancesInput) *rds.DescribeReservedDBInstancesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeReservedDBInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeReservedDBInstancesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeReservedDBInstancesOfferings provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeReservedDBInstancesOfferings(_a0 *rds.DescribeReservedDBInstancesOfferingsInput) (*rds.DescribeReservedDBInstancesOfferingsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeReservedDBInstancesOfferingsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeReservedDBInstancesOfferingsInput) *rds.DescribeReservedDBInstancesOfferingsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeReservedDBInstancesOfferingsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeReservedDBInstancesOfferingsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeReservedDBInstancesOfferingsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeReservedDBInstancesOfferingsPages(_a0 *rds.DescribeReservedDBInstancesOfferingsInput, _a1 func(*rds.DescribeReservedDBInstancesOfferingsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeReservedDBInstancesOfferingsInput, func(*rds.DescribeReservedDBInstancesOfferingsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeReservedDBInstancesOfferingsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeReservedDBInstancesOfferingsPagesWithContext(_a0 context.Context, _a1 *rds.DescribeReservedDBInstancesOfferingsInput, _a2 func(*rds.DescribeReservedDBInstancesOfferingsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeReservedDBInstancesOfferingsInput, func(*rds.DescribeReservedDBInstancesOfferingsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeReservedDBInstancesOfferingsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeReservedDBInstancesOfferingsRequest(_a0 *rds.DescribeReservedDBInstancesOfferingsInput) (*request.Request, *rds.DescribeReservedDBInstancesOfferingsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeReservedDBInstancesOfferingsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeReservedDBInstancesOfferingsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeReservedDBInstancesOfferingsInput) *rds.DescribeReservedDBInstancesOfferingsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeReservedDBInstancesOfferingsOutput)
		}
	}

	return r0, r1
}

// DescribeReservedDBInstancesOfferingsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeReservedDBInstancesOfferingsWithContext(_a0 context.Context, _a1 *rds.DescribeReservedDBInstancesOfferingsInput, _a2 ...request.Option) (*rds.DescribeReservedDBInstancesOfferingsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeReservedDBInstancesOfferingsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeReservedDBInstancesOfferingsInput, ...request.Option) *rds.DescribeReservedDBInstancesOfferingsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeReservedDBInstancesOfferingsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeReservedDBInstancesOfferingsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeReservedDBInstancesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeReservedDBInstancesPages(_a0 *rds.DescribeReservedDBInstancesInput, _a1 func(*rds.DescribeReservedDBInstancesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeReservedDBInstancesInput, func(*rds.DescribeReservedDBInstancesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeReservedDBInstancesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeReservedDBInstancesPagesWithContext(_a0 context.Context, _a1 *rds.DescribeReservedDBInstancesInput, _a2 func(*rds.DescribeReservedDBInstancesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeReservedDBInstancesInput, func(*rds.DescribeReservedDBInstancesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeReservedDBInstancesRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeReservedDBInstancesRequest(_a0 *rds.DescribeReservedDBInstancesInput) (*request.Request, *rds.DescribeReservedDBInstancesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeReservedDBInstancesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeReservedDBInstancesOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeReservedDBInstancesInput) *rds.DescribeReservedDBInstancesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeReservedDBInstancesOutput)
		}
	}

	return r0, r1
}

// DescribeReservedDBInstancesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeReservedDBInstancesWithContext(_a0 context.Context, _a1 *rds.DescribeReservedDBInstancesInput, _a2 ...request.Option) (*rds.DescribeReservedDBInstancesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeReservedDBInstancesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeReservedDBInstancesInput, ...request.Option) *rds.DescribeReservedDBInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeReservedDBInstancesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeReservedDBInstancesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSourceRegions provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeSourceRegions(_a0 *rds.DescribeSourceRegionsInput) (*rds.DescribeSourceRegionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeSourceRegionsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeSourceRegionsInput) *rds.DescribeSourceRegionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeSourceRegionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeSourceRegionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeSourceRegionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DescribeSourceRegionsPages(_a0 *rds.DescribeSourceRegionsInput, _a1 func(*rds.DescribeSourceRegionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeSourceRegionsInput, func(*rds.DescribeSourceRegionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeSourceRegionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DescribeSourceRegionsPagesWithContext(_a0 context.Context, _a1 *rds.DescribeSourceRegionsInput, _a2 func(*rds.DescribeSourceRegionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeSourceRegionsInput, func(*rds.DescribeSourceRegionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeSourceRegionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeSourceRegionsRequest(_a0 *rds.DescribeSourceRegionsInput) (*request.Request, *rds.DescribeSourceRegionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeSourceRegionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeSourceRegionsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeSourceRegionsInput) *rds.DescribeSourceRegionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeSourceRegionsOutput)
		}
	}

	return r0, r1
}

// DescribeSourceRegionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeSourceRegionsWithContext(_a0 context.Context, _a1 *rds.DescribeSourceRegionsInput, _a2 ...request.Option) (*rds.DescribeSourceRegionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeSourceRegionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeSourceRegionsInput, ...request.Option) *rds.DescribeSourceRegionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeSourceRegionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeSourceRegionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeValidDBInstanceModifications provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeValidDBInstanceModifications(_a0 *rds.DescribeValidDBInstanceModificationsInput) (*rds.DescribeValidDBInstanceModificationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DescribeValidDBInstanceModificationsOutput
	if rf, ok := ret.Get(0).(func(*rds.DescribeValidDBInstanceModificationsInput) *rds.DescribeValidDBInstanceModificationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeValidDBInstanceModificationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DescribeValidDBInstanceModificationsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeValidDBInstanceModificationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DescribeValidDBInstanceModificationsRequest(_a0 *rds.DescribeValidDBInstanceModificationsInput) (*request.Request, *rds.DescribeValidDBInstanceModificationsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DescribeValidDBInstanceModificationsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DescribeValidDBInstanceModificationsOutput
	if rf, ok := ret.Get(1).(func(*rds.DescribeValidDBInstanceModificationsInput) *rds.DescribeValidDBInstanceModificationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DescribeValidDBInstanceModificationsOutput)
		}
	}

	return r0, r1
}

// DescribeValidDBInstanceModificationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DescribeValidDBInstanceModificationsWithContext(_a0 context.Context, _a1 *rds.DescribeValidDBInstanceModificationsInput, _a2 ...request.Option) (*rds.DescribeValidDBInstanceModificationsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DescribeValidDBInstanceModificationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeValidDBInstanceModificationsInput, ...request.Option) *rds.DescribeValidDBInstanceModificationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DescribeValidDBInstanceModificationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DescribeValidDBInstanceModificationsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DownloadDBLogFilePortion provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DownloadDBLogFilePortion(_a0 *rds.DownloadDBLogFilePortionInput) (*rds.DownloadDBLogFilePortionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DownloadDBLogFilePortionOutput
	if rf, ok := ret.Get(0).(func(*rds.DownloadDBLogFilePortionInput) *rds.DownloadDBLogFilePortionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DownloadDBLogFilePortionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.DownloadDBLogFilePortionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DownloadDBLogFilePortionPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeRDS) DownloadDBLogFilePortionPages(_a0 *rds.DownloadDBLogFilePortionInput, _a1 func(*rds.DownloadDBLogFilePortionOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DownloadDBLogFilePortionInput, func(*rds.DownloadDBLogFilePortionOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DownloadDBLogFilePortionPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeRDS) DownloadDBLogFilePortionPagesWithContext(_a0 context.Context, _a1 *rds.DownloadDBLogFilePortionInput, _a2 func(*rds.DownloadDBLogFilePortionOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DownloadDBLogFilePortionInput, func(*rds.DownloadDBLogFilePortionOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DownloadDBLogFilePortionRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) DownloadDBLogFilePortionRequest(_a0 *rds.DownloadDBLogFilePortionInput) (*request.Request, *rds.DownloadDBLogFilePortionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.DownloadDBLogFilePortionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DownloadDBLogFilePortionOutput
	if rf, ok := ret.Get(1).(func(*rds.DownloadDBLogFilePortionInput) *rds.DownloadDBLogFilePortionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DownloadDBLogFilePortionOutput)
		}
	}

	return r0, r1
}

// DownloadDBLogFilePortionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) DownloadDBLogFilePortionWithContext(_a0 context.Context, _a1 *rds.DownloadDBLogFilePortionInput, _a2 ...request.Option) (*rds.DownloadDBLogFilePortionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DownloadDBLogFilePortionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DownloadDBLogFilePortionInput, ...request.Option) *rds.DownloadDBLogFilePortionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DownloadDBLogFilePortionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.DownloadDBLogFilePortionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// FailoverDBCluster provides a mock function with given fields: _a0
func (_m *MockFakeRDS) FailoverDBCluster(_a0 *rds.FailoverDBClusterInput) (*rds.FailoverDBClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.FailoverDBClusterOutput
	if rf, ok := ret.Get(0).(func(*rds.FailoverDBClusterInput) *rds.FailoverDBClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.FailoverDBClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.FailoverDBClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// FailoverDBClusterRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) FailoverDBClusterRequest(_a0 *rds.FailoverDBClusterInput) (*request.Request, *rds.FailoverDBClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.FailoverDBClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.FailoverDBClusterOutput
	if rf, ok := ret.Get(1).(func(*rds.FailoverDBClusterInput) *rds.FailoverDBClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.FailoverDBClusterOutput)
		}
	}

	return r0, r1
}

// FailoverDBClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) FailoverDBClusterWithContext(_a0 context.Context, _a1 *rds.FailoverDBClusterInput, _a2 ...request.Option) (*rds.FailoverDBClusterOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.FailoverDBClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.FailoverDBClusterInput, ...request.Option) *rds.FailoverDBClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.FailoverDBClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.FailoverDBClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// FailoverGlobalCluster provides a mock function with given fields: _a0
func (_m *MockFakeRDS) FailoverGlobalCluster(_a0 *rds.FailoverGlobalClusterInput) (*rds.FailoverGlobalClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.FailoverGlobalClusterOutput
	if rf, ok := ret.Get(0).(func(*rds.FailoverGlobalClusterInput) *rds.FailoverGlobalClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.FailoverGlobalClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.FailoverGlobalClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// FailoverGlobalClusterRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) FailoverGlobalClusterRequest(_a0 *rds.FailoverGlobalClusterInput) (*request.Request, *rds.FailoverGlobalClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.FailoverGlobalClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.FailoverGlobalClusterOutput
	if rf, ok := ret.Get(1).(func(*rds.FailoverGlobalClusterInput) *rds.FailoverGlobalClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.FailoverGlobalClusterOutput)
		}
	}

	return r0, r1
}

// FailoverGlobalClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) FailoverGlobalClusterWithContext(_a0 context.Context, _a1 *rds.FailoverGlobalClusterInput, _a2 ...request.Option) (*rds.FailoverGlobalClusterOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.FailoverGlobalClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.FailoverGlobalClusterInput, ...request.Option) *rds.FailoverGlobalClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.FailoverGlobalClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.FailoverGlobalClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImportInstallationMedia provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ImportInstallationMedia(_a0 *rds.ImportInstallationMediaInput) (*rds.ImportInstallationMediaOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.ImportInstallationMediaOutput
	if rf, ok := ret.Get(0).(func(*rds.ImportInstallationMediaInput) *rds.ImportInstallationMediaOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ImportInstallationMediaOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ImportInstallationMediaInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ImportInstallationMediaRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ImportInstallationMediaRequest(_a0 *rds.ImportInstallationMediaInput) (*request.Request, *rds.ImportInstallationMediaOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ImportInstallationMediaInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.ImportInstallationMediaOutput
	if rf, ok := ret.Get(1).(func(*rds.ImportInstallationMediaInput) *rds.ImportInstallationMediaOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.ImportInstallationMediaOutput)
		}
	}

	return r0, r1
}

// ImportInstallationMediaWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ImportInstallationMediaWithContext(_a0 context.Context, _a1 *rds.ImportInstallationMediaInput, _a2 ...request.Option) (*rds.ImportInstallationMediaOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.ImportInstallationMediaOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ImportInstallationMediaInput, ...request.Option) *rds.ImportInstallationMediaOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ImportInstallationMediaOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ImportInstallationMediaInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTagsForResource provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ListTagsForResource(_a0 *rds.ListTagsForResourceInput) (*rds.ListTagsForResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.ListTagsForResourceOutput
	if rf, ok := ret.Get(0).(func(*rds.ListTagsForResourceInput) *rds.ListTagsForResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ListTagsForResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ListTagsForResourceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTagsForResourceRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ListTagsForResourceRequest(_a0 *rds.ListTagsForResourceInput) (*request.Request, *rds.ListTagsForResourceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ListTagsForResourceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.ListTagsForResourceOutput
	if rf, ok := ret.Get(1).(func(*rds.ListTagsForResourceInput) *rds.ListTagsForResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.ListTagsForResourceOutput)
		}
	}

	return r0, r1
}

// ListTagsForResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ListTagsForResourceWithContext(_a0 context.Context, _a1 *rds.ListTagsForResourceInput, _a2 ...request.Option) (*rds.ListTagsForResourceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.ListTagsForResourceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ListTagsForResourceInput, ...request.Option) *rds.ListTagsForResourceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ListTagsForResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ListTagsForResourceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyCertificates provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyCertificates(_a0 *rds.ModifyCertificatesInput) (*rds.ModifyCertificatesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.ModifyCertificatesOutput
	if rf, ok := ret.Get(0).(func(*rds.ModifyCertificatesInput) *rds.ModifyCertificatesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyCertificatesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ModifyCertificatesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyCertificatesRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyCertificatesRequest(_a0 *rds.ModifyCertificatesInput) (*request.Request, *rds.ModifyCertificatesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ModifyCertificatesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.ModifyCertificatesOutput
	if rf, ok := ret.Get(1).(func(*rds.ModifyCertificatesInput) *rds.ModifyCertificatesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.ModifyCertificatesOutput)
		}
	}

	return r0, r1
}

// ModifyCertificatesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ModifyCertificatesWithContext(_a0 context.Context, _a1 *rds.ModifyCertificatesInput, _a2 ...request.Option) (*rds.ModifyCertificatesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.ModifyCertificatesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ModifyCertificatesInput, ...request.Option) *rds.ModifyCertificatesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyCertificatesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ModifyCertificatesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyCurrentDBClusterCapacity provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyCurrentDBClusterCapacity(_a0 *rds.ModifyCurrentDBClusterCapacityInput) (*rds.ModifyCurrentDBClusterCapacityOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.ModifyCurrentDBClusterCapacityOutput
	if rf, ok := ret.Get(0).(func(*rds.ModifyCurrentDBClusterCapacityInput) *rds.ModifyCurrentDBClusterCapacityOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyCurrentDBClusterCapacityOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ModifyCurrentDBClusterCapacityInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyCurrentDBClusterCapacityRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyCurrentDBClusterCapacityRequest(_a0 *rds.ModifyCurrentDBClusterCapacityInput) (*request.Request, *rds.ModifyCurrentDBClusterCapacityOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ModifyCurrentDBClusterCapacityInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.ModifyCurrentDBClusterCapacityOutput
	if rf, ok := ret.Get(1).(func(*rds.ModifyCurrentDBClusterCapacityInput) *rds.ModifyCurrentDBClusterCapacityOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.ModifyCurrentDBClusterCapacityOutput)
		}
	}

	return r0, r1
}

// ModifyCurrentDBClusterCapacityWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ModifyCurrentDBClusterCapacityWithContext(_a0 context.Context, _a1 *rds.ModifyCurrentDBClusterCapacityInput, _a2 ...request.Option) (*rds.ModifyCurrentDBClusterCapacityOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.ModifyCurrentDBClusterCapacityOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ModifyCurrentDBClusterCapacityInput, ...request.Option) *rds.ModifyCurrentDBClusterCapacityOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyCurrentDBClusterCapacityOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ModifyCurrentDBClusterCapacityInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBCluster provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBCluster(_a0 *rds.ModifyDBClusterInput) (*rds.ModifyDBClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.ModifyDBClusterOutput
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBClusterInput) *rds.ModifyDBClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyDBClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBClusterEndpoint provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBClusterEndpoint(_a0 *rds.ModifyDBClusterEndpointInput) (*rds.ModifyDBClusterEndpointOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.ModifyDBClusterEndpointOutput
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBClusterEndpointInput) *rds.ModifyDBClusterEndpointOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyDBClusterEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBClusterEndpointInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBClusterEndpointRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBClusterEndpointRequest(_a0 *rds.ModifyDBClusterEndpointInput) (*request.Request, *rds.ModifyDBClusterEndpointOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBClusterEndpointInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.ModifyDBClusterEndpointOutput
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBClusterEndpointInput) *rds.ModifyDBClusterEndpointOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.ModifyDBClusterEndpointOutput)
		}
	}

	return r0, r1
}

// ModifyDBClusterEndpointWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ModifyDBClusterEndpointWithContext(_a0 context.Context, _a1 *rds.ModifyDBClusterEndpointInput, _a2 ...request.Option) (*rds.ModifyDBClusterEndpointOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.ModifyDBClusterEndpointOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ModifyDBClusterEndpointInput, ...request.Option) *rds.ModifyDBClusterEndpointOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyDBClusterEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ModifyDBClusterEndpointInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBClusterParameterGroup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBClusterParameterGroup(_a0 *rds.ModifyDBClusterParameterGroupInput) (*rds.DBClusterParameterGroupNameMessage, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DBClusterParameterGroupNameMessage
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBClusterParameterGroupInput) *rds.DBClusterParameterGroupNameMessage); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DBClusterParameterGroupNameMessage)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBClusterParameterGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBClusterParameterGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBClusterParameterGroupRequest(_a0 *rds.ModifyDBClusterParameterGroupInput) (*request.Request, *rds.DBClusterParameterGroupNameMessage) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBClusterParameterGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DBClusterParameterGroupNameMessage
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBClusterParameterGroupInput) *rds.DBClusterParameterGroupNameMessage); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DBClusterParameterGroupNameMessage)
		}
	}

	return r0, r1
}

// ModifyDBClusterParameterGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ModifyDBClusterParameterGroupWithContext(_a0 context.Context, _a1 *rds.ModifyDBClusterParameterGroupInput, _a2 ...request.Option) (*rds.DBClusterParameterGroupNameMessage, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DBClusterParameterGroupNameMessage
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ModifyDBClusterParameterGroupInput, ...request.Option) *rds.DBClusterParameterGroupNameMessage); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DBClusterParameterGroupNameMessage)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ModifyDBClusterParameterGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBClusterRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBClusterRequest(_a0 *rds.ModifyDBClusterInput) (*request.Request, *rds.ModifyDBClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.ModifyDBClusterOutput
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBClusterInput) *rds.ModifyDBClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.ModifyDBClusterOutput)
		}
	}

	return r0, r1
}

// ModifyDBClusterSnapshotAttribute provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBClusterSnapshotAttribute(_a0 *rds.ModifyDBClusterSnapshotAttributeInput) (*rds.ModifyDBClusterSnapshotAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.ModifyDBClusterSnapshotAttributeOutput
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBClusterSnapshotAttributeInput) *rds.ModifyDBClusterSnapshotAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyDBClusterSnapshotAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBClusterSnapshotAttributeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBClusterSnapshotAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBClusterSnapshotAttributeRequest(_a0 *rds.ModifyDBClusterSnapshotAttributeInput) (*request.Request, *rds.ModifyDBClusterSnapshotAttributeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBClusterSnapshotAttributeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.ModifyDBClusterSnapshotAttributeOutput
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBClusterSnapshotAttributeInput) *rds.ModifyDBClusterSnapshotAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.ModifyDBClusterSnapshotAttributeOutput)
		}
	}

	return r0, r1
}

// ModifyDBClusterSnapshotAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ModifyDBClusterSnapshotAttributeWithContext(_a0 context.Context, _a1 *rds.ModifyDBClusterSnapshotAttributeInput, _a2 ...request.Option) (*rds.ModifyDBClusterSnapshotAttributeOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.ModifyDBClusterSnapshotAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ModifyDBClusterSnapshotAttributeInput, ...request.Option) *rds.ModifyDBClusterSnapshotAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyDBClusterSnapshotAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ModifyDBClusterSnapshotAttributeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ModifyDBClusterWithContext(_a0 context.Context, _a1 *rds.ModifyDBClusterInput, _a2 ...request.Option) (*rds.ModifyDBClusterOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.ModifyDBClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ModifyDBClusterInput, ...request.Option) *rds.ModifyDBClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyDBClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ModifyDBClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBInstance provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBInstance(_a0 *rds.ModifyDBInstanceInput) (*rds.ModifyDBInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.ModifyDBInstanceOutput
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBInstanceInput) *rds.ModifyDBInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyDBInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBInstanceRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBInstanceRequest(_a0 *rds.ModifyDBInstanceInput) (*request.Request, *rds.ModifyDBInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.ModifyDBInstanceOutput
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBInstanceInput) *rds.ModifyDBInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.ModifyDBInstanceOutput)
		}
	}

	return r0, r1
}

// ModifyDBInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ModifyDBInstanceWithContext(_a0 context.Context, _a1 *rds.ModifyDBInstanceInput, _a2 ...request.Option) (*rds.ModifyDBInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.ModifyDBInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ModifyDBInstanceInput, ...request.Option) *rds.ModifyDBInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyDBInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ModifyDBInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBParameterGroup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBParameterGroup(_a0 *rds.ModifyDBParameterGroupInput) (*rds.DBParameterGroupNameMessage, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DBParameterGroupNameMessage
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBParameterGroupInput) *rds.DBParameterGroupNameMessage); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DBParameterGroupNameMessage)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBParameterGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBParameterGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBParameterGroupRequest(_a0 *rds.ModifyDBParameterGroupInput) (*request.Request, *rds.DBParameterGroupNameMessage) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBParameterGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DBParameterGroupNameMessage
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBParameterGroupInput) *rds.DBParameterGroupNameMessage); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DBParameterGroupNameMessage)
		}
	}

	return r0, r1
}

// ModifyDBParameterGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ModifyDBParameterGroupWithContext(_a0 context.Context, _a1 *rds.ModifyDBParameterGroupInput, _a2 ...request.Option) (*rds.DBParameterGroupNameMessage, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DBParameterGroupNameMessage
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ModifyDBParameterGroupInput, ...request.Option) *rds.DBParameterGroupNameMessage); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DBParameterGroupNameMessage)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ModifyDBParameterGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBProxy provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBProxy(_a0 *rds.ModifyDBProxyInput) (*rds.ModifyDBProxyOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.ModifyDBProxyOutput
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBProxyInput) *rds.ModifyDBProxyOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyDBProxyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBProxyInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBProxyEndpoint provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBProxyEndpoint(_a0 *rds.ModifyDBProxyEndpointInput) (*rds.ModifyDBProxyEndpointOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.ModifyDBProxyEndpointOutput
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBProxyEndpointInput) *rds.ModifyDBProxyEndpointOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyDBProxyEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBProxyEndpointInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBProxyEndpointRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBProxyEndpointRequest(_a0 *rds.ModifyDBProxyEndpointInput) (*request.Request, *rds.ModifyDBProxyEndpointOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBProxyEndpointInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.ModifyDBProxyEndpointOutput
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBProxyEndpointInput) *rds.ModifyDBProxyEndpointOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.ModifyDBProxyEndpointOutput)
		}
	}

	return r0, r1
}

// ModifyDBProxyEndpointWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ModifyDBProxyEndpointWithContext(_a0 context.Context, _a1 *rds.ModifyDBProxyEndpointInput, _a2 ...request.Option) (*rds.ModifyDBProxyEndpointOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.ModifyDBProxyEndpointOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ModifyDBProxyEndpointInput, ...request.Option) *rds.ModifyDBProxyEndpointOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyDBProxyEndpointOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ModifyDBProxyEndpointInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBProxyRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBProxyRequest(_a0 *rds.ModifyDBProxyInput) (*request.Request, *rds.ModifyDBProxyOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBProxyInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.ModifyDBProxyOutput
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBProxyInput) *rds.ModifyDBProxyOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.ModifyDBProxyOutput)
		}
	}

	return r0, r1
}

// ModifyDBProxyTargetGroup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBProxyTargetGroup(_a0 *rds.ModifyDBProxyTargetGroupInput) (*rds.ModifyDBProxyTargetGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.ModifyDBProxyTargetGroupOutput
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBProxyTargetGroupInput) *rds.ModifyDBProxyTargetGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyDBProxyTargetGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBProxyTargetGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBProxyTargetGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBProxyTargetGroupRequest(_a0 *rds.ModifyDBProxyTargetGroupInput) (*request.Request, *rds.ModifyDBProxyTargetGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBProxyTargetGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.ModifyDBProxyTargetGroupOutput
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBProxyTargetGroupInput) *rds.ModifyDBProxyTargetGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.ModifyDBProxyTargetGroupOutput)
		}
	}

	return r0, r1
}

// ModifyDBProxyTargetGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ModifyDBProxyTargetGroupWithContext(_a0 context.Context, _a1 *rds.ModifyDBProxyTargetGroupInput, _a2 ...request.Option) (*rds.ModifyDBProxyTargetGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.ModifyDBProxyTargetGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ModifyDBProxyTargetGroupInput, ...request.Option) *rds.ModifyDBProxyTargetGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyDBProxyTargetGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ModifyDBProxyTargetGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBProxyWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ModifyDBProxyWithContext(_a0 context.Context, _a1 *rds.ModifyDBProxyInput, _a2 ...request.Option) (*rds.ModifyDBProxyOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.ModifyDBProxyOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ModifyDBProxyInput, ...request.Option) *rds.ModifyDBProxyOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyDBProxyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ModifyDBProxyInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBSnapshot provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBSnapshot(_a0 *rds.ModifyDBSnapshotInput) (*rds.ModifyDBSnapshotOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.ModifyDBSnapshotOutput
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBSnapshotInput) *rds.ModifyDBSnapshotOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyDBSnapshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBSnapshotInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBSnapshotAttribute provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBSnapshotAttribute(_a0 *rds.ModifyDBSnapshotAttributeInput) (*rds.ModifyDBSnapshotAttributeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.ModifyDBSnapshotAttributeOutput
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBSnapshotAttributeInput) *rds.ModifyDBSnapshotAttributeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyDBSnapshotAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBSnapshotAttributeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBSnapshotAttributeRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBSnapshotAttributeRequest(_a0 *rds.ModifyDBSnapshotAttributeInput) (*request.Request, *rds.ModifyDBSnapshotAttributeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBSnapshotAttributeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.ModifyDBSnapshotAttributeOutput
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBSnapshotAttributeInput) *rds.ModifyDBSnapshotAttributeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.ModifyDBSnapshotAttributeOutput)
		}
	}

	return r0, r1
}

// ModifyDBSnapshotAttributeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ModifyDBSnapshotAttributeWithContext(_a0 context.Context, _a1 *rds.ModifyDBSnapshotAttributeInput, _a2 ...request.Option) (*rds.ModifyDBSnapshotAttributeOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.ModifyDBSnapshotAttributeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ModifyDBSnapshotAttributeInput, ...request.Option) *rds.ModifyDBSnapshotAttributeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyDBSnapshotAttributeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ModifyDBSnapshotAttributeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBSnapshotRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBSnapshotRequest(_a0 *rds.ModifyDBSnapshotInput) (*request.Request, *rds.ModifyDBSnapshotOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBSnapshotInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.ModifyDBSnapshotOutput
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBSnapshotInput) *rds.ModifyDBSnapshotOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.ModifyDBSnapshotOutput)
		}
	}

	return r0, r1
}

// ModifyDBSnapshotWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ModifyDBSnapshotWithContext(_a0 context.Context, _a1 *rds.ModifyDBSnapshotInput, _a2 ...request.Option) (*rds.ModifyDBSnapshotOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.ModifyDBSnapshotOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ModifyDBSnapshotInput, ...request.Option) *rds.ModifyDBSnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyDBSnapshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ModifyDBSnapshotInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBSubnetGroup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBSubnetGroup(_a0 *rds.ModifyDBSubnetGroupInput) (*rds.ModifyDBSubnetGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.ModifyDBSubnetGroupOutput
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBSubnetGroupInput) *rds.ModifyDBSubnetGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyDBSubnetGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBSubnetGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyDBSubnetGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyDBSubnetGroupRequest(_a0 *rds.ModifyDBSubnetGroupInput) (*request.Request, *rds.ModifyDBSubnetGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ModifyDBSubnetGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.ModifyDBSubnetGroupOutput
	if rf, ok := ret.Get(1).(func(*rds.ModifyDBSubnetGroupInput) *rds.ModifyDBSubnetGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.ModifyDBSubnetGroupOutput)
		}
	}

	return r0, r1
}

// ModifyDBSubnetGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ModifyDBSubnetGroupWithContext(_a0 context.Context, _a1 *rds.ModifyDBSubnetGroupInput, _a2 ...request.Option) (*rds.ModifyDBSubnetGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.ModifyDBSubnetGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ModifyDBSubnetGroupInput, ...request.Option) *rds.ModifyDBSubnetGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyDBSubnetGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ModifyDBSubnetGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyEventSubscription provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyEventSubscription(_a0 *rds.ModifyEventSubscriptionInput) (*rds.ModifyEventSubscriptionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.ModifyEventSubscriptionOutput
	if rf, ok := ret.Get(0).(func(*rds.ModifyEventSubscriptionInput) *rds.ModifyEventSubscriptionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyEventSubscriptionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ModifyEventSubscriptionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyEventSubscriptionRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyEventSubscriptionRequest(_a0 *rds.ModifyEventSubscriptionInput) (*request.Request, *rds.ModifyEventSubscriptionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ModifyEventSubscriptionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.ModifyEventSubscriptionOutput
	if rf, ok := ret.Get(1).(func(*rds.ModifyEventSubscriptionInput) *rds.ModifyEventSubscriptionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.ModifyEventSubscriptionOutput)
		}
	}

	return r0, r1
}

// ModifyEventSubscriptionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ModifyEventSubscriptionWithContext(_a0 context.Context, _a1 *rds.ModifyEventSubscriptionInput, _a2 ...request.Option) (*rds.ModifyEventSubscriptionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.ModifyEventSubscriptionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ModifyEventSubscriptionInput, ...request.Option) *rds.ModifyEventSubscriptionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyEventSubscriptionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ModifyEventSubscriptionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyGlobalCluster provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyGlobalCluster(_a0 *rds.ModifyGlobalClusterInput) (*rds.ModifyGlobalClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.ModifyGlobalClusterOutput
	if rf, ok := ret.Get(0).(func(*rds.ModifyGlobalClusterInput) *rds.ModifyGlobalClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyGlobalClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ModifyGlobalClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyGlobalClusterRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyGlobalClusterRequest(_a0 *rds.ModifyGlobalClusterInput) (*request.Request, *rds.ModifyGlobalClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ModifyGlobalClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.ModifyGlobalClusterOutput
	if rf, ok := ret.Get(1).(func(*rds.ModifyGlobalClusterInput) *rds.ModifyGlobalClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.ModifyGlobalClusterOutput)
		}
	}

	return r0, r1
}

// ModifyGlobalClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ModifyGlobalClusterWithContext(_a0 context.Context, _a1 *rds.ModifyGlobalClusterInput, _a2 ...request.Option) (*rds.ModifyGlobalClusterOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.ModifyGlobalClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ModifyGlobalClusterInput, ...request.Option) *rds.ModifyGlobalClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyGlobalClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ModifyGlobalClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyOptionGroup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyOptionGroup(_a0 *rds.ModifyOptionGroupInput) (*rds.ModifyOptionGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.ModifyOptionGroupOutput
	if rf, ok := ret.Get(0).(func(*rds.ModifyOptionGroupInput) *rds.ModifyOptionGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyOptionGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ModifyOptionGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ModifyOptionGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ModifyOptionGroupRequest(_a0 *rds.ModifyOptionGroupInput) (*request.Request, *rds.ModifyOptionGroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ModifyOptionGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.ModifyOptionGroupOutput
	if rf, ok := ret.Get(1).(func(*rds.ModifyOptionGroupInput) *rds.ModifyOptionGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.ModifyOptionGroupOutput)
		}
	}

	return r0, r1
}

// ModifyOptionGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ModifyOptionGroupWithContext(_a0 context.Context, _a1 *rds.ModifyOptionGroupInput, _a2 ...request.Option) (*rds.ModifyOptionGroupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.ModifyOptionGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ModifyOptionGroupInput, ...request.Option) *rds.ModifyOptionGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.ModifyOptionGroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ModifyOptionGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PromoteReadReplica provides a mock function with given fields: _a0
func (_m *MockFakeRDS) PromoteReadReplica(_a0 *rds.PromoteReadReplicaInput) (*rds.PromoteReadReplicaOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.PromoteReadReplicaOutput
	if rf, ok := ret.Get(0).(func(*rds.PromoteReadReplicaInput) *rds.PromoteReadReplicaOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.PromoteReadReplicaOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.PromoteReadReplicaInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PromoteReadReplicaDBCluster provides a mock function with given fields: _a0
func (_m *MockFakeRDS) PromoteReadReplicaDBCluster(_a0 *rds.PromoteReadReplicaDBClusterInput) (*rds.PromoteReadReplicaDBClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.PromoteReadReplicaDBClusterOutput
	if rf, ok := ret.Get(0).(func(*rds.PromoteReadReplicaDBClusterInput) *rds.PromoteReadReplicaDBClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.PromoteReadReplicaDBClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.PromoteReadReplicaDBClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PromoteReadReplicaDBClusterRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) PromoteReadReplicaDBClusterRequest(_a0 *rds.PromoteReadReplicaDBClusterInput) (*request.Request, *rds.PromoteReadReplicaDBClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.PromoteReadReplicaDBClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.PromoteReadReplicaDBClusterOutput
	if rf, ok := ret.Get(1).(func(*rds.PromoteReadReplicaDBClusterInput) *rds.PromoteReadReplicaDBClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.PromoteReadReplicaDBClusterOutput)
		}
	}

	return r0, r1
}

// PromoteReadReplicaDBClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) PromoteReadReplicaDBClusterWithContext(_a0 context.Context, _a1 *rds.PromoteReadReplicaDBClusterInput, _a2 ...request.Option) (*rds.PromoteReadReplicaDBClusterOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.PromoteReadReplicaDBClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.PromoteReadReplicaDBClusterInput, ...request.Option) *rds.PromoteReadReplicaDBClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.PromoteReadReplicaDBClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.PromoteReadReplicaDBClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PromoteReadReplicaRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) PromoteReadReplicaRequest(_a0 *rds.PromoteReadReplicaInput) (*request.Request, *rds.PromoteReadReplicaOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.PromoteReadReplicaInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.PromoteReadReplicaOutput
	if rf, ok := ret.Get(1).(func(*rds.PromoteReadReplicaInput) *rds.PromoteReadReplicaOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.PromoteReadReplicaOutput)
		}
	}

	return r0, r1
}

// PromoteReadReplicaWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) PromoteReadReplicaWithContext(_a0 context.Context, _a1 *rds.PromoteReadReplicaInput, _a2 ...request.Option) (*rds.PromoteReadReplicaOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.PromoteReadReplicaOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.PromoteReadReplicaInput, ...request.Option) *rds.PromoteReadReplicaOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.PromoteReadReplicaOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.PromoteReadReplicaInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PurchaseReservedDBInstancesOffering provides a mock function with given fields: _a0
func (_m *MockFakeRDS) PurchaseReservedDBInstancesOffering(_a0 *rds.PurchaseReservedDBInstancesOfferingInput) (*rds.PurchaseReservedDBInstancesOfferingOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.PurchaseReservedDBInstancesOfferingOutput
	if rf, ok := ret.Get(0).(func(*rds.PurchaseReservedDBInstancesOfferingInput) *rds.PurchaseReservedDBInstancesOfferingOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.PurchaseReservedDBInstancesOfferingOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.PurchaseReservedDBInstancesOfferingInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PurchaseReservedDBInstancesOfferingRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) PurchaseReservedDBInstancesOfferingRequest(_a0 *rds.PurchaseReservedDBInstancesOfferingInput) (*request.Request, *rds.PurchaseReservedDBInstancesOfferingOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.PurchaseReservedDBInstancesOfferingInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.PurchaseReservedDBInstancesOfferingOutput
	if rf, ok := ret.Get(1).(func(*rds.PurchaseReservedDBInstancesOfferingInput) *rds.PurchaseReservedDBInstancesOfferingOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.PurchaseReservedDBInstancesOfferingOutput)
		}
	}

	return r0, r1
}

// PurchaseReservedDBInstancesOfferingWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) PurchaseReservedDBInstancesOfferingWithContext(_a0 context.Context, _a1 *rds.PurchaseReservedDBInstancesOfferingInput, _a2 ...request.Option) (*rds.PurchaseReservedDBInstancesOfferingOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.PurchaseReservedDBInstancesOfferingOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.PurchaseReservedDBInstancesOfferingInput, ...request.Option) *rds.PurchaseReservedDBInstancesOfferingOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.PurchaseReservedDBInstancesOfferingOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.PurchaseReservedDBInstancesOfferingInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RebootDBInstance provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RebootDBInstance(_a0 *rds.RebootDBInstanceInput) (*rds.RebootDBInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.RebootDBInstanceOutput
	if rf, ok := ret.Get(0).(func(*rds.RebootDBInstanceInput) *rds.RebootDBInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RebootDBInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.RebootDBInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RebootDBInstanceRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RebootDBInstanceRequest(_a0 *rds.RebootDBInstanceInput) (*request.Request, *rds.RebootDBInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.RebootDBInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.RebootDBInstanceOutput
	if rf, ok := ret.Get(1).(func(*rds.RebootDBInstanceInput) *rds.RebootDBInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.RebootDBInstanceOutput)
		}
	}

	return r0, r1
}

// RebootDBInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) RebootDBInstanceWithContext(_a0 context.Context, _a1 *rds.RebootDBInstanceInput, _a2 ...request.Option) (*rds.RebootDBInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.RebootDBInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.RebootDBInstanceInput, ...request.Option) *rds.RebootDBInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RebootDBInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.RebootDBInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RegisterDBProxyTargets provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RegisterDBProxyTargets(_a0 *rds.RegisterDBProxyTargetsInput) (*rds.RegisterDBProxyTargetsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.RegisterDBProxyTargetsOutput
	if rf, ok := ret.Get(0).(func(*rds.RegisterDBProxyTargetsInput) *rds.RegisterDBProxyTargetsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RegisterDBProxyTargetsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.RegisterDBProxyTargetsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RegisterDBProxyTargetsRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RegisterDBProxyTargetsRequest(_a0 *rds.RegisterDBProxyTargetsInput) (*request.Request, *rds.RegisterDBProxyTargetsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.RegisterDBProxyTargetsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.RegisterDBProxyTargetsOutput
	if rf, ok := ret.Get(1).(func(*rds.RegisterDBProxyTargetsInput) *rds.RegisterDBProxyTargetsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.RegisterDBProxyTargetsOutput)
		}
	}

	return r0, r1
}

// RegisterDBProxyTargetsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) RegisterDBProxyTargetsWithContext(_a0 context.Context, _a1 *rds.RegisterDBProxyTargetsInput, _a2 ...request.Option) (*rds.RegisterDBProxyTargetsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.RegisterDBProxyTargetsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.RegisterDBProxyTargetsInput, ...request.Option) *rds.RegisterDBProxyTargetsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RegisterDBProxyTargetsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.RegisterDBProxyTargetsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemoveFromGlobalCluster provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RemoveFromGlobalCluster(_a0 *rds.RemoveFromGlobalClusterInput) (*rds.RemoveFromGlobalClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.RemoveFromGlobalClusterOutput
	if rf, ok := ret.Get(0).(func(*rds.RemoveFromGlobalClusterInput) *rds.RemoveFromGlobalClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RemoveFromGlobalClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.RemoveFromGlobalClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemoveFromGlobalClusterRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RemoveFromGlobalClusterRequest(_a0 *rds.RemoveFromGlobalClusterInput) (*request.Request, *rds.RemoveFromGlobalClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.RemoveFromGlobalClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.RemoveFromGlobalClusterOutput
	if rf, ok := ret.Get(1).(func(*rds.RemoveFromGlobalClusterInput) *rds.RemoveFromGlobalClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.RemoveFromGlobalClusterOutput)
		}
	}

	return r0, r1
}

// RemoveFromGlobalClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) RemoveFromGlobalClusterWithContext(_a0 context.Context, _a1 *rds.RemoveFromGlobalClusterInput, _a2 ...request.Option) (*rds.RemoveFromGlobalClusterOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.RemoveFromGlobalClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.RemoveFromGlobalClusterInput, ...request.Option) *rds.RemoveFromGlobalClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RemoveFromGlobalClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.RemoveFromGlobalClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemoveRoleFromDBCluster provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RemoveRoleFromDBCluster(_a0 *rds.RemoveRoleFromDBClusterInput) (*rds.RemoveRoleFromDBClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.RemoveRoleFromDBClusterOutput
	if rf, ok := ret.Get(0).(func(*rds.RemoveRoleFromDBClusterInput) *rds.RemoveRoleFromDBClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RemoveRoleFromDBClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.RemoveRoleFromDBClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemoveRoleFromDBClusterRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RemoveRoleFromDBClusterRequest(_a0 *rds.RemoveRoleFromDBClusterInput) (*request.Request, *rds.RemoveRoleFromDBClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.RemoveRoleFromDBClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.RemoveRoleFromDBClusterOutput
	if rf, ok := ret.Get(1).(func(*rds.RemoveRoleFromDBClusterInput) *rds.RemoveRoleFromDBClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.RemoveRoleFromDBClusterOutput)
		}
	}

	return r0, r1
}

// RemoveRoleFromDBClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) RemoveRoleFromDBClusterWithContext(_a0 context.Context, _a1 *rds.RemoveRoleFromDBClusterInput, _a2 ...request.Option) (*rds.RemoveRoleFromDBClusterOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.RemoveRoleFromDBClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.RemoveRoleFromDBClusterInput, ...request.Option) *rds.RemoveRoleFromDBClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RemoveRoleFromDBClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.RemoveRoleFromDBClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemoveRoleFromDBInstance provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RemoveRoleFromDBInstance(_a0 *rds.RemoveRoleFromDBInstanceInput) (*rds.RemoveRoleFromDBInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.RemoveRoleFromDBInstanceOutput
	if rf, ok := ret.Get(0).(func(*rds.RemoveRoleFromDBInstanceInput) *rds.RemoveRoleFromDBInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RemoveRoleFromDBInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.RemoveRoleFromDBInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemoveRoleFromDBInstanceRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RemoveRoleFromDBInstanceRequest(_a0 *rds.RemoveRoleFromDBInstanceInput) (*request.Request, *rds.RemoveRoleFromDBInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.RemoveRoleFromDBInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.RemoveRoleFromDBInstanceOutput
	if rf, ok := ret.Get(1).(func(*rds.RemoveRoleFromDBInstanceInput) *rds.RemoveRoleFromDBInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.RemoveRoleFromDBInstanceOutput)
		}
	}

	return r0, r1
}

// RemoveRoleFromDBInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) RemoveRoleFromDBInstanceWithContext(_a0 context.Context, _a1 *rds.RemoveRoleFromDBInstanceInput, _a2 ...request.Option) (*rds.RemoveRoleFromDBInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.RemoveRoleFromDBInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.RemoveRoleFromDBInstanceInput, ...request.Option) *rds.RemoveRoleFromDBInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RemoveRoleFromDBInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.RemoveRoleFromDBInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemoveSourceIdentifierFromSubscription provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RemoveSourceIdentifierFromSubscription(_a0 *rds.RemoveSourceIdentifierFromSubscriptionInput) (*rds.RemoveSourceIdentifierFromSubscriptionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.RemoveSourceIdentifierFromSubscriptionOutput
	if rf, ok := ret.Get(0).(func(*rds.RemoveSourceIdentifierFromSubscriptionInput) *rds.RemoveSourceIdentifierFromSubscriptionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RemoveSourceIdentifierFromSubscriptionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.RemoveSourceIdentifierFromSubscriptionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemoveSourceIdentifierFromSubscriptionRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RemoveSourceIdentifierFromSubscriptionRequest(_a0 *rds.RemoveSourceIdentifierFromSubscriptionInput) (*request.Request, *rds.RemoveSourceIdentifierFromSubscriptionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.RemoveSourceIdentifierFromSubscriptionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.RemoveSourceIdentifierFromSubscriptionOutput
	if rf, ok := ret.Get(1).(func(*rds.RemoveSourceIdentifierFromSubscriptionInput) *rds.RemoveSourceIdentifierFromSubscriptionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.RemoveSourceIdentifierFromSubscriptionOutput)
		}
	}

	return r0, r1
}

// RemoveSourceIdentifierFromSubscriptionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) RemoveSourceIdentifierFromSubscriptionWithContext(_a0 context.Context, _a1 *rds.RemoveSourceIdentifierFromSubscriptionInput, _a2 ...request.Option) (*rds.RemoveSourceIdentifierFromSubscriptionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.RemoveSourceIdentifierFromSubscriptionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.RemoveSourceIdentifierFromSubscriptionInput, ...request.Option) *rds.RemoveSourceIdentifierFromSubscriptionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RemoveSourceIdentifierFromSubscriptionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.RemoveSourceIdentifierFromSubscriptionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemoveTagsFromResource provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RemoveTagsFromResource(_a0 *rds.RemoveTagsFromResourceInput) (*rds.RemoveTagsFromResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.RemoveTagsFromResourceOutput
	if rf, ok := ret.Get(0).(func(*rds.RemoveTagsFromResourceInput) *rds.RemoveTagsFromResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RemoveTagsFromResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.RemoveTagsFromResourceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RemoveTagsFromResourceRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RemoveTagsFromResourceRequest(_a0 *rds.RemoveTagsFromResourceInput) (*request.Request, *rds.RemoveTagsFromResourceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.RemoveTagsFromResourceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.RemoveTagsFromResourceOutput
	if rf, ok := ret.Get(1).(func(*rds.RemoveTagsFromResourceInput) *rds.RemoveTagsFromResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.RemoveTagsFromResourceOutput)
		}
	}

	return r0, r1
}

// RemoveTagsFromResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) RemoveTagsFromResourceWithContext(_a0 context.Context, _a1 *rds.RemoveTagsFromResourceInput, _a2 ...request.Option) (*rds.RemoveTagsFromResourceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.RemoveTagsFromResourceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.RemoveTagsFromResourceInput, ...request.Option) *rds.RemoveTagsFromResourceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RemoveTagsFromResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.RemoveTagsFromResourceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResetDBClusterParameterGroup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ResetDBClusterParameterGroup(_a0 *rds.ResetDBClusterParameterGroupInput) (*rds.DBClusterParameterGroupNameMessage, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DBClusterParameterGroupNameMessage
	if rf, ok := ret.Get(0).(func(*rds.ResetDBClusterParameterGroupInput) *rds.DBClusterParameterGroupNameMessage); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DBClusterParameterGroupNameMessage)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ResetDBClusterParameterGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResetDBClusterParameterGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ResetDBClusterParameterGroupRequest(_a0 *rds.ResetDBClusterParameterGroupInput) (*request.Request, *rds.DBClusterParameterGroupNameMessage) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ResetDBClusterParameterGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DBClusterParameterGroupNameMessage
	if rf, ok := ret.Get(1).(func(*rds.ResetDBClusterParameterGroupInput) *rds.DBClusterParameterGroupNameMessage); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DBClusterParameterGroupNameMessage)
		}
	}

	return r0, r1
}

// ResetDBClusterParameterGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ResetDBClusterParameterGroupWithContext(_a0 context.Context, _a1 *rds.ResetDBClusterParameterGroupInput, _a2 ...request.Option) (*rds.DBClusterParameterGroupNameMessage, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DBClusterParameterGroupNameMessage
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ResetDBClusterParameterGroupInput, ...request.Option) *rds.DBClusterParameterGroupNameMessage); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DBClusterParameterGroupNameMessage)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ResetDBClusterParameterGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResetDBParameterGroup provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ResetDBParameterGroup(_a0 *rds.ResetDBParameterGroupInput) (*rds.DBParameterGroupNameMessage, error) {
	ret := _m.Called(_a0)

	var r0 *rds.DBParameterGroupNameMessage
	if rf, ok := ret.Get(0).(func(*rds.ResetDBParameterGroupInput) *rds.DBParameterGroupNameMessage); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DBParameterGroupNameMessage)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.ResetDBParameterGroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ResetDBParameterGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) ResetDBParameterGroupRequest(_a0 *rds.ResetDBParameterGroupInput) (*request.Request, *rds.DBParameterGroupNameMessage) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.ResetDBParameterGroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.DBParameterGroupNameMessage
	if rf, ok := ret.Get(1).(func(*rds.ResetDBParameterGroupInput) *rds.DBParameterGroupNameMessage); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.DBParameterGroupNameMessage)
		}
	}

	return r0, r1
}

// ResetDBParameterGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) ResetDBParameterGroupWithContext(_a0 context.Context, _a1 *rds.ResetDBParameterGroupInput, _a2 ...request.Option) (*rds.DBParameterGroupNameMessage, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.DBParameterGroupNameMessage
	if rf, ok := ret.Get(0).(func(context.Context, *rds.ResetDBParameterGroupInput, ...request.Option) *rds.DBParameterGroupNameMessage); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.DBParameterGroupNameMessage)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.ResetDBParameterGroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreDBClusterFromS3 provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RestoreDBClusterFromS3(_a0 *rds.RestoreDBClusterFromS3Input) (*rds.RestoreDBClusterFromS3Output, error) {
	ret := _m.Called(_a0)

	var r0 *rds.RestoreDBClusterFromS3Output
	if rf, ok := ret.Get(0).(func(*rds.RestoreDBClusterFromS3Input) *rds.RestoreDBClusterFromS3Output); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RestoreDBClusterFromS3Output)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.RestoreDBClusterFromS3Input) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreDBClusterFromS3Request provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RestoreDBClusterFromS3Request(_a0 *rds.RestoreDBClusterFromS3Input) (*request.Request, *rds.RestoreDBClusterFromS3Output) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.RestoreDBClusterFromS3Input) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.RestoreDBClusterFromS3Output
	if rf, ok := ret.Get(1).(func(*rds.RestoreDBClusterFromS3Input) *rds.RestoreDBClusterFromS3Output); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.RestoreDBClusterFromS3Output)
		}
	}

	return r0, r1
}

// RestoreDBClusterFromS3WithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) RestoreDBClusterFromS3WithContext(_a0 context.Context, _a1 *rds.RestoreDBClusterFromS3Input, _a2 ...request.Option) (*rds.RestoreDBClusterFromS3Output, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.RestoreDBClusterFromS3Output
	if rf, ok := ret.Get(0).(func(context.Context, *rds.RestoreDBClusterFromS3Input, ...request.Option) *rds.RestoreDBClusterFromS3Output); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RestoreDBClusterFromS3Output)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.RestoreDBClusterFromS3Input, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreDBClusterFromSnapshot provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RestoreDBClusterFromSnapshot(_a0 *rds.RestoreDBClusterFromSnapshotInput) (*rds.RestoreDBClusterFromSnapshotOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.RestoreDBClusterFromSnapshotOutput
	if rf, ok := ret.Get(0).(func(*rds.RestoreDBClusterFromSnapshotInput) *rds.RestoreDBClusterFromSnapshotOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RestoreDBClusterFromSnapshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.RestoreDBClusterFromSnapshotInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreDBClusterFromSnapshotRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RestoreDBClusterFromSnapshotRequest(_a0 *rds.RestoreDBClusterFromSnapshotInput) (*request.Request, *rds.RestoreDBClusterFromSnapshotOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.RestoreDBClusterFromSnapshotInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.RestoreDBClusterFromSnapshotOutput
	if rf, ok := ret.Get(1).(func(*rds.RestoreDBClusterFromSnapshotInput) *rds.RestoreDBClusterFromSnapshotOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.RestoreDBClusterFromSnapshotOutput)
		}
	}

	return r0, r1
}

// RestoreDBClusterFromSnapshotWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) RestoreDBClusterFromSnapshotWithContext(_a0 context.Context, _a1 *rds.RestoreDBClusterFromSnapshotInput, _a2 ...request.Option) (*rds.RestoreDBClusterFromSnapshotOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.RestoreDBClusterFromSnapshotOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.RestoreDBClusterFromSnapshotInput, ...request.Option) *rds.RestoreDBClusterFromSnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RestoreDBClusterFromSnapshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.RestoreDBClusterFromSnapshotInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreDBClusterToPointInTime provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RestoreDBClusterToPointInTime(_a0 *rds.RestoreDBClusterToPointInTimeInput) (*rds.RestoreDBClusterToPointInTimeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.RestoreDBClusterToPointInTimeOutput
	if rf, ok := ret.Get(0).(func(*rds.RestoreDBClusterToPointInTimeInput) *rds.RestoreDBClusterToPointInTimeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RestoreDBClusterToPointInTimeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.RestoreDBClusterToPointInTimeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreDBClusterToPointInTimeRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RestoreDBClusterToPointInTimeRequest(_a0 *rds.RestoreDBClusterToPointInTimeInput) (*request.Request, *rds.RestoreDBClusterToPointInTimeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.RestoreDBClusterToPointInTimeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.RestoreDBClusterToPointInTimeOutput
	if rf, ok := ret.Get(1).(func(*rds.RestoreDBClusterToPointInTimeInput) *rds.RestoreDBClusterToPointInTimeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.RestoreDBClusterToPointInTimeOutput)
		}
	}

	return r0, r1
}

// RestoreDBClusterToPointInTimeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) RestoreDBClusterToPointInTimeWithContext(_a0 context.Context, _a1 *rds.RestoreDBClusterToPointInTimeInput, _a2 ...request.Option) (*rds.RestoreDBClusterToPointInTimeOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.RestoreDBClusterToPointInTimeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.RestoreDBClusterToPointInTimeInput, ...request.Option) *rds.RestoreDBClusterToPointInTimeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RestoreDBClusterToPointInTimeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.RestoreDBClusterToPointInTimeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreDBInstanceFromDBSnapshot provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RestoreDBInstanceFromDBSnapshot(_a0 *rds.RestoreDBInstanceFromDBSnapshotInput) (*rds.RestoreDBInstanceFromDBSnapshotOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.RestoreDBInstanceFromDBSnapshotOutput
	if rf, ok := ret.Get(0).(func(*rds.RestoreDBInstanceFromDBSnapshotInput) *rds.RestoreDBInstanceFromDBSnapshotOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RestoreDBInstanceFromDBSnapshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.RestoreDBInstanceFromDBSnapshotInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreDBInstanceFromDBSnapshotRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RestoreDBInstanceFromDBSnapshotRequest(_a0 *rds.RestoreDBInstanceFromDBSnapshotInput) (*request.Request, *rds.RestoreDBInstanceFromDBSnapshotOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.RestoreDBInstanceFromDBSnapshotInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.RestoreDBInstanceFromDBSnapshotOutput
	if rf, ok := ret.Get(1).(func(*rds.RestoreDBInstanceFromDBSnapshotInput) *rds.RestoreDBInstanceFromDBSnapshotOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.RestoreDBInstanceFromDBSnapshotOutput)
		}
	}

	return r0, r1
}

// RestoreDBInstanceFromDBSnapshotWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) RestoreDBInstanceFromDBSnapshotWithContext(_a0 context.Context, _a1 *rds.RestoreDBInstanceFromDBSnapshotInput, _a2 ...request.Option) (*rds.RestoreDBInstanceFromDBSnapshotOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.RestoreDBInstanceFromDBSnapshotOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.RestoreDBInstanceFromDBSnapshotInput, ...request.Option) *rds.RestoreDBInstanceFromDBSnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RestoreDBInstanceFromDBSnapshotOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.RestoreDBInstanceFromDBSnapshotInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreDBInstanceFromS3 provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RestoreDBInstanceFromS3(_a0 *rds.RestoreDBInstanceFromS3Input) (*rds.RestoreDBInstanceFromS3Output, error) {
	ret := _m.Called(_a0)

	var r0 *rds.RestoreDBInstanceFromS3Output
	if rf, ok := ret.Get(0).(func(*rds.RestoreDBInstanceFromS3Input) *rds.RestoreDBInstanceFromS3Output); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RestoreDBInstanceFromS3Output)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.RestoreDBInstanceFromS3Input) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreDBInstanceFromS3Request provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RestoreDBInstanceFromS3Request(_a0 *rds.RestoreDBInstanceFromS3Input) (*request.Request, *rds.RestoreDBInstanceFromS3Output) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.RestoreDBInstanceFromS3Input) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.RestoreDBInstanceFromS3Output
	if rf, ok := ret.Get(1).(func(*rds.RestoreDBInstanceFromS3Input) *rds.RestoreDBInstanceFromS3Output); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.RestoreDBInstanceFromS3Output)
		}
	}

	return r0, r1
}

// RestoreDBInstanceFromS3WithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) RestoreDBInstanceFromS3WithContext(_a0 context.Context, _a1 *rds.RestoreDBInstanceFromS3Input, _a2 ...request.Option) (*rds.RestoreDBInstanceFromS3Output, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.RestoreDBInstanceFromS3Output
	if rf, ok := ret.Get(0).(func(context.Context, *rds.RestoreDBInstanceFromS3Input, ...request.Option) *rds.RestoreDBInstanceFromS3Output); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RestoreDBInstanceFromS3Output)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.RestoreDBInstanceFromS3Input, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreDBInstanceToPointInTime provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RestoreDBInstanceToPointInTime(_a0 *rds.RestoreDBInstanceToPointInTimeInput) (*rds.RestoreDBInstanceToPointInTimeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.RestoreDBInstanceToPointInTimeOutput
	if rf, ok := ret.Get(0).(func(*rds.RestoreDBInstanceToPointInTimeInput) *rds.RestoreDBInstanceToPointInTimeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RestoreDBInstanceToPointInTimeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.RestoreDBInstanceToPointInTimeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreDBInstanceToPointInTimeRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RestoreDBInstanceToPointInTimeRequest(_a0 *rds.RestoreDBInstanceToPointInTimeInput) (*request.Request, *rds.RestoreDBInstanceToPointInTimeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.RestoreDBInstanceToPointInTimeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.RestoreDBInstanceToPointInTimeOutput
	if rf, ok := ret.Get(1).(func(*rds.RestoreDBInstanceToPointInTimeInput) *rds.RestoreDBInstanceToPointInTimeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.RestoreDBInstanceToPointInTimeOutput)
		}
	}

	return r0, r1
}

// RestoreDBInstanceToPointInTimeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) RestoreDBInstanceToPointInTimeWithContext(_a0 context.Context, _a1 *rds.RestoreDBInstanceToPointInTimeInput, _a2 ...request.Option) (*rds.RestoreDBInstanceToPointInTimeOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.RestoreDBInstanceToPointInTimeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.RestoreDBInstanceToPointInTimeInput, ...request.Option) *rds.RestoreDBInstanceToPointInTimeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RestoreDBInstanceToPointInTimeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.RestoreDBInstanceToPointInTimeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RevokeDBSecurityGroupIngress provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RevokeDBSecurityGroupIngress(_a0 *rds.RevokeDBSecurityGroupIngressInput) (*rds.RevokeDBSecurityGroupIngressOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.RevokeDBSecurityGroupIngressOutput
	if rf, ok := ret.Get(0).(func(*rds.RevokeDBSecurityGroupIngressInput) *rds.RevokeDBSecurityGroupIngressOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RevokeDBSecurityGroupIngressOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.RevokeDBSecurityGroupIngressInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RevokeDBSecurityGroupIngressRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) RevokeDBSecurityGroupIngressRequest(_a0 *rds.RevokeDBSecurityGroupIngressInput) (*request.Request, *rds.RevokeDBSecurityGroupIngressOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.RevokeDBSecurityGroupIngressInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.RevokeDBSecurityGroupIngressOutput
	if rf, ok := ret.Get(1).(func(*rds.RevokeDBSecurityGroupIngressInput) *rds.RevokeDBSecurityGroupIngressOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.RevokeDBSecurityGroupIngressOutput)
		}
	}

	return r0, r1
}

// RevokeDBSecurityGroupIngressWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) RevokeDBSecurityGroupIngressWithContext(_a0 context.Context, _a1 *rds.RevokeDBSecurityGroupIngressInput, _a2 ...request.Option) (*rds.RevokeDBSecurityGroupIngressOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.RevokeDBSecurityGroupIngressOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.RevokeDBSecurityGroupIngressInput, ...request.Option) *rds.RevokeDBSecurityGroupIngressOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.RevokeDBSecurityGroupIngressOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.RevokeDBSecurityGroupIngressInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartActivityStream provides a mock function with given fields: _a0
func (_m *MockFakeRDS) StartActivityStream(_a0 *rds.StartActivityStreamInput) (*rds.StartActivityStreamOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.StartActivityStreamOutput
	if rf, ok := ret.Get(0).(func(*rds.StartActivityStreamInput) *rds.StartActivityStreamOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.StartActivityStreamOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.StartActivityStreamInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartActivityStreamRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) StartActivityStreamRequest(_a0 *rds.StartActivityStreamInput) (*request.Request, *rds.StartActivityStreamOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.StartActivityStreamInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.StartActivityStreamOutput
	if rf, ok := ret.Get(1).(func(*rds.StartActivityStreamInput) *rds.StartActivityStreamOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.StartActivityStreamOutput)
		}
	}

	return r0, r1
}

// StartActivityStreamWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) StartActivityStreamWithContext(_a0 context.Context, _a1 *rds.StartActivityStreamInput, _a2 ...request.Option) (*rds.StartActivityStreamOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.StartActivityStreamOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.StartActivityStreamInput, ...request.Option) *rds.StartActivityStreamOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.StartActivityStreamOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.StartActivityStreamInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartDBCluster provides a mock function with given fields: _a0
func (_m *MockFakeRDS) StartDBCluster(_a0 *rds.StartDBClusterInput) (*rds.StartDBClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.StartDBClusterOutput
	if rf, ok := ret.Get(0).(func(*rds.StartDBClusterInput) *rds.StartDBClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.StartDBClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.StartDBClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartDBClusterRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) StartDBClusterRequest(_a0 *rds.StartDBClusterInput) (*request.Request, *rds.StartDBClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.StartDBClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.StartDBClusterOutput
	if rf, ok := ret.Get(1).(func(*rds.StartDBClusterInput) *rds.StartDBClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.StartDBClusterOutput)
		}
	}

	return r0, r1
}

// StartDBClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) StartDBClusterWithContext(_a0 context.Context, _a1 *rds.StartDBClusterInput, _a2 ...request.Option) (*rds.StartDBClusterOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.StartDBClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.StartDBClusterInput, ...request.Option) *rds.StartDBClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.StartDBClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.StartDBClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartDBInstance provides a mock function with given fields: _a0
func (_m *MockFakeRDS) StartDBInstance(_a0 *rds.StartDBInstanceInput) (*rds.StartDBInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.StartDBInstanceOutput
	if rf, ok := ret.Get(0).(func(*rds.StartDBInstanceInput) *rds.StartDBInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.StartDBInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.StartDBInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartDBInstanceAutomatedBackupsReplication provides a mock function with given fields: _a0
func (_m *MockFakeRDS) StartDBInstanceAutomatedBackupsReplication(_a0 *rds.StartDBInstanceAutomatedBackupsReplicationInput) (*rds.StartDBInstanceAutomatedBackupsReplicationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.StartDBInstanceAutomatedBackupsReplicationOutput
	if rf, ok := ret.Get(0).(func(*rds.StartDBInstanceAutomatedBackupsReplicationInput) *rds.StartDBInstanceAutomatedBackupsReplicationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.StartDBInstanceAutomatedBackupsReplicationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.StartDBInstanceAutomatedBackupsReplicationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartDBInstanceAutomatedBackupsReplicationRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) StartDBInstanceAutomatedBackupsReplicationRequest(_a0 *rds.StartDBInstanceAutomatedBackupsReplicationInput) (*request.Request, *rds.StartDBInstanceAutomatedBackupsReplicationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.StartDBInstanceAutomatedBackupsReplicationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.StartDBInstanceAutomatedBackupsReplicationOutput
	if rf, ok := ret.Get(1).(func(*rds.StartDBInstanceAutomatedBackupsReplicationInput) *rds.StartDBInstanceAutomatedBackupsReplicationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.StartDBInstanceAutomatedBackupsReplicationOutput)
		}
	}

	return r0, r1
}

// StartDBInstanceAutomatedBackupsReplicationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) StartDBInstanceAutomatedBackupsReplicationWithContext(_a0 context.Context, _a1 *rds.StartDBInstanceAutomatedBackupsReplicationInput, _a2 ...request.Option) (*rds.StartDBInstanceAutomatedBackupsReplicationOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.StartDBInstanceAutomatedBackupsReplicationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.StartDBInstanceAutomatedBackupsReplicationInput, ...request.Option) *rds.StartDBInstanceAutomatedBackupsReplicationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.StartDBInstanceAutomatedBackupsReplicationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.StartDBInstanceAutomatedBackupsReplicationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartDBInstanceRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) StartDBInstanceRequest(_a0 *rds.StartDBInstanceInput) (*request.Request, *rds.StartDBInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.StartDBInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.StartDBInstanceOutput
	if rf, ok := ret.Get(1).(func(*rds.StartDBInstanceInput) *rds.StartDBInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.StartDBInstanceOutput)
		}
	}

	return r0, r1
}

// StartDBInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) StartDBInstanceWithContext(_a0 context.Context, _a1 *rds.StartDBInstanceInput, _a2 ...request.Option) (*rds.StartDBInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.StartDBInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.StartDBInstanceInput, ...request.Option) *rds.StartDBInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.StartDBInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.StartDBInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartExportTask provides a mock function with given fields: _a0
func (_m *MockFakeRDS) StartExportTask(_a0 *rds.StartExportTaskInput) (*rds.StartExportTaskOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.StartExportTaskOutput
	if rf, ok := ret.Get(0).(func(*rds.StartExportTaskInput) *rds.StartExportTaskOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.StartExportTaskOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.StartExportTaskInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StartExportTaskRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) StartExportTaskRequest(_a0 *rds.StartExportTaskInput) (*request.Request, *rds.StartExportTaskOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.StartExportTaskInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.StartExportTaskOutput
	if rf, ok := ret.Get(1).(func(*rds.StartExportTaskInput) *rds.StartExportTaskOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.StartExportTaskOutput)
		}
	}

	return r0, r1
}

// StartExportTaskWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) StartExportTaskWithContext(_a0 context.Context, _a1 *rds.StartExportTaskInput, _a2 ...request.Option) (*rds.StartExportTaskOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.StartExportTaskOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.StartExportTaskInput, ...request.Option) *rds.StartExportTaskOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.StartExportTaskOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.StartExportTaskInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopActivityStream provides a mock function with given fields: _a0
func (_m *MockFakeRDS) StopActivityStream(_a0 *rds.StopActivityStreamInput) (*rds.StopActivityStreamOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.StopActivityStreamOutput
	if rf, ok := ret.Get(0).(func(*rds.StopActivityStreamInput) *rds.StopActivityStreamOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.StopActivityStreamOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.StopActivityStreamInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopActivityStreamRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) StopActivityStreamRequest(_a0 *rds.StopActivityStreamInput) (*request.Request, *rds.StopActivityStreamOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.StopActivityStreamInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.StopActivityStreamOutput
	if rf, ok := ret.Get(1).(func(*rds.StopActivityStreamInput) *rds.StopActivityStreamOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.StopActivityStreamOutput)
		}
	}

	return r0, r1
}

// StopActivityStreamWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) StopActivityStreamWithContext(_a0 context.Context, _a1 *rds.StopActivityStreamInput, _a2 ...request.Option) (*rds.StopActivityStreamOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.StopActivityStreamOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.StopActivityStreamInput, ...request.Option) *rds.StopActivityStreamOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.StopActivityStreamOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.StopActivityStreamInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopDBCluster provides a mock function with given fields: _a0
func (_m *MockFakeRDS) StopDBCluster(_a0 *rds.StopDBClusterInput) (*rds.StopDBClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.StopDBClusterOutput
	if rf, ok := ret.Get(0).(func(*rds.StopDBClusterInput) *rds.StopDBClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.StopDBClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.StopDBClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopDBClusterRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) StopDBClusterRequest(_a0 *rds.StopDBClusterInput) (*request.Request, *rds.StopDBClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.StopDBClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.StopDBClusterOutput
	if rf, ok := ret.Get(1).(func(*rds.StopDBClusterInput) *rds.StopDBClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.StopDBClusterOutput)
		}
	}

	return r0, r1
}

// StopDBClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) StopDBClusterWithContext(_a0 context.Context, _a1 *rds.StopDBClusterInput, _a2 ...request.Option) (*rds.StopDBClusterOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.StopDBClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.StopDBClusterInput, ...request.Option) *rds.StopDBClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.StopDBClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.StopDBClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopDBInstance provides a mock function with given fields: _a0
func (_m *MockFakeRDS) StopDBInstance(_a0 *rds.StopDBInstanceInput) (*rds.StopDBInstanceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.StopDBInstanceOutput
	if rf, ok := ret.Get(0).(func(*rds.StopDBInstanceInput) *rds.StopDBInstanceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.StopDBInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.StopDBInstanceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopDBInstanceAutomatedBackupsReplication provides a mock function with given fields: _a0
func (_m *MockFakeRDS) StopDBInstanceAutomatedBackupsReplication(_a0 *rds.StopDBInstanceAutomatedBackupsReplicationInput) (*rds.StopDBInstanceAutomatedBackupsReplicationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *rds.StopDBInstanceAutomatedBackupsReplicationOutput
	if rf, ok := ret.Get(0).(func(*rds.StopDBInstanceAutomatedBackupsReplicationInput) *rds.StopDBInstanceAutomatedBackupsReplicationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.StopDBInstanceAutomatedBackupsReplicationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*rds.StopDBInstanceAutomatedBackupsReplicationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopDBInstanceAutomatedBackupsReplicationRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) StopDBInstanceAutomatedBackupsReplicationRequest(_a0 *rds.StopDBInstanceAutomatedBackupsReplicationInput) (*request.Request, *rds.StopDBInstanceAutomatedBackupsReplicationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.StopDBInstanceAutomatedBackupsReplicationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.StopDBInstanceAutomatedBackupsReplicationOutput
	if rf, ok := ret.Get(1).(func(*rds.StopDBInstanceAutomatedBackupsReplicationInput) *rds.StopDBInstanceAutomatedBackupsReplicationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.StopDBInstanceAutomatedBackupsReplicationOutput)
		}
	}

	return r0, r1
}

// StopDBInstanceAutomatedBackupsReplicationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) StopDBInstanceAutomatedBackupsReplicationWithContext(_a0 context.Context, _a1 *rds.StopDBInstanceAutomatedBackupsReplicationInput, _a2 ...request.Option) (*rds.StopDBInstanceAutomatedBackupsReplicationOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.StopDBInstanceAutomatedBackupsReplicationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.StopDBInstanceAutomatedBackupsReplicationInput, ...request.Option) *rds.StopDBInstanceAutomatedBackupsReplicationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.StopDBInstanceAutomatedBackupsReplicationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.StopDBInstanceAutomatedBackupsReplicationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// StopDBInstanceRequest provides a mock function with given fields: _a0
func (_m *MockFakeRDS) StopDBInstanceRequest(_a0 *rds.StopDBInstanceInput) (*request.Request, *rds.StopDBInstanceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*rds.StopDBInstanceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *rds.StopDBInstanceOutput
	if rf, ok := ret.Get(1).(func(*rds.StopDBInstanceInput) *rds.StopDBInstanceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*rds.StopDBInstanceOutput)
		}
	}

	return r0, r1
}

// StopDBInstanceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) StopDBInstanceWithContext(_a0 context.Context, _a1 *rds.StopDBInstanceInput, _a2 ...request.Option) (*rds.StopDBInstanceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *rds.StopDBInstanceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *rds.StopDBInstanceInput, ...request.Option) *rds.StopDBInstanceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*rds.StopDBInstanceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *rds.StopDBInstanceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// WaitUntilDBClusterSnapshotAvailable provides a mock function with given fields: _a0
func (_m *MockFakeRDS) WaitUntilDBClusterSnapshotAvailable(_a0 *rds.DescribeDBClusterSnapshotsInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClusterSnapshotsInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilDBClusterSnapshotAvailableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) WaitUntilDBClusterSnapshotAvailableWithContext(_a0 context.Context, _a1 *rds.DescribeDBClusterSnapshotsInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBClusterSnapshotsInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilDBClusterSnapshotDeleted provides a mock function with given fields: _a0
func (_m *MockFakeRDS) WaitUntilDBClusterSnapshotDeleted(_a0 *rds.DescribeDBClusterSnapshotsInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBClusterSnapshotsInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilDBClusterSnapshotDeletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) WaitUntilDBClusterSnapshotDeletedWithContext(_a0 context.Context, _a1 *rds.DescribeDBClusterSnapshotsInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBClusterSnapshotsInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilDBInstanceAvailable provides a mock function with given fields: _a0
func (_m *MockFakeRDS) WaitUntilDBInstanceAvailable(_a0 *rds.DescribeDBInstancesInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBInstancesInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilDBInstanceAvailableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) WaitUntilDBInstanceAvailableWithContext(_a0 context.Context, _a1 *rds.DescribeDBInstancesInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBInstancesInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilDBInstanceDeleted provides a mock function with given fields: _a0
func (_m *MockFakeRDS) WaitUntilDBInstanceDeleted(_a0 *rds.DescribeDBInstancesInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBInstancesInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilDBInstanceDeletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) WaitUntilDBInstanceDeletedWithContext(_a0 context.Context, _a1 *rds.DescribeDBInstancesInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBInstancesInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilDBSnapshotAvailable provides a mock function with given fields: _a0
func (_m *MockFakeRDS) WaitUntilDBSnapshotAvailable(_a0 *rds.DescribeDBSnapshotsInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBSnapshotsInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilDBSnapshotAvailableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) WaitUntilDBSnapshotAvailableWithContext(_a0 context.Context, _a1 *rds.DescribeDBSnapshotsInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBSnapshotsInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilDBSnapshotDeleted provides a mock function with given fields: _a0
func (_m *MockFakeRDS) WaitUntilDBSnapshotDeleted(_a0 *rds.DescribeDBSnapshotsInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*rds.DescribeDBSnapshotsInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilDBSnapshotDeletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeRDS) WaitUntilDBSnapshotDeletedWithContext(_a0 context.Context, _a1 *rds.DescribeDBSnapshotsInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *rds.DescribeDBSnapshotsInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}