// Code generated by mockery v2.10.4. DO NOT EDIT.

package aws

import (
	context "context"

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

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

// MockFakeElastiCache is an autogenerated mock type for the FakeElastiCache type
type MockFakeElastiCache struct {
	mock.Mock
}

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

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

	var r1 error
	if rf, ok := ret.Get(1).(func(*elasticache.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 *MockFakeElastiCache) AddTagsToResourceRequest(_a0 *elasticache.AddTagsToResourceInput) (*request.Request, *elasticache.TagListMessage) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// AddTagsToResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) AddTagsToResourceWithContext(_a0 context.Context, _a1 *elasticache.AddTagsToResourceInput, _a2 ...request.Option) (*elasticache.TagListMessage, 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 *elasticache.TagListMessage
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.AddTagsToResourceInput, ...request.Option) *elasticache.TagListMessage); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.TagListMessage)
		}
	}

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

	return r0, r1
}

// AuthorizeCacheSecurityGroupIngress provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) AuthorizeCacheSecurityGroupIngress(_a0 *elasticache.AuthorizeCacheSecurityGroupIngressInput) (*elasticache.AuthorizeCacheSecurityGroupIngressOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.AuthorizeCacheSecurityGroupIngressOutput
	if rf, ok := ret.Get(0).(func(*elasticache.AuthorizeCacheSecurityGroupIngressInput) *elasticache.AuthorizeCacheSecurityGroupIngressOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.AuthorizeCacheSecurityGroupIngressOutput)
		}
	}

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

	return r0, r1
}

// AuthorizeCacheSecurityGroupIngressRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) AuthorizeCacheSecurityGroupIngressRequest(_a0 *elasticache.AuthorizeCacheSecurityGroupIngressInput) (*request.Request, *elasticache.AuthorizeCacheSecurityGroupIngressOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.AuthorizeCacheSecurityGroupIngressOutput
	if rf, ok := ret.Get(1).(func(*elasticache.AuthorizeCacheSecurityGroupIngressInput) *elasticache.AuthorizeCacheSecurityGroupIngressOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.AuthorizeCacheSecurityGroupIngressOutput)
		}
	}

	return r0, r1
}

// AuthorizeCacheSecurityGroupIngressWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) AuthorizeCacheSecurityGroupIngressWithContext(_a0 context.Context, _a1 *elasticache.AuthorizeCacheSecurityGroupIngressInput, _a2 ...request.Option) (*elasticache.AuthorizeCacheSecurityGroupIngressOutput, 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 *elasticache.AuthorizeCacheSecurityGroupIngressOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.AuthorizeCacheSecurityGroupIngressInput, ...request.Option) *elasticache.AuthorizeCacheSecurityGroupIngressOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.AuthorizeCacheSecurityGroupIngressOutput)
		}
	}

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

	return r0, r1
}

// BatchApplyUpdateAction provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) BatchApplyUpdateAction(_a0 *elasticache.BatchApplyUpdateActionInput) (*elasticache.BatchApplyUpdateActionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.BatchApplyUpdateActionOutput
	if rf, ok := ret.Get(0).(func(*elasticache.BatchApplyUpdateActionInput) *elasticache.BatchApplyUpdateActionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.BatchApplyUpdateActionOutput)
		}
	}

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

	return r0, r1
}

// BatchApplyUpdateActionRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) BatchApplyUpdateActionRequest(_a0 *elasticache.BatchApplyUpdateActionInput) (*request.Request, *elasticache.BatchApplyUpdateActionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.BatchApplyUpdateActionOutput
	if rf, ok := ret.Get(1).(func(*elasticache.BatchApplyUpdateActionInput) *elasticache.BatchApplyUpdateActionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.BatchApplyUpdateActionOutput)
		}
	}

	return r0, r1
}

// BatchApplyUpdateActionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) BatchApplyUpdateActionWithContext(_a0 context.Context, _a1 *elasticache.BatchApplyUpdateActionInput, _a2 ...request.Option) (*elasticache.BatchApplyUpdateActionOutput, 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 *elasticache.BatchApplyUpdateActionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.BatchApplyUpdateActionInput, ...request.Option) *elasticache.BatchApplyUpdateActionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.BatchApplyUpdateActionOutput)
		}
	}

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

	return r0, r1
}

// BatchStopUpdateAction provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) BatchStopUpdateAction(_a0 *elasticache.BatchStopUpdateActionInput) (*elasticache.BatchStopUpdateActionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.BatchStopUpdateActionOutput
	if rf, ok := ret.Get(0).(func(*elasticache.BatchStopUpdateActionInput) *elasticache.BatchStopUpdateActionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.BatchStopUpdateActionOutput)
		}
	}

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

	return r0, r1
}

// BatchStopUpdateActionRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) BatchStopUpdateActionRequest(_a0 *elasticache.BatchStopUpdateActionInput) (*request.Request, *elasticache.BatchStopUpdateActionOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.BatchStopUpdateActionOutput
	if rf, ok := ret.Get(1).(func(*elasticache.BatchStopUpdateActionInput) *elasticache.BatchStopUpdateActionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.BatchStopUpdateActionOutput)
		}
	}

	return r0, r1
}

// BatchStopUpdateActionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) BatchStopUpdateActionWithContext(_a0 context.Context, _a1 *elasticache.BatchStopUpdateActionInput, _a2 ...request.Option) (*elasticache.BatchStopUpdateActionOutput, 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 *elasticache.BatchStopUpdateActionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.BatchStopUpdateActionInput, ...request.Option) *elasticache.BatchStopUpdateActionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.BatchStopUpdateActionOutput)
		}
	}

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

	return r0, r1
}

// CompleteMigration provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CompleteMigration(_a0 *elasticache.CompleteMigrationInput) (*elasticache.CompleteMigrationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.CompleteMigrationOutput
	if rf, ok := ret.Get(0).(func(*elasticache.CompleteMigrationInput) *elasticache.CompleteMigrationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CompleteMigrationOutput)
		}
	}

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

	return r0, r1
}

// CompleteMigrationRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CompleteMigrationRequest(_a0 *elasticache.CompleteMigrationInput) (*request.Request, *elasticache.CompleteMigrationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.CompleteMigrationOutput
	if rf, ok := ret.Get(1).(func(*elasticache.CompleteMigrationInput) *elasticache.CompleteMigrationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.CompleteMigrationOutput)
		}
	}

	return r0, r1
}

// CompleteMigrationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) CompleteMigrationWithContext(_a0 context.Context, _a1 *elasticache.CompleteMigrationInput, _a2 ...request.Option) (*elasticache.CompleteMigrationOutput, 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 *elasticache.CompleteMigrationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CompleteMigrationInput, ...request.Option) *elasticache.CompleteMigrationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CompleteMigrationOutput)
		}
	}

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

	return r0, r1
}

// CopySnapshot provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CopySnapshot(_a0 *elasticache.CopySnapshotInput) (*elasticache.CopySnapshotOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.CopySnapshotOutput
	if rf, ok := ret.Get(0).(func(*elasticache.CopySnapshotInput) *elasticache.CopySnapshotOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CopySnapshotOutput)
		}
	}

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

	return r0, r1
}

// CopySnapshotRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CopySnapshotRequest(_a0 *elasticache.CopySnapshotInput) (*request.Request, *elasticache.CopySnapshotOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.CopySnapshotOutput
	if rf, ok := ret.Get(1).(func(*elasticache.CopySnapshotInput) *elasticache.CopySnapshotOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.CopySnapshotOutput)
		}
	}

	return r0, r1
}

// CopySnapshotWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) CopySnapshotWithContext(_a0 context.Context, _a1 *elasticache.CopySnapshotInput, _a2 ...request.Option) (*elasticache.CopySnapshotOutput, 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 *elasticache.CopySnapshotOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CopySnapshotInput, ...request.Option) *elasticache.CopySnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CopySnapshotOutput)
		}
	}

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

	return r0, r1
}

// CreateCacheCluster provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CreateCacheCluster(_a0 *elasticache.CreateCacheClusterInput) (*elasticache.CreateCacheClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.CreateCacheClusterOutput
	if rf, ok := ret.Get(0).(func(*elasticache.CreateCacheClusterInput) *elasticache.CreateCacheClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateCacheClusterOutput)
		}
	}

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

	return r0, r1
}

// CreateCacheClusterRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CreateCacheClusterRequest(_a0 *elasticache.CreateCacheClusterInput) (*request.Request, *elasticache.CreateCacheClusterOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.CreateCacheClusterOutput
	if rf, ok := ret.Get(1).(func(*elasticache.CreateCacheClusterInput) *elasticache.CreateCacheClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.CreateCacheClusterOutput)
		}
	}

	return r0, r1
}

// CreateCacheClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) CreateCacheClusterWithContext(_a0 context.Context, _a1 *elasticache.CreateCacheClusterInput, _a2 ...request.Option) (*elasticache.CreateCacheClusterOutput, 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 *elasticache.CreateCacheClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateCacheClusterInput, ...request.Option) *elasticache.CreateCacheClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateCacheClusterOutput)
		}
	}

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

	return r0, r1
}

// CreateCacheParameterGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CreateCacheParameterGroup(_a0 *elasticache.CreateCacheParameterGroupInput) (*elasticache.CreateCacheParameterGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.CreateCacheParameterGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.CreateCacheParameterGroupInput) *elasticache.CreateCacheParameterGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateCacheParameterGroupOutput)
		}
	}

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

	return r0, r1
}

// CreateCacheParameterGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CreateCacheParameterGroupRequest(_a0 *elasticache.CreateCacheParameterGroupInput) (*request.Request, *elasticache.CreateCacheParameterGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.CreateCacheParameterGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.CreateCacheParameterGroupInput) *elasticache.CreateCacheParameterGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.CreateCacheParameterGroupOutput)
		}
	}

	return r0, r1
}

// CreateCacheParameterGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) CreateCacheParameterGroupWithContext(_a0 context.Context, _a1 *elasticache.CreateCacheParameterGroupInput, _a2 ...request.Option) (*elasticache.CreateCacheParameterGroupOutput, 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 *elasticache.CreateCacheParameterGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateCacheParameterGroupInput, ...request.Option) *elasticache.CreateCacheParameterGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateCacheParameterGroupOutput)
		}
	}

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

	return r0, r1
}

// CreateCacheSecurityGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CreateCacheSecurityGroup(_a0 *elasticache.CreateCacheSecurityGroupInput) (*elasticache.CreateCacheSecurityGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.CreateCacheSecurityGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.CreateCacheSecurityGroupInput) *elasticache.CreateCacheSecurityGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateCacheSecurityGroupOutput)
		}
	}

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

	return r0, r1
}

// CreateCacheSecurityGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CreateCacheSecurityGroupRequest(_a0 *elasticache.CreateCacheSecurityGroupInput) (*request.Request, *elasticache.CreateCacheSecurityGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.CreateCacheSecurityGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.CreateCacheSecurityGroupInput) *elasticache.CreateCacheSecurityGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.CreateCacheSecurityGroupOutput)
		}
	}

	return r0, r1
}

// CreateCacheSecurityGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) CreateCacheSecurityGroupWithContext(_a0 context.Context, _a1 *elasticache.CreateCacheSecurityGroupInput, _a2 ...request.Option) (*elasticache.CreateCacheSecurityGroupOutput, 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 *elasticache.CreateCacheSecurityGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateCacheSecurityGroupInput, ...request.Option) *elasticache.CreateCacheSecurityGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateCacheSecurityGroupOutput)
		}
	}

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

	return r0, r1
}

// CreateCacheSubnetGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CreateCacheSubnetGroup(_a0 *elasticache.CreateCacheSubnetGroupInput) (*elasticache.CreateCacheSubnetGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.CreateCacheSubnetGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.CreateCacheSubnetGroupInput) *elasticache.CreateCacheSubnetGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateCacheSubnetGroupOutput)
		}
	}

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

	return r0, r1
}

// CreateCacheSubnetGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CreateCacheSubnetGroupRequest(_a0 *elasticache.CreateCacheSubnetGroupInput) (*request.Request, *elasticache.CreateCacheSubnetGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.CreateCacheSubnetGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.CreateCacheSubnetGroupInput) *elasticache.CreateCacheSubnetGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.CreateCacheSubnetGroupOutput)
		}
	}

	return r0, r1
}

// CreateCacheSubnetGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) CreateCacheSubnetGroupWithContext(_a0 context.Context, _a1 *elasticache.CreateCacheSubnetGroupInput, _a2 ...request.Option) (*elasticache.CreateCacheSubnetGroupOutput, 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 *elasticache.CreateCacheSubnetGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateCacheSubnetGroupInput, ...request.Option) *elasticache.CreateCacheSubnetGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateCacheSubnetGroupOutput)
		}
	}

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

	return r0, r1
}

// CreateGlobalReplicationGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CreateGlobalReplicationGroup(_a0 *elasticache.CreateGlobalReplicationGroupInput) (*elasticache.CreateGlobalReplicationGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.CreateGlobalReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.CreateGlobalReplicationGroupInput) *elasticache.CreateGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// CreateGlobalReplicationGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CreateGlobalReplicationGroupRequest(_a0 *elasticache.CreateGlobalReplicationGroupInput) (*request.Request, *elasticache.CreateGlobalReplicationGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.CreateGlobalReplicationGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.CreateGlobalReplicationGroupInput) *elasticache.CreateGlobalReplicationGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.CreateGlobalReplicationGroupOutput)
		}
	}

	return r0, r1
}

// CreateGlobalReplicationGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) CreateGlobalReplicationGroupWithContext(_a0 context.Context, _a1 *elasticache.CreateGlobalReplicationGroupInput, _a2 ...request.Option) (*elasticache.CreateGlobalReplicationGroupOutput, 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 *elasticache.CreateGlobalReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateGlobalReplicationGroupInput, ...request.Option) *elasticache.CreateGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// CreateReplicationGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CreateReplicationGroup(_a0 *elasticache.CreateReplicationGroupInput) (*elasticache.CreateReplicationGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.CreateReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.CreateReplicationGroupInput) *elasticache.CreateReplicationGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// CreateReplicationGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CreateReplicationGroupRequest(_a0 *elasticache.CreateReplicationGroupInput) (*request.Request, *elasticache.CreateReplicationGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.CreateReplicationGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.CreateReplicationGroupInput) *elasticache.CreateReplicationGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.CreateReplicationGroupOutput)
		}
	}

	return r0, r1
}

// CreateReplicationGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) CreateReplicationGroupWithContext(_a0 context.Context, _a1 *elasticache.CreateReplicationGroupInput, _a2 ...request.Option) (*elasticache.CreateReplicationGroupOutput, 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 *elasticache.CreateReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateReplicationGroupInput, ...request.Option) *elasticache.CreateReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// CreateSnapshot provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CreateSnapshot(_a0 *elasticache.CreateSnapshotInput) (*elasticache.CreateSnapshotOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.CreateSnapshotOutput
	if rf, ok := ret.Get(0).(func(*elasticache.CreateSnapshotInput) *elasticache.CreateSnapshotOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateSnapshotOutput)
		}
	}

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

	return r0, r1
}

// CreateSnapshotRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CreateSnapshotRequest(_a0 *elasticache.CreateSnapshotInput) (*request.Request, *elasticache.CreateSnapshotOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.CreateSnapshotOutput
	if rf, ok := ret.Get(1).(func(*elasticache.CreateSnapshotInput) *elasticache.CreateSnapshotOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.CreateSnapshotOutput)
		}
	}

	return r0, r1
}

// CreateSnapshotWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) CreateSnapshotWithContext(_a0 context.Context, _a1 *elasticache.CreateSnapshotInput, _a2 ...request.Option) (*elasticache.CreateSnapshotOutput, 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 *elasticache.CreateSnapshotOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateSnapshotInput, ...request.Option) *elasticache.CreateSnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateSnapshotOutput)
		}
	}

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

	return r0, r1
}

// CreateUser provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CreateUser(_a0 *elasticache.CreateUserInput) (*elasticache.CreateUserOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.CreateUserOutput
	if rf, ok := ret.Get(0).(func(*elasticache.CreateUserInput) *elasticache.CreateUserOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateUserOutput)
		}
	}

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

	return r0, r1
}

// CreateUserGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CreateUserGroup(_a0 *elasticache.CreateUserGroupInput) (*elasticache.CreateUserGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.CreateUserGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.CreateUserGroupInput) *elasticache.CreateUserGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateUserGroupOutput)
		}
	}

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

	return r0, r1
}

// CreateUserGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CreateUserGroupRequest(_a0 *elasticache.CreateUserGroupInput) (*request.Request, *elasticache.CreateUserGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.CreateUserGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.CreateUserGroupInput) *elasticache.CreateUserGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.CreateUserGroupOutput)
		}
	}

	return r0, r1
}

// CreateUserGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) CreateUserGroupWithContext(_a0 context.Context, _a1 *elasticache.CreateUserGroupInput, _a2 ...request.Option) (*elasticache.CreateUserGroupOutput, 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 *elasticache.CreateUserGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateUserGroupInput, ...request.Option) *elasticache.CreateUserGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateUserGroupOutput)
		}
	}

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

	return r0, r1
}

// CreateUserRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) CreateUserRequest(_a0 *elasticache.CreateUserInput) (*request.Request, *elasticache.CreateUserOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.CreateUserOutput
	if rf, ok := ret.Get(1).(func(*elasticache.CreateUserInput) *elasticache.CreateUserOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.CreateUserOutput)
		}
	}

	return r0, r1
}

// CreateUserWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) CreateUserWithContext(_a0 context.Context, _a1 *elasticache.CreateUserInput, _a2 ...request.Option) (*elasticache.CreateUserOutput, 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 *elasticache.CreateUserOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateUserInput, ...request.Option) *elasticache.CreateUserOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateUserOutput)
		}
	}

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

	return r0, r1
}

// DecreaseNodeGroupsInGlobalReplicationGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DecreaseNodeGroupsInGlobalReplicationGroup(_a0 *elasticache.DecreaseNodeGroupsInGlobalReplicationGroupInput) (*elasticache.DecreaseNodeGroupsInGlobalReplicationGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DecreaseNodeGroupsInGlobalReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DecreaseNodeGroupsInGlobalReplicationGroupInput) *elasticache.DecreaseNodeGroupsInGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DecreaseNodeGroupsInGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// DecreaseNodeGroupsInGlobalReplicationGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DecreaseNodeGroupsInGlobalReplicationGroupRequest(_a0 *elasticache.DecreaseNodeGroupsInGlobalReplicationGroupInput) (*request.Request, *elasticache.DecreaseNodeGroupsInGlobalReplicationGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DecreaseNodeGroupsInGlobalReplicationGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DecreaseNodeGroupsInGlobalReplicationGroupInput) *elasticache.DecreaseNodeGroupsInGlobalReplicationGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DecreaseNodeGroupsInGlobalReplicationGroupOutput)
		}
	}

	return r0, r1
}

// DecreaseNodeGroupsInGlobalReplicationGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DecreaseNodeGroupsInGlobalReplicationGroupWithContext(_a0 context.Context, _a1 *elasticache.DecreaseNodeGroupsInGlobalReplicationGroupInput, _a2 ...request.Option) (*elasticache.DecreaseNodeGroupsInGlobalReplicationGroupOutput, 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 *elasticache.DecreaseNodeGroupsInGlobalReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DecreaseNodeGroupsInGlobalReplicationGroupInput, ...request.Option) *elasticache.DecreaseNodeGroupsInGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DecreaseNodeGroupsInGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// DecreaseReplicaCount provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DecreaseReplicaCount(_a0 *elasticache.DecreaseReplicaCountInput) (*elasticache.DecreaseReplicaCountOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DecreaseReplicaCountOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DecreaseReplicaCountInput) *elasticache.DecreaseReplicaCountOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DecreaseReplicaCountOutput)
		}
	}

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

	return r0, r1
}

// DecreaseReplicaCountRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DecreaseReplicaCountRequest(_a0 *elasticache.DecreaseReplicaCountInput) (*request.Request, *elasticache.DecreaseReplicaCountOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DecreaseReplicaCountOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DecreaseReplicaCountInput) *elasticache.DecreaseReplicaCountOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DecreaseReplicaCountOutput)
		}
	}

	return r0, r1
}

// DecreaseReplicaCountWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DecreaseReplicaCountWithContext(_a0 context.Context, _a1 *elasticache.DecreaseReplicaCountInput, _a2 ...request.Option) (*elasticache.DecreaseReplicaCountOutput, 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 *elasticache.DecreaseReplicaCountOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DecreaseReplicaCountInput, ...request.Option) *elasticache.DecreaseReplicaCountOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DecreaseReplicaCountOutput)
		}
	}

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

	return r0, r1
}

// DeleteCacheCluster provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DeleteCacheCluster(_a0 *elasticache.DeleteCacheClusterInput) (*elasticache.DeleteCacheClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DeleteCacheClusterOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DeleteCacheClusterInput) *elasticache.DeleteCacheClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteCacheClusterOutput)
		}
	}

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

	return r0, r1
}

// DeleteCacheClusterRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DeleteCacheClusterRequest(_a0 *elasticache.DeleteCacheClusterInput) (*request.Request, *elasticache.DeleteCacheClusterOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DeleteCacheClusterOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DeleteCacheClusterInput) *elasticache.DeleteCacheClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DeleteCacheClusterOutput)
		}
	}

	return r0, r1
}

// DeleteCacheClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DeleteCacheClusterWithContext(_a0 context.Context, _a1 *elasticache.DeleteCacheClusterInput, _a2 ...request.Option) (*elasticache.DeleteCacheClusterOutput, 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 *elasticache.DeleteCacheClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteCacheClusterInput, ...request.Option) *elasticache.DeleteCacheClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteCacheClusterOutput)
		}
	}

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

	return r0, r1
}

// DeleteCacheParameterGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DeleteCacheParameterGroup(_a0 *elasticache.DeleteCacheParameterGroupInput) (*elasticache.DeleteCacheParameterGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DeleteCacheParameterGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DeleteCacheParameterGroupInput) *elasticache.DeleteCacheParameterGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteCacheParameterGroupOutput)
		}
	}

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

	return r0, r1
}

// DeleteCacheParameterGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DeleteCacheParameterGroupRequest(_a0 *elasticache.DeleteCacheParameterGroupInput) (*request.Request, *elasticache.DeleteCacheParameterGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DeleteCacheParameterGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DeleteCacheParameterGroupInput) *elasticache.DeleteCacheParameterGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DeleteCacheParameterGroupOutput)
		}
	}

	return r0, r1
}

// DeleteCacheParameterGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DeleteCacheParameterGroupWithContext(_a0 context.Context, _a1 *elasticache.DeleteCacheParameterGroupInput, _a2 ...request.Option) (*elasticache.DeleteCacheParameterGroupOutput, 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 *elasticache.DeleteCacheParameterGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteCacheParameterGroupInput, ...request.Option) *elasticache.DeleteCacheParameterGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteCacheParameterGroupOutput)
		}
	}

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

	return r0, r1
}

// DeleteCacheSecurityGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DeleteCacheSecurityGroup(_a0 *elasticache.DeleteCacheSecurityGroupInput) (*elasticache.DeleteCacheSecurityGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DeleteCacheSecurityGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DeleteCacheSecurityGroupInput) *elasticache.DeleteCacheSecurityGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteCacheSecurityGroupOutput)
		}
	}

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

	return r0, r1
}

// DeleteCacheSecurityGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DeleteCacheSecurityGroupRequest(_a0 *elasticache.DeleteCacheSecurityGroupInput) (*request.Request, *elasticache.DeleteCacheSecurityGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DeleteCacheSecurityGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DeleteCacheSecurityGroupInput) *elasticache.DeleteCacheSecurityGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DeleteCacheSecurityGroupOutput)
		}
	}

	return r0, r1
}

// DeleteCacheSecurityGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DeleteCacheSecurityGroupWithContext(_a0 context.Context, _a1 *elasticache.DeleteCacheSecurityGroupInput, _a2 ...request.Option) (*elasticache.DeleteCacheSecurityGroupOutput, 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 *elasticache.DeleteCacheSecurityGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteCacheSecurityGroupInput, ...request.Option) *elasticache.DeleteCacheSecurityGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteCacheSecurityGroupOutput)
		}
	}

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

	return r0, r1
}

// DeleteCacheSubnetGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DeleteCacheSubnetGroup(_a0 *elasticache.DeleteCacheSubnetGroupInput) (*elasticache.DeleteCacheSubnetGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DeleteCacheSubnetGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DeleteCacheSubnetGroupInput) *elasticache.DeleteCacheSubnetGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteCacheSubnetGroupOutput)
		}
	}

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

	return r0, r1
}

// DeleteCacheSubnetGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DeleteCacheSubnetGroupRequest(_a0 *elasticache.DeleteCacheSubnetGroupInput) (*request.Request, *elasticache.DeleteCacheSubnetGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DeleteCacheSubnetGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DeleteCacheSubnetGroupInput) *elasticache.DeleteCacheSubnetGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DeleteCacheSubnetGroupOutput)
		}
	}

	return r0, r1
}

// DeleteCacheSubnetGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DeleteCacheSubnetGroupWithContext(_a0 context.Context, _a1 *elasticache.DeleteCacheSubnetGroupInput, _a2 ...request.Option) (*elasticache.DeleteCacheSubnetGroupOutput, 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 *elasticache.DeleteCacheSubnetGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteCacheSubnetGroupInput, ...request.Option) *elasticache.DeleteCacheSubnetGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteCacheSubnetGroupOutput)
		}
	}

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

	return r0, r1
}

// DeleteGlobalReplicationGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DeleteGlobalReplicationGroup(_a0 *elasticache.DeleteGlobalReplicationGroupInput) (*elasticache.DeleteGlobalReplicationGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DeleteGlobalReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DeleteGlobalReplicationGroupInput) *elasticache.DeleteGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// DeleteGlobalReplicationGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DeleteGlobalReplicationGroupRequest(_a0 *elasticache.DeleteGlobalReplicationGroupInput) (*request.Request, *elasticache.DeleteGlobalReplicationGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DeleteGlobalReplicationGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DeleteGlobalReplicationGroupInput) *elasticache.DeleteGlobalReplicationGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DeleteGlobalReplicationGroupOutput)
		}
	}

	return r0, r1
}

// DeleteGlobalReplicationGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DeleteGlobalReplicationGroupWithContext(_a0 context.Context, _a1 *elasticache.DeleteGlobalReplicationGroupInput, _a2 ...request.Option) (*elasticache.DeleteGlobalReplicationGroupOutput, 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 *elasticache.DeleteGlobalReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteGlobalReplicationGroupInput, ...request.Option) *elasticache.DeleteGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// DeleteReplicationGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DeleteReplicationGroup(_a0 *elasticache.DeleteReplicationGroupInput) (*elasticache.DeleteReplicationGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DeleteReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DeleteReplicationGroupInput) *elasticache.DeleteReplicationGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// DeleteReplicationGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DeleteReplicationGroupRequest(_a0 *elasticache.DeleteReplicationGroupInput) (*request.Request, *elasticache.DeleteReplicationGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DeleteReplicationGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DeleteReplicationGroupInput) *elasticache.DeleteReplicationGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DeleteReplicationGroupOutput)
		}
	}

	return r0, r1
}

// DeleteReplicationGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DeleteReplicationGroupWithContext(_a0 context.Context, _a1 *elasticache.DeleteReplicationGroupInput, _a2 ...request.Option) (*elasticache.DeleteReplicationGroupOutput, 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 *elasticache.DeleteReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteReplicationGroupInput, ...request.Option) *elasticache.DeleteReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// DeleteSnapshot provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DeleteSnapshot(_a0 *elasticache.DeleteSnapshotInput) (*elasticache.DeleteSnapshotOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DeleteSnapshotOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DeleteSnapshotInput) *elasticache.DeleteSnapshotOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteSnapshotOutput)
		}
	}

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

	return r0, r1
}

// DeleteSnapshotRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DeleteSnapshotRequest(_a0 *elasticache.DeleteSnapshotInput) (*request.Request, *elasticache.DeleteSnapshotOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DeleteSnapshotOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DeleteSnapshotInput) *elasticache.DeleteSnapshotOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DeleteSnapshotOutput)
		}
	}

	return r0, r1
}

// DeleteSnapshotWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DeleteSnapshotWithContext(_a0 context.Context, _a1 *elasticache.DeleteSnapshotInput, _a2 ...request.Option) (*elasticache.DeleteSnapshotOutput, 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 *elasticache.DeleteSnapshotOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteSnapshotInput, ...request.Option) *elasticache.DeleteSnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteSnapshotOutput)
		}
	}

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

	return r0, r1
}

// DeleteUser provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DeleteUser(_a0 *elasticache.DeleteUserInput) (*elasticache.DeleteUserOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DeleteUserOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DeleteUserInput) *elasticache.DeleteUserOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteUserOutput)
		}
	}

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

	return r0, r1
}

// DeleteUserGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DeleteUserGroup(_a0 *elasticache.DeleteUserGroupInput) (*elasticache.DeleteUserGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DeleteUserGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DeleteUserGroupInput) *elasticache.DeleteUserGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteUserGroupOutput)
		}
	}

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

	return r0, r1
}

// DeleteUserGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DeleteUserGroupRequest(_a0 *elasticache.DeleteUserGroupInput) (*request.Request, *elasticache.DeleteUserGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DeleteUserGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DeleteUserGroupInput) *elasticache.DeleteUserGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DeleteUserGroupOutput)
		}
	}

	return r0, r1
}

// DeleteUserGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DeleteUserGroupWithContext(_a0 context.Context, _a1 *elasticache.DeleteUserGroupInput, _a2 ...request.Option) (*elasticache.DeleteUserGroupOutput, 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 *elasticache.DeleteUserGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteUserGroupInput, ...request.Option) *elasticache.DeleteUserGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteUserGroupOutput)
		}
	}

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

	return r0, r1
}

// DeleteUserRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DeleteUserRequest(_a0 *elasticache.DeleteUserInput) (*request.Request, *elasticache.DeleteUserOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DeleteUserOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DeleteUserInput) *elasticache.DeleteUserOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DeleteUserOutput)
		}
	}

	return r0, r1
}

// DeleteUserWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DeleteUserWithContext(_a0 context.Context, _a1 *elasticache.DeleteUserInput, _a2 ...request.Option) (*elasticache.DeleteUserOutput, 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 *elasticache.DeleteUserOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteUserInput, ...request.Option) *elasticache.DeleteUserOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteUserOutput)
		}
	}

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

	return r0, r1
}

// DescribeCacheClusters provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeCacheClusters(_a0 *elasticache.DescribeCacheClustersInput) (*elasticache.DescribeCacheClustersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DescribeCacheClustersOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeCacheClustersInput) *elasticache.DescribeCacheClustersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeCacheClustersOutput)
		}
	}

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

	return r0, r1
}

// DescribeCacheClustersPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeElastiCache) DescribeCacheClustersPages(_a0 *elasticache.DescribeCacheClustersInput, _a1 func(*elasticache.DescribeCacheClustersOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeCacheClustersPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeElastiCache) DescribeCacheClustersPagesWithContext(_a0 context.Context, _a1 *elasticache.DescribeCacheClustersInput, _a2 func(*elasticache.DescribeCacheClustersOutput, 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, *elasticache.DescribeCacheClustersInput, func(*elasticache.DescribeCacheClustersOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeCacheClustersRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeCacheClustersRequest(_a0 *elasticache.DescribeCacheClustersInput) (*request.Request, *elasticache.DescribeCacheClustersOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DescribeCacheClustersOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DescribeCacheClustersInput) *elasticache.DescribeCacheClustersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DescribeCacheClustersOutput)
		}
	}

	return r0, r1
}

// DescribeCacheClustersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DescribeCacheClustersWithContext(_a0 context.Context, _a1 *elasticache.DescribeCacheClustersInput, _a2 ...request.Option) (*elasticache.DescribeCacheClustersOutput, 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 *elasticache.DescribeCacheClustersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeCacheClustersInput, ...request.Option) *elasticache.DescribeCacheClustersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeCacheClustersOutput)
		}
	}

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

	return r0, r1
}

// DescribeCacheEngineVersions provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeCacheEngineVersions(_a0 *elasticache.DescribeCacheEngineVersionsInput) (*elasticache.DescribeCacheEngineVersionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DescribeCacheEngineVersionsOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeCacheEngineVersionsInput) *elasticache.DescribeCacheEngineVersionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeCacheEngineVersionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeCacheEngineVersionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeElastiCache) DescribeCacheEngineVersionsPages(_a0 *elasticache.DescribeCacheEngineVersionsInput, _a1 func(*elasticache.DescribeCacheEngineVersionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeCacheEngineVersionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeElastiCache) DescribeCacheEngineVersionsPagesWithContext(_a0 context.Context, _a1 *elasticache.DescribeCacheEngineVersionsInput, _a2 func(*elasticache.DescribeCacheEngineVersionsOutput, 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, *elasticache.DescribeCacheEngineVersionsInput, func(*elasticache.DescribeCacheEngineVersionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeCacheEngineVersionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeCacheEngineVersionsRequest(_a0 *elasticache.DescribeCacheEngineVersionsInput) (*request.Request, *elasticache.DescribeCacheEngineVersionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DescribeCacheEngineVersionsOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DescribeCacheEngineVersionsInput) *elasticache.DescribeCacheEngineVersionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DescribeCacheEngineVersionsOutput)
		}
	}

	return r0, r1
}

// DescribeCacheEngineVersionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DescribeCacheEngineVersionsWithContext(_a0 context.Context, _a1 *elasticache.DescribeCacheEngineVersionsInput, _a2 ...request.Option) (*elasticache.DescribeCacheEngineVersionsOutput, 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 *elasticache.DescribeCacheEngineVersionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeCacheEngineVersionsInput, ...request.Option) *elasticache.DescribeCacheEngineVersionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeCacheEngineVersionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeCacheParameterGroups provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeCacheParameterGroups(_a0 *elasticache.DescribeCacheParameterGroupsInput) (*elasticache.DescribeCacheParameterGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DescribeCacheParameterGroupsOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeCacheParameterGroupsInput) *elasticache.DescribeCacheParameterGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeCacheParameterGroupsOutput)
		}
	}

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

	return r0, r1
}

// DescribeCacheParameterGroupsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeElastiCache) DescribeCacheParameterGroupsPages(_a0 *elasticache.DescribeCacheParameterGroupsInput, _a1 func(*elasticache.DescribeCacheParameterGroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeCacheParameterGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeElastiCache) DescribeCacheParameterGroupsPagesWithContext(_a0 context.Context, _a1 *elasticache.DescribeCacheParameterGroupsInput, _a2 func(*elasticache.DescribeCacheParameterGroupsOutput, 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, *elasticache.DescribeCacheParameterGroupsInput, func(*elasticache.DescribeCacheParameterGroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeCacheParameterGroupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeCacheParameterGroupsRequest(_a0 *elasticache.DescribeCacheParameterGroupsInput) (*request.Request, *elasticache.DescribeCacheParameterGroupsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DescribeCacheParameterGroupsOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DescribeCacheParameterGroupsInput) *elasticache.DescribeCacheParameterGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DescribeCacheParameterGroupsOutput)
		}
	}

	return r0, r1
}

// DescribeCacheParameterGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DescribeCacheParameterGroupsWithContext(_a0 context.Context, _a1 *elasticache.DescribeCacheParameterGroupsInput, _a2 ...request.Option) (*elasticache.DescribeCacheParameterGroupsOutput, 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 *elasticache.DescribeCacheParameterGroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeCacheParameterGroupsInput, ...request.Option) *elasticache.DescribeCacheParameterGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeCacheParameterGroupsOutput)
		}
	}

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

	return r0, r1
}

// DescribeCacheParameters provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeCacheParameters(_a0 *elasticache.DescribeCacheParametersInput) (*elasticache.DescribeCacheParametersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DescribeCacheParametersOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeCacheParametersInput) *elasticache.DescribeCacheParametersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeCacheParametersOutput)
		}
	}

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

	return r0, r1
}

// DescribeCacheParametersPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeElastiCache) DescribeCacheParametersPages(_a0 *elasticache.DescribeCacheParametersInput, _a1 func(*elasticache.DescribeCacheParametersOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeCacheParametersPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeElastiCache) DescribeCacheParametersPagesWithContext(_a0 context.Context, _a1 *elasticache.DescribeCacheParametersInput, _a2 func(*elasticache.DescribeCacheParametersOutput, 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, *elasticache.DescribeCacheParametersInput, func(*elasticache.DescribeCacheParametersOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeCacheParametersRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeCacheParametersRequest(_a0 *elasticache.DescribeCacheParametersInput) (*request.Request, *elasticache.DescribeCacheParametersOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DescribeCacheParametersOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DescribeCacheParametersInput) *elasticache.DescribeCacheParametersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DescribeCacheParametersOutput)
		}
	}

	return r0, r1
}

// DescribeCacheParametersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DescribeCacheParametersWithContext(_a0 context.Context, _a1 *elasticache.DescribeCacheParametersInput, _a2 ...request.Option) (*elasticache.DescribeCacheParametersOutput, 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 *elasticache.DescribeCacheParametersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeCacheParametersInput, ...request.Option) *elasticache.DescribeCacheParametersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeCacheParametersOutput)
		}
	}

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

	return r0, r1
}

// DescribeCacheSecurityGroups provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeCacheSecurityGroups(_a0 *elasticache.DescribeCacheSecurityGroupsInput) (*elasticache.DescribeCacheSecurityGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DescribeCacheSecurityGroupsOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeCacheSecurityGroupsInput) *elasticache.DescribeCacheSecurityGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeCacheSecurityGroupsOutput)
		}
	}

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

	return r0, r1
}

// DescribeCacheSecurityGroupsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeElastiCache) DescribeCacheSecurityGroupsPages(_a0 *elasticache.DescribeCacheSecurityGroupsInput, _a1 func(*elasticache.DescribeCacheSecurityGroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeCacheSecurityGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeElastiCache) DescribeCacheSecurityGroupsPagesWithContext(_a0 context.Context, _a1 *elasticache.DescribeCacheSecurityGroupsInput, _a2 func(*elasticache.DescribeCacheSecurityGroupsOutput, 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, *elasticache.DescribeCacheSecurityGroupsInput, func(*elasticache.DescribeCacheSecurityGroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeCacheSecurityGroupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeCacheSecurityGroupsRequest(_a0 *elasticache.DescribeCacheSecurityGroupsInput) (*request.Request, *elasticache.DescribeCacheSecurityGroupsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DescribeCacheSecurityGroupsOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DescribeCacheSecurityGroupsInput) *elasticache.DescribeCacheSecurityGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DescribeCacheSecurityGroupsOutput)
		}
	}

	return r0, r1
}

// DescribeCacheSecurityGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DescribeCacheSecurityGroupsWithContext(_a0 context.Context, _a1 *elasticache.DescribeCacheSecurityGroupsInput, _a2 ...request.Option) (*elasticache.DescribeCacheSecurityGroupsOutput, 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 *elasticache.DescribeCacheSecurityGroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeCacheSecurityGroupsInput, ...request.Option) *elasticache.DescribeCacheSecurityGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeCacheSecurityGroupsOutput)
		}
	}

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

	return r0, r1
}

// DescribeCacheSubnetGroups provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeCacheSubnetGroups(_a0 *elasticache.DescribeCacheSubnetGroupsInput) (*elasticache.DescribeCacheSubnetGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DescribeCacheSubnetGroupsOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeCacheSubnetGroupsInput) *elasticache.DescribeCacheSubnetGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeCacheSubnetGroupsOutput)
		}
	}

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

	return r0, r1
}

// DescribeCacheSubnetGroupsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeElastiCache) DescribeCacheSubnetGroupsPages(_a0 *elasticache.DescribeCacheSubnetGroupsInput, _a1 func(*elasticache.DescribeCacheSubnetGroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeCacheSubnetGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeElastiCache) DescribeCacheSubnetGroupsPagesWithContext(_a0 context.Context, _a1 *elasticache.DescribeCacheSubnetGroupsInput, _a2 func(*elasticache.DescribeCacheSubnetGroupsOutput, 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, *elasticache.DescribeCacheSubnetGroupsInput, func(*elasticache.DescribeCacheSubnetGroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeCacheSubnetGroupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeCacheSubnetGroupsRequest(_a0 *elasticache.DescribeCacheSubnetGroupsInput) (*request.Request, *elasticache.DescribeCacheSubnetGroupsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DescribeCacheSubnetGroupsOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DescribeCacheSubnetGroupsInput) *elasticache.DescribeCacheSubnetGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DescribeCacheSubnetGroupsOutput)
		}
	}

	return r0, r1
}

// DescribeCacheSubnetGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DescribeCacheSubnetGroupsWithContext(_a0 context.Context, _a1 *elasticache.DescribeCacheSubnetGroupsInput, _a2 ...request.Option) (*elasticache.DescribeCacheSubnetGroupsOutput, 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 *elasticache.DescribeCacheSubnetGroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeCacheSubnetGroupsInput, ...request.Option) *elasticache.DescribeCacheSubnetGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeCacheSubnetGroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *elasticache.DescribeCacheSubnetGroupsInput, ...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 *MockFakeElastiCache) DescribeEngineDefaultParameters(_a0 *elasticache.DescribeEngineDefaultParametersInput) (*elasticache.DescribeEngineDefaultParametersOutput, error) {
	ret := _m.Called(_a0)

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

	var r1 error
	if rf, ok := ret.Get(1).(func(*elasticache.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 *MockFakeElastiCache) DescribeEngineDefaultParametersPages(_a0 *elasticache.DescribeEngineDefaultParametersInput, _a1 func(*elasticache.DescribeEngineDefaultParametersOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeEngineDefaultParametersInput, func(*elasticache.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 *MockFakeElastiCache) DescribeEngineDefaultParametersPagesWithContext(_a0 context.Context, _a1 *elasticache.DescribeEngineDefaultParametersInput, _a2 func(*elasticache.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, *elasticache.DescribeEngineDefaultParametersInput, func(*elasticache.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 *MockFakeElastiCache) DescribeEngineDefaultParametersRequest(_a0 *elasticache.DescribeEngineDefaultParametersInput) (*request.Request, *elasticache.DescribeEngineDefaultParametersOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// DescribeEngineDefaultParametersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DescribeEngineDefaultParametersWithContext(_a0 context.Context, _a1 *elasticache.DescribeEngineDefaultParametersInput, _a2 ...request.Option) (*elasticache.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 *elasticache.DescribeEngineDefaultParametersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeEngineDefaultParametersInput, ...request.Option) *elasticache.DescribeEngineDefaultParametersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeEngineDefaultParametersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *elasticache.DescribeEngineDefaultParametersInput, ...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 *MockFakeElastiCache) DescribeEvents(_a0 *elasticache.DescribeEventsInput) (*elasticache.DescribeEventsOutput, error) {
	ret := _m.Called(_a0)

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

	var r1 error
	if rf, ok := ret.Get(1).(func(*elasticache.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 *MockFakeElastiCache) DescribeEventsPages(_a0 *elasticache.DescribeEventsInput, _a1 func(*elasticache.DescribeEventsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeEventsInput, func(*elasticache.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 *MockFakeElastiCache) DescribeEventsPagesWithContext(_a0 context.Context, _a1 *elasticache.DescribeEventsInput, _a2 func(*elasticache.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, *elasticache.DescribeEventsInput, func(*elasticache.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 *MockFakeElastiCache) DescribeEventsRequest(_a0 *elasticache.DescribeEventsInput) (*request.Request, *elasticache.DescribeEventsOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// DescribeEventsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DescribeEventsWithContext(_a0 context.Context, _a1 *elasticache.DescribeEventsInput, _a2 ...request.Option) (*elasticache.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 *elasticache.DescribeEventsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeEventsInput, ...request.Option) *elasticache.DescribeEventsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeEventsOutput)
		}
	}

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

	return r0, r1
}

// DescribeGlobalReplicationGroups provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeGlobalReplicationGroups(_a0 *elasticache.DescribeGlobalReplicationGroupsInput) (*elasticache.DescribeGlobalReplicationGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DescribeGlobalReplicationGroupsOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeGlobalReplicationGroupsInput) *elasticache.DescribeGlobalReplicationGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeGlobalReplicationGroupsOutput)
		}
	}

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

	return r0, r1
}

// DescribeGlobalReplicationGroupsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeElastiCache) DescribeGlobalReplicationGroupsPages(_a0 *elasticache.DescribeGlobalReplicationGroupsInput, _a1 func(*elasticache.DescribeGlobalReplicationGroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeGlobalReplicationGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeElastiCache) DescribeGlobalReplicationGroupsPagesWithContext(_a0 context.Context, _a1 *elasticache.DescribeGlobalReplicationGroupsInput, _a2 func(*elasticache.DescribeGlobalReplicationGroupsOutput, 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, *elasticache.DescribeGlobalReplicationGroupsInput, func(*elasticache.DescribeGlobalReplicationGroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeGlobalReplicationGroupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeGlobalReplicationGroupsRequest(_a0 *elasticache.DescribeGlobalReplicationGroupsInput) (*request.Request, *elasticache.DescribeGlobalReplicationGroupsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DescribeGlobalReplicationGroupsOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DescribeGlobalReplicationGroupsInput) *elasticache.DescribeGlobalReplicationGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DescribeGlobalReplicationGroupsOutput)
		}
	}

	return r0, r1
}

// DescribeGlobalReplicationGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DescribeGlobalReplicationGroupsWithContext(_a0 context.Context, _a1 *elasticache.DescribeGlobalReplicationGroupsInput, _a2 ...request.Option) (*elasticache.DescribeGlobalReplicationGroupsOutput, 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 *elasticache.DescribeGlobalReplicationGroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeGlobalReplicationGroupsInput, ...request.Option) *elasticache.DescribeGlobalReplicationGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeGlobalReplicationGroupsOutput)
		}
	}

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

	return r0, r1
}

// DescribeReplicationGroups provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeReplicationGroups(_a0 *elasticache.DescribeReplicationGroupsInput) (*elasticache.DescribeReplicationGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DescribeReplicationGroupsOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeReplicationGroupsInput) *elasticache.DescribeReplicationGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeReplicationGroupsOutput)
		}
	}

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

	return r0, r1
}

// DescribeReplicationGroupsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeElastiCache) DescribeReplicationGroupsPages(_a0 *elasticache.DescribeReplicationGroupsInput, _a1 func(*elasticache.DescribeReplicationGroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeReplicationGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeElastiCache) DescribeReplicationGroupsPagesWithContext(_a0 context.Context, _a1 *elasticache.DescribeReplicationGroupsInput, _a2 func(*elasticache.DescribeReplicationGroupsOutput, 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, *elasticache.DescribeReplicationGroupsInput, func(*elasticache.DescribeReplicationGroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeReplicationGroupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeReplicationGroupsRequest(_a0 *elasticache.DescribeReplicationGroupsInput) (*request.Request, *elasticache.DescribeReplicationGroupsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DescribeReplicationGroupsOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DescribeReplicationGroupsInput) *elasticache.DescribeReplicationGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DescribeReplicationGroupsOutput)
		}
	}

	return r0, r1
}

// DescribeReplicationGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DescribeReplicationGroupsWithContext(_a0 context.Context, _a1 *elasticache.DescribeReplicationGroupsInput, _a2 ...request.Option) (*elasticache.DescribeReplicationGroupsOutput, 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 *elasticache.DescribeReplicationGroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeReplicationGroupsInput, ...request.Option) *elasticache.DescribeReplicationGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeReplicationGroupsOutput)
		}
	}

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

	return r0, r1
}

// DescribeReservedCacheNodes provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeReservedCacheNodes(_a0 *elasticache.DescribeReservedCacheNodesInput) (*elasticache.DescribeReservedCacheNodesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DescribeReservedCacheNodesOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeReservedCacheNodesInput) *elasticache.DescribeReservedCacheNodesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeReservedCacheNodesOutput)
		}
	}

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

	return r0, r1
}

// DescribeReservedCacheNodesOfferings provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeReservedCacheNodesOfferings(_a0 *elasticache.DescribeReservedCacheNodesOfferingsInput) (*elasticache.DescribeReservedCacheNodesOfferingsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DescribeReservedCacheNodesOfferingsOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeReservedCacheNodesOfferingsInput) *elasticache.DescribeReservedCacheNodesOfferingsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeReservedCacheNodesOfferingsOutput)
		}
	}

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

	return r0, r1
}

// DescribeReservedCacheNodesOfferingsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeElastiCache) DescribeReservedCacheNodesOfferingsPages(_a0 *elasticache.DescribeReservedCacheNodesOfferingsInput, _a1 func(*elasticache.DescribeReservedCacheNodesOfferingsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeReservedCacheNodesOfferingsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeElastiCache) DescribeReservedCacheNodesOfferingsPagesWithContext(_a0 context.Context, _a1 *elasticache.DescribeReservedCacheNodesOfferingsInput, _a2 func(*elasticache.DescribeReservedCacheNodesOfferingsOutput, 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, *elasticache.DescribeReservedCacheNodesOfferingsInput, func(*elasticache.DescribeReservedCacheNodesOfferingsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeReservedCacheNodesOfferingsRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeReservedCacheNodesOfferingsRequest(_a0 *elasticache.DescribeReservedCacheNodesOfferingsInput) (*request.Request, *elasticache.DescribeReservedCacheNodesOfferingsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DescribeReservedCacheNodesOfferingsOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DescribeReservedCacheNodesOfferingsInput) *elasticache.DescribeReservedCacheNodesOfferingsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DescribeReservedCacheNodesOfferingsOutput)
		}
	}

	return r0, r1
}

// DescribeReservedCacheNodesOfferingsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DescribeReservedCacheNodesOfferingsWithContext(_a0 context.Context, _a1 *elasticache.DescribeReservedCacheNodesOfferingsInput, _a2 ...request.Option) (*elasticache.DescribeReservedCacheNodesOfferingsOutput, 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 *elasticache.DescribeReservedCacheNodesOfferingsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeReservedCacheNodesOfferingsInput, ...request.Option) *elasticache.DescribeReservedCacheNodesOfferingsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeReservedCacheNodesOfferingsOutput)
		}
	}

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

	return r0, r1
}

// DescribeReservedCacheNodesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeElastiCache) DescribeReservedCacheNodesPages(_a0 *elasticache.DescribeReservedCacheNodesInput, _a1 func(*elasticache.DescribeReservedCacheNodesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeReservedCacheNodesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeElastiCache) DescribeReservedCacheNodesPagesWithContext(_a0 context.Context, _a1 *elasticache.DescribeReservedCacheNodesInput, _a2 func(*elasticache.DescribeReservedCacheNodesOutput, 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, *elasticache.DescribeReservedCacheNodesInput, func(*elasticache.DescribeReservedCacheNodesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeReservedCacheNodesRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeReservedCacheNodesRequest(_a0 *elasticache.DescribeReservedCacheNodesInput) (*request.Request, *elasticache.DescribeReservedCacheNodesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DescribeReservedCacheNodesOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DescribeReservedCacheNodesInput) *elasticache.DescribeReservedCacheNodesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DescribeReservedCacheNodesOutput)
		}
	}

	return r0, r1
}

// DescribeReservedCacheNodesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DescribeReservedCacheNodesWithContext(_a0 context.Context, _a1 *elasticache.DescribeReservedCacheNodesInput, _a2 ...request.Option) (*elasticache.DescribeReservedCacheNodesOutput, 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 *elasticache.DescribeReservedCacheNodesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeReservedCacheNodesInput, ...request.Option) *elasticache.DescribeReservedCacheNodesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeReservedCacheNodesOutput)
		}
	}

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

	return r0, r1
}

// DescribeServiceUpdates provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeServiceUpdates(_a0 *elasticache.DescribeServiceUpdatesInput) (*elasticache.DescribeServiceUpdatesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DescribeServiceUpdatesOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeServiceUpdatesInput) *elasticache.DescribeServiceUpdatesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeServiceUpdatesOutput)
		}
	}

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

	return r0, r1
}

// DescribeServiceUpdatesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeElastiCache) DescribeServiceUpdatesPages(_a0 *elasticache.DescribeServiceUpdatesInput, _a1 func(*elasticache.DescribeServiceUpdatesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeServiceUpdatesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeElastiCache) DescribeServiceUpdatesPagesWithContext(_a0 context.Context, _a1 *elasticache.DescribeServiceUpdatesInput, _a2 func(*elasticache.DescribeServiceUpdatesOutput, 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, *elasticache.DescribeServiceUpdatesInput, func(*elasticache.DescribeServiceUpdatesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeServiceUpdatesRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeServiceUpdatesRequest(_a0 *elasticache.DescribeServiceUpdatesInput) (*request.Request, *elasticache.DescribeServiceUpdatesOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DescribeServiceUpdatesOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DescribeServiceUpdatesInput) *elasticache.DescribeServiceUpdatesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DescribeServiceUpdatesOutput)
		}
	}

	return r0, r1
}

// DescribeServiceUpdatesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DescribeServiceUpdatesWithContext(_a0 context.Context, _a1 *elasticache.DescribeServiceUpdatesInput, _a2 ...request.Option) (*elasticache.DescribeServiceUpdatesOutput, 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 *elasticache.DescribeServiceUpdatesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeServiceUpdatesInput, ...request.Option) *elasticache.DescribeServiceUpdatesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeServiceUpdatesOutput)
		}
	}

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

	return r0, r1
}

// DescribeSnapshots provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeSnapshots(_a0 *elasticache.DescribeSnapshotsInput) (*elasticache.DescribeSnapshotsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DescribeSnapshotsOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeSnapshotsInput) *elasticache.DescribeSnapshotsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeSnapshotsOutput)
		}
	}

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

	return r0, r1
}

// DescribeSnapshotsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeElastiCache) DescribeSnapshotsPages(_a0 *elasticache.DescribeSnapshotsInput, _a1 func(*elasticache.DescribeSnapshotsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeSnapshotsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeElastiCache) DescribeSnapshotsPagesWithContext(_a0 context.Context, _a1 *elasticache.DescribeSnapshotsInput, _a2 func(*elasticache.DescribeSnapshotsOutput, 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, *elasticache.DescribeSnapshotsInput, func(*elasticache.DescribeSnapshotsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeSnapshotsRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeSnapshotsRequest(_a0 *elasticache.DescribeSnapshotsInput) (*request.Request, *elasticache.DescribeSnapshotsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DescribeSnapshotsOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DescribeSnapshotsInput) *elasticache.DescribeSnapshotsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DescribeSnapshotsOutput)
		}
	}

	return r0, r1
}

// DescribeSnapshotsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DescribeSnapshotsWithContext(_a0 context.Context, _a1 *elasticache.DescribeSnapshotsInput, _a2 ...request.Option) (*elasticache.DescribeSnapshotsOutput, 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 *elasticache.DescribeSnapshotsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeSnapshotsInput, ...request.Option) *elasticache.DescribeSnapshotsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeSnapshotsOutput)
		}
	}

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

	return r0, r1
}

// DescribeUpdateActions provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeUpdateActions(_a0 *elasticache.DescribeUpdateActionsInput) (*elasticache.DescribeUpdateActionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DescribeUpdateActionsOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeUpdateActionsInput) *elasticache.DescribeUpdateActionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeUpdateActionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeUpdateActionsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeElastiCache) DescribeUpdateActionsPages(_a0 *elasticache.DescribeUpdateActionsInput, _a1 func(*elasticache.DescribeUpdateActionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeUpdateActionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeElastiCache) DescribeUpdateActionsPagesWithContext(_a0 context.Context, _a1 *elasticache.DescribeUpdateActionsInput, _a2 func(*elasticache.DescribeUpdateActionsOutput, 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, *elasticache.DescribeUpdateActionsInput, func(*elasticache.DescribeUpdateActionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeUpdateActionsRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeUpdateActionsRequest(_a0 *elasticache.DescribeUpdateActionsInput) (*request.Request, *elasticache.DescribeUpdateActionsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DescribeUpdateActionsOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DescribeUpdateActionsInput) *elasticache.DescribeUpdateActionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DescribeUpdateActionsOutput)
		}
	}

	return r0, r1
}

// DescribeUpdateActionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DescribeUpdateActionsWithContext(_a0 context.Context, _a1 *elasticache.DescribeUpdateActionsInput, _a2 ...request.Option) (*elasticache.DescribeUpdateActionsOutput, 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 *elasticache.DescribeUpdateActionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeUpdateActionsInput, ...request.Option) *elasticache.DescribeUpdateActionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeUpdateActionsOutput)
		}
	}

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

	return r0, r1
}

// DescribeUserGroups provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeUserGroups(_a0 *elasticache.DescribeUserGroupsInput) (*elasticache.DescribeUserGroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DescribeUserGroupsOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeUserGroupsInput) *elasticache.DescribeUserGroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeUserGroupsOutput)
		}
	}

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

	return r0, r1
}

// DescribeUserGroupsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeElastiCache) DescribeUserGroupsPages(_a0 *elasticache.DescribeUserGroupsInput, _a1 func(*elasticache.DescribeUserGroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeUserGroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeElastiCache) DescribeUserGroupsPagesWithContext(_a0 context.Context, _a1 *elasticache.DescribeUserGroupsInput, _a2 func(*elasticache.DescribeUserGroupsOutput, 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, *elasticache.DescribeUserGroupsInput, func(*elasticache.DescribeUserGroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeUserGroupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeUserGroupsRequest(_a0 *elasticache.DescribeUserGroupsInput) (*request.Request, *elasticache.DescribeUserGroupsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DescribeUserGroupsOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DescribeUserGroupsInput) *elasticache.DescribeUserGroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DescribeUserGroupsOutput)
		}
	}

	return r0, r1
}

// DescribeUserGroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DescribeUserGroupsWithContext(_a0 context.Context, _a1 *elasticache.DescribeUserGroupsInput, _a2 ...request.Option) (*elasticache.DescribeUserGroupsOutput, 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 *elasticache.DescribeUserGroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeUserGroupsInput, ...request.Option) *elasticache.DescribeUserGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeUserGroupsOutput)
		}
	}

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

	return r0, r1
}

// DescribeUsers provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeUsers(_a0 *elasticache.DescribeUsersInput) (*elasticache.DescribeUsersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DescribeUsersOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeUsersInput) *elasticache.DescribeUsersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeUsersOutput)
		}
	}

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

	return r0, r1
}

// DescribeUsersPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeElastiCache) DescribeUsersPages(_a0 *elasticache.DescribeUsersInput, _a1 func(*elasticache.DescribeUsersOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

// DescribeUsersPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeElastiCache) DescribeUsersPagesWithContext(_a0 context.Context, _a1 *elasticache.DescribeUsersInput, _a2 func(*elasticache.DescribeUsersOutput, 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, *elasticache.DescribeUsersInput, func(*elasticache.DescribeUsersOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeUsersRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DescribeUsersRequest(_a0 *elasticache.DescribeUsersInput) (*request.Request, *elasticache.DescribeUsersOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DescribeUsersOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DescribeUsersInput) *elasticache.DescribeUsersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DescribeUsersOutput)
		}
	}

	return r0, r1
}

// DescribeUsersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DescribeUsersWithContext(_a0 context.Context, _a1 *elasticache.DescribeUsersInput, _a2 ...request.Option) (*elasticache.DescribeUsersOutput, 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 *elasticache.DescribeUsersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeUsersInput, ...request.Option) *elasticache.DescribeUsersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeUsersOutput)
		}
	}

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

	return r0, r1
}

// DisassociateGlobalReplicationGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DisassociateGlobalReplicationGroup(_a0 *elasticache.DisassociateGlobalReplicationGroupInput) (*elasticache.DisassociateGlobalReplicationGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DisassociateGlobalReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.DisassociateGlobalReplicationGroupInput) *elasticache.DisassociateGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DisassociateGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// DisassociateGlobalReplicationGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) DisassociateGlobalReplicationGroupRequest(_a0 *elasticache.DisassociateGlobalReplicationGroupInput) (*request.Request, *elasticache.DisassociateGlobalReplicationGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.DisassociateGlobalReplicationGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.DisassociateGlobalReplicationGroupInput) *elasticache.DisassociateGlobalReplicationGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.DisassociateGlobalReplicationGroupOutput)
		}
	}

	return r0, r1
}

// DisassociateGlobalReplicationGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) DisassociateGlobalReplicationGroupWithContext(_a0 context.Context, _a1 *elasticache.DisassociateGlobalReplicationGroupInput, _a2 ...request.Option) (*elasticache.DisassociateGlobalReplicationGroupOutput, 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 *elasticache.DisassociateGlobalReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DisassociateGlobalReplicationGroupInput, ...request.Option) *elasticache.DisassociateGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DisassociateGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// FailoverGlobalReplicationGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) FailoverGlobalReplicationGroup(_a0 *elasticache.FailoverGlobalReplicationGroupInput) (*elasticache.FailoverGlobalReplicationGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.FailoverGlobalReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.FailoverGlobalReplicationGroupInput) *elasticache.FailoverGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.FailoverGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// FailoverGlobalReplicationGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) FailoverGlobalReplicationGroupRequest(_a0 *elasticache.FailoverGlobalReplicationGroupInput) (*request.Request, *elasticache.FailoverGlobalReplicationGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.FailoverGlobalReplicationGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.FailoverGlobalReplicationGroupInput) *elasticache.FailoverGlobalReplicationGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.FailoverGlobalReplicationGroupOutput)
		}
	}

	return r0, r1
}

// FailoverGlobalReplicationGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) FailoverGlobalReplicationGroupWithContext(_a0 context.Context, _a1 *elasticache.FailoverGlobalReplicationGroupInput, _a2 ...request.Option) (*elasticache.FailoverGlobalReplicationGroupOutput, 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 *elasticache.FailoverGlobalReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.FailoverGlobalReplicationGroupInput, ...request.Option) *elasticache.FailoverGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.FailoverGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// IncreaseNodeGroupsInGlobalReplicationGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) IncreaseNodeGroupsInGlobalReplicationGroup(_a0 *elasticache.IncreaseNodeGroupsInGlobalReplicationGroupInput) (*elasticache.IncreaseNodeGroupsInGlobalReplicationGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.IncreaseNodeGroupsInGlobalReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.IncreaseNodeGroupsInGlobalReplicationGroupInput) *elasticache.IncreaseNodeGroupsInGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.IncreaseNodeGroupsInGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// IncreaseNodeGroupsInGlobalReplicationGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) IncreaseNodeGroupsInGlobalReplicationGroupRequest(_a0 *elasticache.IncreaseNodeGroupsInGlobalReplicationGroupInput) (*request.Request, *elasticache.IncreaseNodeGroupsInGlobalReplicationGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.IncreaseNodeGroupsInGlobalReplicationGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.IncreaseNodeGroupsInGlobalReplicationGroupInput) *elasticache.IncreaseNodeGroupsInGlobalReplicationGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.IncreaseNodeGroupsInGlobalReplicationGroupOutput)
		}
	}

	return r0, r1
}

// IncreaseNodeGroupsInGlobalReplicationGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) IncreaseNodeGroupsInGlobalReplicationGroupWithContext(_a0 context.Context, _a1 *elasticache.IncreaseNodeGroupsInGlobalReplicationGroupInput, _a2 ...request.Option) (*elasticache.IncreaseNodeGroupsInGlobalReplicationGroupOutput, 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 *elasticache.IncreaseNodeGroupsInGlobalReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.IncreaseNodeGroupsInGlobalReplicationGroupInput, ...request.Option) *elasticache.IncreaseNodeGroupsInGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.IncreaseNodeGroupsInGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// IncreaseReplicaCount provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) IncreaseReplicaCount(_a0 *elasticache.IncreaseReplicaCountInput) (*elasticache.IncreaseReplicaCountOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.IncreaseReplicaCountOutput
	if rf, ok := ret.Get(0).(func(*elasticache.IncreaseReplicaCountInput) *elasticache.IncreaseReplicaCountOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.IncreaseReplicaCountOutput)
		}
	}

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

	return r0, r1
}

// IncreaseReplicaCountRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) IncreaseReplicaCountRequest(_a0 *elasticache.IncreaseReplicaCountInput) (*request.Request, *elasticache.IncreaseReplicaCountOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.IncreaseReplicaCountOutput
	if rf, ok := ret.Get(1).(func(*elasticache.IncreaseReplicaCountInput) *elasticache.IncreaseReplicaCountOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.IncreaseReplicaCountOutput)
		}
	}

	return r0, r1
}

// IncreaseReplicaCountWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) IncreaseReplicaCountWithContext(_a0 context.Context, _a1 *elasticache.IncreaseReplicaCountInput, _a2 ...request.Option) (*elasticache.IncreaseReplicaCountOutput, 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 *elasticache.IncreaseReplicaCountOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.IncreaseReplicaCountInput, ...request.Option) *elasticache.IncreaseReplicaCountOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.IncreaseReplicaCountOutput)
		}
	}

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

	return r0, r1
}

// ListAllowedNodeTypeModifications provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) ListAllowedNodeTypeModifications(_a0 *elasticache.ListAllowedNodeTypeModificationsInput) (*elasticache.ListAllowedNodeTypeModificationsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.ListAllowedNodeTypeModificationsOutput
	if rf, ok := ret.Get(0).(func(*elasticache.ListAllowedNodeTypeModificationsInput) *elasticache.ListAllowedNodeTypeModificationsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ListAllowedNodeTypeModificationsOutput)
		}
	}

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

	return r0, r1
}

// ListAllowedNodeTypeModificationsRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) ListAllowedNodeTypeModificationsRequest(_a0 *elasticache.ListAllowedNodeTypeModificationsInput) (*request.Request, *elasticache.ListAllowedNodeTypeModificationsOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.ListAllowedNodeTypeModificationsOutput
	if rf, ok := ret.Get(1).(func(*elasticache.ListAllowedNodeTypeModificationsInput) *elasticache.ListAllowedNodeTypeModificationsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.ListAllowedNodeTypeModificationsOutput)
		}
	}

	return r0, r1
}

// ListAllowedNodeTypeModificationsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) ListAllowedNodeTypeModificationsWithContext(_a0 context.Context, _a1 *elasticache.ListAllowedNodeTypeModificationsInput, _a2 ...request.Option) (*elasticache.ListAllowedNodeTypeModificationsOutput, 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 *elasticache.ListAllowedNodeTypeModificationsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ListAllowedNodeTypeModificationsInput, ...request.Option) *elasticache.ListAllowedNodeTypeModificationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ListAllowedNodeTypeModificationsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *elasticache.ListAllowedNodeTypeModificationsInput, ...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 *MockFakeElastiCache) ListTagsForResource(_a0 *elasticache.ListTagsForResourceInput) (*elasticache.TagListMessage, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.TagListMessage
	if rf, ok := ret.Get(0).(func(*elasticache.ListTagsForResourceInput) *elasticache.TagListMessage); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.TagListMessage)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*elasticache.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 *MockFakeElastiCache) ListTagsForResourceRequest(_a0 *elasticache.ListTagsForResourceInput) (*request.Request, *elasticache.TagListMessage) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.TagListMessage
	if rf, ok := ret.Get(1).(func(*elasticache.ListTagsForResourceInput) *elasticache.TagListMessage); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.TagListMessage)
		}
	}

	return r0, r1
}

// ListTagsForResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) ListTagsForResourceWithContext(_a0 context.Context, _a1 *elasticache.ListTagsForResourceInput, _a2 ...request.Option) (*elasticache.TagListMessage, 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 *elasticache.TagListMessage
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ListTagsForResourceInput, ...request.Option) *elasticache.TagListMessage); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.TagListMessage)
		}
	}

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

	return r0, r1
}

// ModifyCacheCluster provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) ModifyCacheCluster(_a0 *elasticache.ModifyCacheClusterInput) (*elasticache.ModifyCacheClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.ModifyCacheClusterOutput
	if rf, ok := ret.Get(0).(func(*elasticache.ModifyCacheClusterInput) *elasticache.ModifyCacheClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyCacheClusterOutput)
		}
	}

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

	return r0, r1
}

// ModifyCacheClusterRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) ModifyCacheClusterRequest(_a0 *elasticache.ModifyCacheClusterInput) (*request.Request, *elasticache.ModifyCacheClusterOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.ModifyCacheClusterOutput
	if rf, ok := ret.Get(1).(func(*elasticache.ModifyCacheClusterInput) *elasticache.ModifyCacheClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.ModifyCacheClusterOutput)
		}
	}

	return r0, r1
}

// ModifyCacheClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) ModifyCacheClusterWithContext(_a0 context.Context, _a1 *elasticache.ModifyCacheClusterInput, _a2 ...request.Option) (*elasticache.ModifyCacheClusterOutput, 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 *elasticache.ModifyCacheClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyCacheClusterInput, ...request.Option) *elasticache.ModifyCacheClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyCacheClusterOutput)
		}
	}

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

	return r0, r1
}

// ModifyCacheParameterGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) ModifyCacheParameterGroup(_a0 *elasticache.ModifyCacheParameterGroupInput) (*elasticache.CacheParameterGroupNameMessage, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.CacheParameterGroupNameMessage
	if rf, ok := ret.Get(0).(func(*elasticache.ModifyCacheParameterGroupInput) *elasticache.CacheParameterGroupNameMessage); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CacheParameterGroupNameMessage)
		}
	}

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

	return r0, r1
}

// ModifyCacheParameterGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) ModifyCacheParameterGroupRequest(_a0 *elasticache.ModifyCacheParameterGroupInput) (*request.Request, *elasticache.CacheParameterGroupNameMessage) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.CacheParameterGroupNameMessage
	if rf, ok := ret.Get(1).(func(*elasticache.ModifyCacheParameterGroupInput) *elasticache.CacheParameterGroupNameMessage); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.CacheParameterGroupNameMessage)
		}
	}

	return r0, r1
}

// ModifyCacheParameterGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) ModifyCacheParameterGroupWithContext(_a0 context.Context, _a1 *elasticache.ModifyCacheParameterGroupInput, _a2 ...request.Option) (*elasticache.CacheParameterGroupNameMessage, 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 *elasticache.CacheParameterGroupNameMessage
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyCacheParameterGroupInput, ...request.Option) *elasticache.CacheParameterGroupNameMessage); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CacheParameterGroupNameMessage)
		}
	}

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

	return r0, r1
}

// ModifyCacheSubnetGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) ModifyCacheSubnetGroup(_a0 *elasticache.ModifyCacheSubnetGroupInput) (*elasticache.ModifyCacheSubnetGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.ModifyCacheSubnetGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.ModifyCacheSubnetGroupInput) *elasticache.ModifyCacheSubnetGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyCacheSubnetGroupOutput)
		}
	}

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

	return r0, r1
}

// ModifyCacheSubnetGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) ModifyCacheSubnetGroupRequest(_a0 *elasticache.ModifyCacheSubnetGroupInput) (*request.Request, *elasticache.ModifyCacheSubnetGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.ModifyCacheSubnetGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.ModifyCacheSubnetGroupInput) *elasticache.ModifyCacheSubnetGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.ModifyCacheSubnetGroupOutput)
		}
	}

	return r0, r1
}

// ModifyCacheSubnetGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) ModifyCacheSubnetGroupWithContext(_a0 context.Context, _a1 *elasticache.ModifyCacheSubnetGroupInput, _a2 ...request.Option) (*elasticache.ModifyCacheSubnetGroupOutput, 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 *elasticache.ModifyCacheSubnetGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyCacheSubnetGroupInput, ...request.Option) *elasticache.ModifyCacheSubnetGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyCacheSubnetGroupOutput)
		}
	}

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

	return r0, r1
}

// ModifyGlobalReplicationGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) ModifyGlobalReplicationGroup(_a0 *elasticache.ModifyGlobalReplicationGroupInput) (*elasticache.ModifyGlobalReplicationGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.ModifyGlobalReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.ModifyGlobalReplicationGroupInput) *elasticache.ModifyGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// ModifyGlobalReplicationGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) ModifyGlobalReplicationGroupRequest(_a0 *elasticache.ModifyGlobalReplicationGroupInput) (*request.Request, *elasticache.ModifyGlobalReplicationGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.ModifyGlobalReplicationGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.ModifyGlobalReplicationGroupInput) *elasticache.ModifyGlobalReplicationGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.ModifyGlobalReplicationGroupOutput)
		}
	}

	return r0, r1
}

// ModifyGlobalReplicationGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) ModifyGlobalReplicationGroupWithContext(_a0 context.Context, _a1 *elasticache.ModifyGlobalReplicationGroupInput, _a2 ...request.Option) (*elasticache.ModifyGlobalReplicationGroupOutput, 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 *elasticache.ModifyGlobalReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyGlobalReplicationGroupInput, ...request.Option) *elasticache.ModifyGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// ModifyReplicationGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) ModifyReplicationGroup(_a0 *elasticache.ModifyReplicationGroupInput) (*elasticache.ModifyReplicationGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.ModifyReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.ModifyReplicationGroupInput) *elasticache.ModifyReplicationGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// ModifyReplicationGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) ModifyReplicationGroupRequest(_a0 *elasticache.ModifyReplicationGroupInput) (*request.Request, *elasticache.ModifyReplicationGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.ModifyReplicationGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.ModifyReplicationGroupInput) *elasticache.ModifyReplicationGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.ModifyReplicationGroupOutput)
		}
	}

	return r0, r1
}

// ModifyReplicationGroupShardConfiguration provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) ModifyReplicationGroupShardConfiguration(_a0 *elasticache.ModifyReplicationGroupShardConfigurationInput) (*elasticache.ModifyReplicationGroupShardConfigurationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.ModifyReplicationGroupShardConfigurationOutput
	if rf, ok := ret.Get(0).(func(*elasticache.ModifyReplicationGroupShardConfigurationInput) *elasticache.ModifyReplicationGroupShardConfigurationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyReplicationGroupShardConfigurationOutput)
		}
	}

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

	return r0, r1
}

// ModifyReplicationGroupShardConfigurationRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) ModifyReplicationGroupShardConfigurationRequest(_a0 *elasticache.ModifyReplicationGroupShardConfigurationInput) (*request.Request, *elasticache.ModifyReplicationGroupShardConfigurationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.ModifyReplicationGroupShardConfigurationOutput
	if rf, ok := ret.Get(1).(func(*elasticache.ModifyReplicationGroupShardConfigurationInput) *elasticache.ModifyReplicationGroupShardConfigurationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.ModifyReplicationGroupShardConfigurationOutput)
		}
	}

	return r0, r1
}

// ModifyReplicationGroupShardConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) ModifyReplicationGroupShardConfigurationWithContext(_a0 context.Context, _a1 *elasticache.ModifyReplicationGroupShardConfigurationInput, _a2 ...request.Option) (*elasticache.ModifyReplicationGroupShardConfigurationOutput, 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 *elasticache.ModifyReplicationGroupShardConfigurationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyReplicationGroupShardConfigurationInput, ...request.Option) *elasticache.ModifyReplicationGroupShardConfigurationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyReplicationGroupShardConfigurationOutput)
		}
	}

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

	return r0, r1
}

// ModifyReplicationGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) ModifyReplicationGroupWithContext(_a0 context.Context, _a1 *elasticache.ModifyReplicationGroupInput, _a2 ...request.Option) (*elasticache.ModifyReplicationGroupOutput, 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 *elasticache.ModifyReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyReplicationGroupInput, ...request.Option) *elasticache.ModifyReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// ModifyUser provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) ModifyUser(_a0 *elasticache.ModifyUserInput) (*elasticache.ModifyUserOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.ModifyUserOutput
	if rf, ok := ret.Get(0).(func(*elasticache.ModifyUserInput) *elasticache.ModifyUserOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyUserOutput)
		}
	}

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

	return r0, r1
}

// ModifyUserGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) ModifyUserGroup(_a0 *elasticache.ModifyUserGroupInput) (*elasticache.ModifyUserGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.ModifyUserGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.ModifyUserGroupInput) *elasticache.ModifyUserGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyUserGroupOutput)
		}
	}

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

	return r0, r1
}

// ModifyUserGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) ModifyUserGroupRequest(_a0 *elasticache.ModifyUserGroupInput) (*request.Request, *elasticache.ModifyUserGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.ModifyUserGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.ModifyUserGroupInput) *elasticache.ModifyUserGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.ModifyUserGroupOutput)
		}
	}

	return r0, r1
}

// ModifyUserGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) ModifyUserGroupWithContext(_a0 context.Context, _a1 *elasticache.ModifyUserGroupInput, _a2 ...request.Option) (*elasticache.ModifyUserGroupOutput, 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 *elasticache.ModifyUserGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyUserGroupInput, ...request.Option) *elasticache.ModifyUserGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyUserGroupOutput)
		}
	}

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

	return r0, r1
}

// ModifyUserRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) ModifyUserRequest(_a0 *elasticache.ModifyUserInput) (*request.Request, *elasticache.ModifyUserOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.ModifyUserOutput
	if rf, ok := ret.Get(1).(func(*elasticache.ModifyUserInput) *elasticache.ModifyUserOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.ModifyUserOutput)
		}
	}

	return r0, r1
}

// ModifyUserWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) ModifyUserWithContext(_a0 context.Context, _a1 *elasticache.ModifyUserInput, _a2 ...request.Option) (*elasticache.ModifyUserOutput, 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 *elasticache.ModifyUserOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyUserInput, ...request.Option) *elasticache.ModifyUserOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyUserOutput)
		}
	}

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

	return r0, r1
}

// PurchaseReservedCacheNodesOffering provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) PurchaseReservedCacheNodesOffering(_a0 *elasticache.PurchaseReservedCacheNodesOfferingInput) (*elasticache.PurchaseReservedCacheNodesOfferingOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.PurchaseReservedCacheNodesOfferingOutput
	if rf, ok := ret.Get(0).(func(*elasticache.PurchaseReservedCacheNodesOfferingInput) *elasticache.PurchaseReservedCacheNodesOfferingOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.PurchaseReservedCacheNodesOfferingOutput)
		}
	}

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

	return r0, r1
}

// PurchaseReservedCacheNodesOfferingRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) PurchaseReservedCacheNodesOfferingRequest(_a0 *elasticache.PurchaseReservedCacheNodesOfferingInput) (*request.Request, *elasticache.PurchaseReservedCacheNodesOfferingOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.PurchaseReservedCacheNodesOfferingOutput
	if rf, ok := ret.Get(1).(func(*elasticache.PurchaseReservedCacheNodesOfferingInput) *elasticache.PurchaseReservedCacheNodesOfferingOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.PurchaseReservedCacheNodesOfferingOutput)
		}
	}

	return r0, r1
}

// PurchaseReservedCacheNodesOfferingWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) PurchaseReservedCacheNodesOfferingWithContext(_a0 context.Context, _a1 *elasticache.PurchaseReservedCacheNodesOfferingInput, _a2 ...request.Option) (*elasticache.PurchaseReservedCacheNodesOfferingOutput, 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 *elasticache.PurchaseReservedCacheNodesOfferingOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.PurchaseReservedCacheNodesOfferingInput, ...request.Option) *elasticache.PurchaseReservedCacheNodesOfferingOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.PurchaseReservedCacheNodesOfferingOutput)
		}
	}

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

	return r0, r1
}

// RebalanceSlotsInGlobalReplicationGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) RebalanceSlotsInGlobalReplicationGroup(_a0 *elasticache.RebalanceSlotsInGlobalReplicationGroupInput) (*elasticache.RebalanceSlotsInGlobalReplicationGroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.RebalanceSlotsInGlobalReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(*elasticache.RebalanceSlotsInGlobalReplicationGroupInput) *elasticache.RebalanceSlotsInGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.RebalanceSlotsInGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// RebalanceSlotsInGlobalReplicationGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) RebalanceSlotsInGlobalReplicationGroupRequest(_a0 *elasticache.RebalanceSlotsInGlobalReplicationGroupInput) (*request.Request, *elasticache.RebalanceSlotsInGlobalReplicationGroupOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.RebalanceSlotsInGlobalReplicationGroupOutput
	if rf, ok := ret.Get(1).(func(*elasticache.RebalanceSlotsInGlobalReplicationGroupInput) *elasticache.RebalanceSlotsInGlobalReplicationGroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.RebalanceSlotsInGlobalReplicationGroupOutput)
		}
	}

	return r0, r1
}

// RebalanceSlotsInGlobalReplicationGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) RebalanceSlotsInGlobalReplicationGroupWithContext(_a0 context.Context, _a1 *elasticache.RebalanceSlotsInGlobalReplicationGroupInput, _a2 ...request.Option) (*elasticache.RebalanceSlotsInGlobalReplicationGroupOutput, 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 *elasticache.RebalanceSlotsInGlobalReplicationGroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.RebalanceSlotsInGlobalReplicationGroupInput, ...request.Option) *elasticache.RebalanceSlotsInGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.RebalanceSlotsInGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// RebootCacheCluster provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) RebootCacheCluster(_a0 *elasticache.RebootCacheClusterInput) (*elasticache.RebootCacheClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.RebootCacheClusterOutput
	if rf, ok := ret.Get(0).(func(*elasticache.RebootCacheClusterInput) *elasticache.RebootCacheClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.RebootCacheClusterOutput)
		}
	}

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

	return r0, r1
}

// RebootCacheClusterRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) RebootCacheClusterRequest(_a0 *elasticache.RebootCacheClusterInput) (*request.Request, *elasticache.RebootCacheClusterOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.RebootCacheClusterOutput
	if rf, ok := ret.Get(1).(func(*elasticache.RebootCacheClusterInput) *elasticache.RebootCacheClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.RebootCacheClusterOutput)
		}
	}

	return r0, r1
}

// RebootCacheClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) RebootCacheClusterWithContext(_a0 context.Context, _a1 *elasticache.RebootCacheClusterInput, _a2 ...request.Option) (*elasticache.RebootCacheClusterOutput, 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 *elasticache.RebootCacheClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.RebootCacheClusterInput, ...request.Option) *elasticache.RebootCacheClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.RebootCacheClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *elasticache.RebootCacheClusterInput, ...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 *MockFakeElastiCache) RemoveTagsFromResource(_a0 *elasticache.RemoveTagsFromResourceInput) (*elasticache.TagListMessage, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.TagListMessage
	if rf, ok := ret.Get(0).(func(*elasticache.RemoveTagsFromResourceInput) *elasticache.TagListMessage); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.TagListMessage)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*elasticache.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 *MockFakeElastiCache) RemoveTagsFromResourceRequest(_a0 *elasticache.RemoveTagsFromResourceInput) (*request.Request, *elasticache.TagListMessage) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.TagListMessage
	if rf, ok := ret.Get(1).(func(*elasticache.RemoveTagsFromResourceInput) *elasticache.TagListMessage); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.TagListMessage)
		}
	}

	return r0, r1
}

// RemoveTagsFromResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) RemoveTagsFromResourceWithContext(_a0 context.Context, _a1 *elasticache.RemoveTagsFromResourceInput, _a2 ...request.Option) (*elasticache.TagListMessage, 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 *elasticache.TagListMessage
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.RemoveTagsFromResourceInput, ...request.Option) *elasticache.TagListMessage); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.TagListMessage)
		}
	}

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

	return r0, r1
}

// ResetCacheParameterGroup provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) ResetCacheParameterGroup(_a0 *elasticache.ResetCacheParameterGroupInput) (*elasticache.CacheParameterGroupNameMessage, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.CacheParameterGroupNameMessage
	if rf, ok := ret.Get(0).(func(*elasticache.ResetCacheParameterGroupInput) *elasticache.CacheParameterGroupNameMessage); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CacheParameterGroupNameMessage)
		}
	}

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

	return r0, r1
}

// ResetCacheParameterGroupRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) ResetCacheParameterGroupRequest(_a0 *elasticache.ResetCacheParameterGroupInput) (*request.Request, *elasticache.CacheParameterGroupNameMessage) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.CacheParameterGroupNameMessage
	if rf, ok := ret.Get(1).(func(*elasticache.ResetCacheParameterGroupInput) *elasticache.CacheParameterGroupNameMessage); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.CacheParameterGroupNameMessage)
		}
	}

	return r0, r1
}

// ResetCacheParameterGroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) ResetCacheParameterGroupWithContext(_a0 context.Context, _a1 *elasticache.ResetCacheParameterGroupInput, _a2 ...request.Option) (*elasticache.CacheParameterGroupNameMessage, 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 *elasticache.CacheParameterGroupNameMessage
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ResetCacheParameterGroupInput, ...request.Option) *elasticache.CacheParameterGroupNameMessage); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CacheParameterGroupNameMessage)
		}
	}

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

	return r0, r1
}

// RevokeCacheSecurityGroupIngress provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) RevokeCacheSecurityGroupIngress(_a0 *elasticache.RevokeCacheSecurityGroupIngressInput) (*elasticache.RevokeCacheSecurityGroupIngressOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.RevokeCacheSecurityGroupIngressOutput
	if rf, ok := ret.Get(0).(func(*elasticache.RevokeCacheSecurityGroupIngressInput) *elasticache.RevokeCacheSecurityGroupIngressOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.RevokeCacheSecurityGroupIngressOutput)
		}
	}

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

	return r0, r1
}

// RevokeCacheSecurityGroupIngressRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) RevokeCacheSecurityGroupIngressRequest(_a0 *elasticache.RevokeCacheSecurityGroupIngressInput) (*request.Request, *elasticache.RevokeCacheSecurityGroupIngressOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.RevokeCacheSecurityGroupIngressOutput
	if rf, ok := ret.Get(1).(func(*elasticache.RevokeCacheSecurityGroupIngressInput) *elasticache.RevokeCacheSecurityGroupIngressOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.RevokeCacheSecurityGroupIngressOutput)
		}
	}

	return r0, r1
}

// RevokeCacheSecurityGroupIngressWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) RevokeCacheSecurityGroupIngressWithContext(_a0 context.Context, _a1 *elasticache.RevokeCacheSecurityGroupIngressInput, _a2 ...request.Option) (*elasticache.RevokeCacheSecurityGroupIngressOutput, 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 *elasticache.RevokeCacheSecurityGroupIngressOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.RevokeCacheSecurityGroupIngressInput, ...request.Option) *elasticache.RevokeCacheSecurityGroupIngressOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.RevokeCacheSecurityGroupIngressOutput)
		}
	}

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

	return r0, r1
}

// StartMigration provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) StartMigration(_a0 *elasticache.StartMigrationInput) (*elasticache.StartMigrationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.StartMigrationOutput
	if rf, ok := ret.Get(0).(func(*elasticache.StartMigrationInput) *elasticache.StartMigrationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.StartMigrationOutput)
		}
	}

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

	return r0, r1
}

// StartMigrationRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) StartMigrationRequest(_a0 *elasticache.StartMigrationInput) (*request.Request, *elasticache.StartMigrationOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.StartMigrationOutput
	if rf, ok := ret.Get(1).(func(*elasticache.StartMigrationInput) *elasticache.StartMigrationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.StartMigrationOutput)
		}
	}

	return r0, r1
}

// StartMigrationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) StartMigrationWithContext(_a0 context.Context, _a1 *elasticache.StartMigrationInput, _a2 ...request.Option) (*elasticache.StartMigrationOutput, 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 *elasticache.StartMigrationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.StartMigrationInput, ...request.Option) *elasticache.StartMigrationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.StartMigrationOutput)
		}
	}

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

	return r0, r1
}

// TestFailover provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) TestFailover(_a0 *elasticache.TestFailoverInput) (*elasticache.TestFailoverOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.TestFailoverOutput
	if rf, ok := ret.Get(0).(func(*elasticache.TestFailoverInput) *elasticache.TestFailoverOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.TestFailoverOutput)
		}
	}

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

	return r0, r1
}

// TestFailoverRequest provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) TestFailoverRequest(_a0 *elasticache.TestFailoverInput) (*request.Request, *elasticache.TestFailoverOutput) {
	ret := _m.Called(_a0)

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

	var r1 *elasticache.TestFailoverOutput
	if rf, ok := ret.Get(1).(func(*elasticache.TestFailoverInput) *elasticache.TestFailoverOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*elasticache.TestFailoverOutput)
		}
	}

	return r0, r1
}

// TestFailoverWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) TestFailoverWithContext(_a0 context.Context, _a1 *elasticache.TestFailoverInput, _a2 ...request.Option) (*elasticache.TestFailoverOutput, 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 *elasticache.TestFailoverOutput
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.TestFailoverInput, ...request.Option) *elasticache.TestFailoverOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.TestFailoverOutput)
		}
	}

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

	return r0, r1
}

// WaitUntilCacheClusterAvailable provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) WaitUntilCacheClusterAvailable(_a0 *elasticache.DescribeCacheClustersInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeCacheClustersInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilCacheClusterAvailableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) WaitUntilCacheClusterAvailableWithContext(_a0 context.Context, _a1 *elasticache.DescribeCacheClustersInput, _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, *elasticache.DescribeCacheClustersInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilCacheClusterDeleted provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) WaitUntilCacheClusterDeleted(_a0 *elasticache.DescribeCacheClustersInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeCacheClustersInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilCacheClusterDeletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) WaitUntilCacheClusterDeletedWithContext(_a0 context.Context, _a1 *elasticache.DescribeCacheClustersInput, _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, *elasticache.DescribeCacheClustersInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilReplicationGroupAvailable provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) WaitUntilReplicationGroupAvailable(_a0 *elasticache.DescribeReplicationGroupsInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeReplicationGroupsInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilReplicationGroupAvailableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) WaitUntilReplicationGroupAvailableWithContext(_a0 context.Context, _a1 *elasticache.DescribeReplicationGroupsInput, _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, *elasticache.DescribeReplicationGroupsInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilReplicationGroupDeleted provides a mock function with given fields: _a0
func (_m *MockFakeElastiCache) WaitUntilReplicationGroupDeleted(_a0 *elasticache.DescribeReplicationGroupsInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeReplicationGroupsInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilReplicationGroupDeletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeElastiCache) WaitUntilReplicationGroupDeletedWithContext(_a0 context.Context, _a1 *elasticache.DescribeReplicationGroupsInput, _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, *elasticache.DescribeReplicationGroupsInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}
