github.com/tetrafolium/tflint@v0.8.0/mock/elasticachemock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: vendor/github.com/aws/aws-sdk-go/service/elasticache/elasticacheiface/interface.go

// Package mock is a generated GoMock package.
package mock

import (
	aws "github.com/aws/aws-sdk-go/aws"
	request "github.com/aws/aws-sdk-go/aws/request"
	elasticache "github.com/aws/aws-sdk-go/service/elasticache"
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
)

// MockElastiCacheAPI is a mock of ElastiCacheAPI interface
type MockElastiCacheAPI struct {
	ctrl     *gomock.Controller
	recorder *MockElastiCacheAPIMockRecorder
}

// MockElastiCacheAPIMockRecorder is the mock recorder for MockElastiCacheAPI
type MockElastiCacheAPIMockRecorder struct {
	mock *MockElastiCacheAPI
}

// NewMockElastiCacheAPI creates a new mock instance
func NewMockElastiCacheAPI(ctrl *gomock.Controller) *MockElastiCacheAPI {
	mock := &MockElastiCacheAPI{ctrl: ctrl}
	mock.recorder = &MockElastiCacheAPIMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockElastiCacheAPI) EXPECT() *MockElastiCacheAPIMockRecorder {
	return m.recorder
}

// AddTagsToResource mocks base method
func (m *MockElastiCacheAPI) AddTagsToResource(arg0 *elasticache.AddTagsToResourceInput) (*elasticache.TagListMessage, error) {
	ret := m.ctrl.Call(m, "AddTagsToResource", arg0)
	ret0, _ := ret[0].(*elasticache.TagListMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddTagsToResource indicates an expected call of AddTagsToResource
func (mr *MockElastiCacheAPIMockRecorder) AddTagsToResource(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToResource", reflect.TypeOf((*MockElastiCacheAPI)(nil).AddTagsToResource), arg0)
}

// AddTagsToResourceWithContext mocks base method
func (m *MockElastiCacheAPI) AddTagsToResourceWithContext(arg0 aws.Context, arg1 *elasticache.AddTagsToResourceInput, arg2 ...request.Option) (*elasticache.TagListMessage, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddTagsToResourceWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.TagListMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddTagsToResourceWithContext indicates an expected call of AddTagsToResourceWithContext
func (mr *MockElastiCacheAPIMockRecorder) AddTagsToResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToResourceWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).AddTagsToResourceWithContext), varargs...)
}

// AddTagsToResourceRequest mocks base method
func (m *MockElastiCacheAPI) AddTagsToResourceRequest(arg0 *elasticache.AddTagsToResourceInput) (*request.Request, *elasticache.TagListMessage) {
	ret := m.ctrl.Call(m, "AddTagsToResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.TagListMessage)
	return ret0, ret1
}

// AddTagsToResourceRequest indicates an expected call of AddTagsToResourceRequest
func (mr *MockElastiCacheAPIMockRecorder) AddTagsToResourceRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToResourceRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).AddTagsToResourceRequest), arg0)
}

// AuthorizeCacheSecurityGroupIngress mocks base method
func (m *MockElastiCacheAPI) AuthorizeCacheSecurityGroupIngress(arg0 *elasticache.AuthorizeCacheSecurityGroupIngressInput) (*elasticache.AuthorizeCacheSecurityGroupIngressOutput, error) {
	ret := m.ctrl.Call(m, "AuthorizeCacheSecurityGroupIngress", arg0)
	ret0, _ := ret[0].(*elasticache.AuthorizeCacheSecurityGroupIngressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AuthorizeCacheSecurityGroupIngress indicates an expected call of AuthorizeCacheSecurityGroupIngress
func (mr *MockElastiCacheAPIMockRecorder) AuthorizeCacheSecurityGroupIngress(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeCacheSecurityGroupIngress", reflect.TypeOf((*MockElastiCacheAPI)(nil).AuthorizeCacheSecurityGroupIngress), arg0)
}

// AuthorizeCacheSecurityGroupIngressWithContext mocks base method
func (m *MockElastiCacheAPI) AuthorizeCacheSecurityGroupIngressWithContext(arg0 aws.Context, arg1 *elasticache.AuthorizeCacheSecurityGroupIngressInput, arg2 ...request.Option) (*elasticache.AuthorizeCacheSecurityGroupIngressOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AuthorizeCacheSecurityGroupIngressWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.AuthorizeCacheSecurityGroupIngressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AuthorizeCacheSecurityGroupIngressWithContext indicates an expected call of AuthorizeCacheSecurityGroupIngressWithContext
func (mr *MockElastiCacheAPIMockRecorder) AuthorizeCacheSecurityGroupIngressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeCacheSecurityGroupIngressWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).AuthorizeCacheSecurityGroupIngressWithContext), varargs...)
}

// AuthorizeCacheSecurityGroupIngressRequest mocks base method
func (m *MockElastiCacheAPI) AuthorizeCacheSecurityGroupIngressRequest(arg0 *elasticache.AuthorizeCacheSecurityGroupIngressInput) (*request.Request, *elasticache.AuthorizeCacheSecurityGroupIngressOutput) {
	ret := m.ctrl.Call(m, "AuthorizeCacheSecurityGroupIngressRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.AuthorizeCacheSecurityGroupIngressOutput)
	return ret0, ret1
}

// AuthorizeCacheSecurityGroupIngressRequest indicates an expected call of AuthorizeCacheSecurityGroupIngressRequest
func (mr *MockElastiCacheAPIMockRecorder) AuthorizeCacheSecurityGroupIngressRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeCacheSecurityGroupIngressRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).AuthorizeCacheSecurityGroupIngressRequest), arg0)
}

// CopySnapshot mocks base method
func (m *MockElastiCacheAPI) CopySnapshot(arg0 *elasticache.CopySnapshotInput) (*elasticache.CopySnapshotOutput, error) {
	ret := m.ctrl.Call(m, "CopySnapshot", arg0)
	ret0, _ := ret[0].(*elasticache.CopySnapshotOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CopySnapshot indicates an expected call of CopySnapshot
func (mr *MockElastiCacheAPIMockRecorder) CopySnapshot(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopySnapshot", reflect.TypeOf((*MockElastiCacheAPI)(nil).CopySnapshot), arg0)
}

// CopySnapshotWithContext mocks base method
func (m *MockElastiCacheAPI) CopySnapshotWithContext(arg0 aws.Context, arg1 *elasticache.CopySnapshotInput, arg2 ...request.Option) (*elasticache.CopySnapshotOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CopySnapshotWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.CopySnapshotOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CopySnapshotWithContext indicates an expected call of CopySnapshotWithContext
func (mr *MockElastiCacheAPIMockRecorder) CopySnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopySnapshotWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).CopySnapshotWithContext), varargs...)
}

// CopySnapshotRequest mocks base method
func (m *MockElastiCacheAPI) CopySnapshotRequest(arg0 *elasticache.CopySnapshotInput) (*request.Request, *elasticache.CopySnapshotOutput) {
	ret := m.ctrl.Call(m, "CopySnapshotRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.CopySnapshotOutput)
	return ret0, ret1
}

// CopySnapshotRequest indicates an expected call of CopySnapshotRequest
func (mr *MockElastiCacheAPIMockRecorder) CopySnapshotRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopySnapshotRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).CopySnapshotRequest), arg0)
}

// CreateCacheCluster mocks base method
func (m *MockElastiCacheAPI) CreateCacheCluster(arg0 *elasticache.CreateCacheClusterInput) (*elasticache.CreateCacheClusterOutput, error) {
	ret := m.ctrl.Call(m, "CreateCacheCluster", arg0)
	ret0, _ := ret[0].(*elasticache.CreateCacheClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCacheCluster indicates an expected call of CreateCacheCluster
func (mr *MockElastiCacheAPIMockRecorder) CreateCacheCluster(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheCluster", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheCluster), arg0)
}

// CreateCacheClusterWithContext mocks base method
func (m *MockElastiCacheAPI) CreateCacheClusterWithContext(arg0 aws.Context, arg1 *elasticache.CreateCacheClusterInput, arg2 ...request.Option) (*elasticache.CreateCacheClusterOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateCacheClusterWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.CreateCacheClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCacheClusterWithContext indicates an expected call of CreateCacheClusterWithContext
func (mr *MockElastiCacheAPIMockRecorder) CreateCacheClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheClusterWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheClusterWithContext), varargs...)
}

// CreateCacheClusterRequest mocks base method
func (m *MockElastiCacheAPI) CreateCacheClusterRequest(arg0 *elasticache.CreateCacheClusterInput) (*request.Request, *elasticache.CreateCacheClusterOutput) {
	ret := m.ctrl.Call(m, "CreateCacheClusterRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.CreateCacheClusterOutput)
	return ret0, ret1
}

// CreateCacheClusterRequest indicates an expected call of CreateCacheClusterRequest
func (mr *MockElastiCacheAPIMockRecorder) CreateCacheClusterRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheClusterRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheClusterRequest), arg0)
}

// CreateCacheParameterGroup mocks base method
func (m *MockElastiCacheAPI) CreateCacheParameterGroup(arg0 *elasticache.CreateCacheParameterGroupInput) (*elasticache.CreateCacheParameterGroupOutput, error) {
	ret := m.ctrl.Call(m, "CreateCacheParameterGroup", arg0)
	ret0, _ := ret[0].(*elasticache.CreateCacheParameterGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCacheParameterGroup indicates an expected call of CreateCacheParameterGroup
func (mr *MockElastiCacheAPIMockRecorder) CreateCacheParameterGroup(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheParameterGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheParameterGroup), arg0)
}

// CreateCacheParameterGroupWithContext mocks base method
func (m *MockElastiCacheAPI) CreateCacheParameterGroupWithContext(arg0 aws.Context, arg1 *elasticache.CreateCacheParameterGroupInput, arg2 ...request.Option) (*elasticache.CreateCacheParameterGroupOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateCacheParameterGroupWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.CreateCacheParameterGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCacheParameterGroupWithContext indicates an expected call of CreateCacheParameterGroupWithContext
func (mr *MockElastiCacheAPIMockRecorder) CreateCacheParameterGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheParameterGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheParameterGroupWithContext), varargs...)
}

// CreateCacheParameterGroupRequest mocks base method
func (m *MockElastiCacheAPI) CreateCacheParameterGroupRequest(arg0 *elasticache.CreateCacheParameterGroupInput) (*request.Request, *elasticache.CreateCacheParameterGroupOutput) {
	ret := m.ctrl.Call(m, "CreateCacheParameterGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.CreateCacheParameterGroupOutput)
	return ret0, ret1
}

// CreateCacheParameterGroupRequest indicates an expected call of CreateCacheParameterGroupRequest
func (mr *MockElastiCacheAPIMockRecorder) CreateCacheParameterGroupRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheParameterGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheParameterGroupRequest), arg0)
}

// CreateCacheSecurityGroup mocks base method
func (m *MockElastiCacheAPI) CreateCacheSecurityGroup(arg0 *elasticache.CreateCacheSecurityGroupInput) (*elasticache.CreateCacheSecurityGroupOutput, error) {
	ret := m.ctrl.Call(m, "CreateCacheSecurityGroup", arg0)
	ret0, _ := ret[0].(*elasticache.CreateCacheSecurityGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCacheSecurityGroup indicates an expected call of CreateCacheSecurityGroup
func (mr *MockElastiCacheAPIMockRecorder) CreateCacheSecurityGroup(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheSecurityGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheSecurityGroup), arg0)
}

// CreateCacheSecurityGroupWithContext mocks base method
func (m *MockElastiCacheAPI) CreateCacheSecurityGroupWithContext(arg0 aws.Context, arg1 *elasticache.CreateCacheSecurityGroupInput, arg2 ...request.Option) (*elasticache.CreateCacheSecurityGroupOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateCacheSecurityGroupWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.CreateCacheSecurityGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCacheSecurityGroupWithContext indicates an expected call of CreateCacheSecurityGroupWithContext
func (mr *MockElastiCacheAPIMockRecorder) CreateCacheSecurityGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheSecurityGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheSecurityGroupWithContext), varargs...)
}

// CreateCacheSecurityGroupRequest mocks base method
func (m *MockElastiCacheAPI) CreateCacheSecurityGroupRequest(arg0 *elasticache.CreateCacheSecurityGroupInput) (*request.Request, *elasticache.CreateCacheSecurityGroupOutput) {
	ret := m.ctrl.Call(m, "CreateCacheSecurityGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.CreateCacheSecurityGroupOutput)
	return ret0, ret1
}

// CreateCacheSecurityGroupRequest indicates an expected call of CreateCacheSecurityGroupRequest
func (mr *MockElastiCacheAPIMockRecorder) CreateCacheSecurityGroupRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheSecurityGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheSecurityGroupRequest), arg0)
}

// CreateCacheSubnetGroup mocks base method
func (m *MockElastiCacheAPI) CreateCacheSubnetGroup(arg0 *elasticache.CreateCacheSubnetGroupInput) (*elasticache.CreateCacheSubnetGroupOutput, error) {
	ret := m.ctrl.Call(m, "CreateCacheSubnetGroup", arg0)
	ret0, _ := ret[0].(*elasticache.CreateCacheSubnetGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCacheSubnetGroup indicates an expected call of CreateCacheSubnetGroup
func (mr *MockElastiCacheAPIMockRecorder) CreateCacheSubnetGroup(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheSubnetGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheSubnetGroup), arg0)
}

// CreateCacheSubnetGroupWithContext mocks base method
func (m *MockElastiCacheAPI) CreateCacheSubnetGroupWithContext(arg0 aws.Context, arg1 *elasticache.CreateCacheSubnetGroupInput, arg2 ...request.Option) (*elasticache.CreateCacheSubnetGroupOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateCacheSubnetGroupWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.CreateCacheSubnetGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCacheSubnetGroupWithContext indicates an expected call of CreateCacheSubnetGroupWithContext
func (mr *MockElastiCacheAPIMockRecorder) CreateCacheSubnetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheSubnetGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheSubnetGroupWithContext), varargs...)
}

// CreateCacheSubnetGroupRequest mocks base method
func (m *MockElastiCacheAPI) CreateCacheSubnetGroupRequest(arg0 *elasticache.CreateCacheSubnetGroupInput) (*request.Request, *elasticache.CreateCacheSubnetGroupOutput) {
	ret := m.ctrl.Call(m, "CreateCacheSubnetGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.CreateCacheSubnetGroupOutput)
	return ret0, ret1
}

// CreateCacheSubnetGroupRequest indicates an expected call of CreateCacheSubnetGroupRequest
func (mr *MockElastiCacheAPIMockRecorder) CreateCacheSubnetGroupRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCacheSubnetGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateCacheSubnetGroupRequest), arg0)
}

// CreateReplicationGroup mocks base method
func (m *MockElastiCacheAPI) CreateReplicationGroup(arg0 *elasticache.CreateReplicationGroupInput) (*elasticache.CreateReplicationGroupOutput, error) {
	ret := m.ctrl.Call(m, "CreateReplicationGroup", arg0)
	ret0, _ := ret[0].(*elasticache.CreateReplicationGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateReplicationGroup indicates an expected call of CreateReplicationGroup
func (mr *MockElastiCacheAPIMockRecorder) CreateReplicationGroup(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReplicationGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateReplicationGroup), arg0)
}

// CreateReplicationGroupWithContext mocks base method
func (m *MockElastiCacheAPI) CreateReplicationGroupWithContext(arg0 aws.Context, arg1 *elasticache.CreateReplicationGroupInput, arg2 ...request.Option) (*elasticache.CreateReplicationGroupOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateReplicationGroupWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.CreateReplicationGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateReplicationGroupWithContext indicates an expected call of CreateReplicationGroupWithContext
func (mr *MockElastiCacheAPIMockRecorder) CreateReplicationGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReplicationGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateReplicationGroupWithContext), varargs...)
}

// CreateReplicationGroupRequest mocks base method
func (m *MockElastiCacheAPI) CreateReplicationGroupRequest(arg0 *elasticache.CreateReplicationGroupInput) (*request.Request, *elasticache.CreateReplicationGroupOutput) {
	ret := m.ctrl.Call(m, "CreateReplicationGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.CreateReplicationGroupOutput)
	return ret0, ret1
}

// CreateReplicationGroupRequest indicates an expected call of CreateReplicationGroupRequest
func (mr *MockElastiCacheAPIMockRecorder) CreateReplicationGroupRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReplicationGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateReplicationGroupRequest), arg0)
}

// CreateSnapshot mocks base method
func (m *MockElastiCacheAPI) CreateSnapshot(arg0 *elasticache.CreateSnapshotInput) (*elasticache.CreateSnapshotOutput, error) {
	ret := m.ctrl.Call(m, "CreateSnapshot", arg0)
	ret0, _ := ret[0].(*elasticache.CreateSnapshotOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSnapshot indicates an expected call of CreateSnapshot
func (mr *MockElastiCacheAPIMockRecorder) CreateSnapshot(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshot", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateSnapshot), arg0)
}

// CreateSnapshotWithContext mocks base method
func (m *MockElastiCacheAPI) CreateSnapshotWithContext(arg0 aws.Context, arg1 *elasticache.CreateSnapshotInput, arg2 ...request.Option) (*elasticache.CreateSnapshotOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateSnapshotWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.CreateSnapshotOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSnapshotWithContext indicates an expected call of CreateSnapshotWithContext
func (mr *MockElastiCacheAPIMockRecorder) CreateSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateSnapshotWithContext), varargs...)
}

// CreateSnapshotRequest mocks base method
func (m *MockElastiCacheAPI) CreateSnapshotRequest(arg0 *elasticache.CreateSnapshotInput) (*request.Request, *elasticache.CreateSnapshotOutput) {
	ret := m.ctrl.Call(m, "CreateSnapshotRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.CreateSnapshotOutput)
	return ret0, ret1
}

// CreateSnapshotRequest indicates an expected call of CreateSnapshotRequest
func (mr *MockElastiCacheAPIMockRecorder) CreateSnapshotRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).CreateSnapshotRequest), arg0)
}

// DeleteCacheCluster mocks base method
func (m *MockElastiCacheAPI) DeleteCacheCluster(arg0 *elasticache.DeleteCacheClusterInput) (*elasticache.DeleteCacheClusterOutput, error) {
	ret := m.ctrl.Call(m, "DeleteCacheCluster", arg0)
	ret0, _ := ret[0].(*elasticache.DeleteCacheClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCacheCluster indicates an expected call of DeleteCacheCluster
func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheCluster(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheCluster", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheCluster), arg0)
}

// DeleteCacheClusterWithContext mocks base method
func (m *MockElastiCacheAPI) DeleteCacheClusterWithContext(arg0 aws.Context, arg1 *elasticache.DeleteCacheClusterInput, arg2 ...request.Option) (*elasticache.DeleteCacheClusterOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteCacheClusterWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.DeleteCacheClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCacheClusterWithContext indicates an expected call of DeleteCacheClusterWithContext
func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheClusterWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheClusterWithContext), varargs...)
}

// DeleteCacheClusterRequest mocks base method
func (m *MockElastiCacheAPI) DeleteCacheClusterRequest(arg0 *elasticache.DeleteCacheClusterInput) (*request.Request, *elasticache.DeleteCacheClusterOutput) {
	ret := m.ctrl.Call(m, "DeleteCacheClusterRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.DeleteCacheClusterOutput)
	return ret0, ret1
}

// DeleteCacheClusterRequest indicates an expected call of DeleteCacheClusterRequest
func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheClusterRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheClusterRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheClusterRequest), arg0)
}

// DeleteCacheParameterGroup mocks base method
func (m *MockElastiCacheAPI) DeleteCacheParameterGroup(arg0 *elasticache.DeleteCacheParameterGroupInput) (*elasticache.DeleteCacheParameterGroupOutput, error) {
	ret := m.ctrl.Call(m, "DeleteCacheParameterGroup", arg0)
	ret0, _ := ret[0].(*elasticache.DeleteCacheParameterGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCacheParameterGroup indicates an expected call of DeleteCacheParameterGroup
func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheParameterGroup(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheParameterGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheParameterGroup), arg0)
}

// DeleteCacheParameterGroupWithContext mocks base method
func (m *MockElastiCacheAPI) DeleteCacheParameterGroupWithContext(arg0 aws.Context, arg1 *elasticache.DeleteCacheParameterGroupInput, arg2 ...request.Option) (*elasticache.DeleteCacheParameterGroupOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteCacheParameterGroupWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.DeleteCacheParameterGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCacheParameterGroupWithContext indicates an expected call of DeleteCacheParameterGroupWithContext
func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheParameterGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheParameterGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheParameterGroupWithContext), varargs...)
}

// DeleteCacheParameterGroupRequest mocks base method
func (m *MockElastiCacheAPI) DeleteCacheParameterGroupRequest(arg0 *elasticache.DeleteCacheParameterGroupInput) (*request.Request, *elasticache.DeleteCacheParameterGroupOutput) {
	ret := m.ctrl.Call(m, "DeleteCacheParameterGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.DeleteCacheParameterGroupOutput)
	return ret0, ret1
}

// DeleteCacheParameterGroupRequest indicates an expected call of DeleteCacheParameterGroupRequest
func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheParameterGroupRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheParameterGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheParameterGroupRequest), arg0)
}

// DeleteCacheSecurityGroup mocks base method
func (m *MockElastiCacheAPI) DeleteCacheSecurityGroup(arg0 *elasticache.DeleteCacheSecurityGroupInput) (*elasticache.DeleteCacheSecurityGroupOutput, error) {
	ret := m.ctrl.Call(m, "DeleteCacheSecurityGroup", arg0)
	ret0, _ := ret[0].(*elasticache.DeleteCacheSecurityGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCacheSecurityGroup indicates an expected call of DeleteCacheSecurityGroup
func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheSecurityGroup(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheSecurityGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheSecurityGroup), arg0)
}

// DeleteCacheSecurityGroupWithContext mocks base method
func (m *MockElastiCacheAPI) DeleteCacheSecurityGroupWithContext(arg0 aws.Context, arg1 *elasticache.DeleteCacheSecurityGroupInput, arg2 ...request.Option) (*elasticache.DeleteCacheSecurityGroupOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteCacheSecurityGroupWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.DeleteCacheSecurityGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCacheSecurityGroupWithContext indicates an expected call of DeleteCacheSecurityGroupWithContext
func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheSecurityGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheSecurityGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheSecurityGroupWithContext), varargs...)
}

// DeleteCacheSecurityGroupRequest mocks base method
func (m *MockElastiCacheAPI) DeleteCacheSecurityGroupRequest(arg0 *elasticache.DeleteCacheSecurityGroupInput) (*request.Request, *elasticache.DeleteCacheSecurityGroupOutput) {
	ret := m.ctrl.Call(m, "DeleteCacheSecurityGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.DeleteCacheSecurityGroupOutput)
	return ret0, ret1
}

// DeleteCacheSecurityGroupRequest indicates an expected call of DeleteCacheSecurityGroupRequest
func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheSecurityGroupRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheSecurityGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheSecurityGroupRequest), arg0)
}

// DeleteCacheSubnetGroup mocks base method
func (m *MockElastiCacheAPI) DeleteCacheSubnetGroup(arg0 *elasticache.DeleteCacheSubnetGroupInput) (*elasticache.DeleteCacheSubnetGroupOutput, error) {
	ret := m.ctrl.Call(m, "DeleteCacheSubnetGroup", arg0)
	ret0, _ := ret[0].(*elasticache.DeleteCacheSubnetGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCacheSubnetGroup indicates an expected call of DeleteCacheSubnetGroup
func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheSubnetGroup(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheSubnetGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheSubnetGroup), arg0)
}

// DeleteCacheSubnetGroupWithContext mocks base method
func (m *MockElastiCacheAPI) DeleteCacheSubnetGroupWithContext(arg0 aws.Context, arg1 *elasticache.DeleteCacheSubnetGroupInput, arg2 ...request.Option) (*elasticache.DeleteCacheSubnetGroupOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteCacheSubnetGroupWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.DeleteCacheSubnetGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCacheSubnetGroupWithContext indicates an expected call of DeleteCacheSubnetGroupWithContext
func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheSubnetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheSubnetGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheSubnetGroupWithContext), varargs...)
}

// DeleteCacheSubnetGroupRequest mocks base method
func (m *MockElastiCacheAPI) DeleteCacheSubnetGroupRequest(arg0 *elasticache.DeleteCacheSubnetGroupInput) (*request.Request, *elasticache.DeleteCacheSubnetGroupOutput) {
	ret := m.ctrl.Call(m, "DeleteCacheSubnetGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.DeleteCacheSubnetGroupOutput)
	return ret0, ret1
}

// DeleteCacheSubnetGroupRequest indicates an expected call of DeleteCacheSubnetGroupRequest
func (mr *MockElastiCacheAPIMockRecorder) DeleteCacheSubnetGroupRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCacheSubnetGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteCacheSubnetGroupRequest), arg0)
}

// DeleteReplicationGroup mocks base method
func (m *MockElastiCacheAPI) DeleteReplicationGroup(arg0 *elasticache.DeleteReplicationGroupInput) (*elasticache.DeleteReplicationGroupOutput, error) {
	ret := m.ctrl.Call(m, "DeleteReplicationGroup", arg0)
	ret0, _ := ret[0].(*elasticache.DeleteReplicationGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteReplicationGroup indicates an expected call of DeleteReplicationGroup
func (mr *MockElastiCacheAPIMockRecorder) DeleteReplicationGroup(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReplicationGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteReplicationGroup), arg0)
}

// DeleteReplicationGroupWithContext mocks base method
func (m *MockElastiCacheAPI) DeleteReplicationGroupWithContext(arg0 aws.Context, arg1 *elasticache.DeleteReplicationGroupInput, arg2 ...request.Option) (*elasticache.DeleteReplicationGroupOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteReplicationGroupWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.DeleteReplicationGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteReplicationGroupWithContext indicates an expected call of DeleteReplicationGroupWithContext
func (mr *MockElastiCacheAPIMockRecorder) DeleteReplicationGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReplicationGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteReplicationGroupWithContext), varargs...)
}

// DeleteReplicationGroupRequest mocks base method
func (m *MockElastiCacheAPI) DeleteReplicationGroupRequest(arg0 *elasticache.DeleteReplicationGroupInput) (*request.Request, *elasticache.DeleteReplicationGroupOutput) {
	ret := m.ctrl.Call(m, "DeleteReplicationGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.DeleteReplicationGroupOutput)
	return ret0, ret1
}

// DeleteReplicationGroupRequest indicates an expected call of DeleteReplicationGroupRequest
func (mr *MockElastiCacheAPIMockRecorder) DeleteReplicationGroupRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReplicationGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteReplicationGroupRequest), arg0)
}

// DeleteSnapshot mocks base method
func (m *MockElastiCacheAPI) DeleteSnapshot(arg0 *elasticache.DeleteSnapshotInput) (*elasticache.DeleteSnapshotOutput, error) {
	ret := m.ctrl.Call(m, "DeleteSnapshot", arg0)
	ret0, _ := ret[0].(*elasticache.DeleteSnapshotOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteSnapshot indicates an expected call of DeleteSnapshot
func (mr *MockElastiCacheAPIMockRecorder) DeleteSnapshot(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshot", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteSnapshot), arg0)
}

// DeleteSnapshotWithContext mocks base method
func (m *MockElastiCacheAPI) DeleteSnapshotWithContext(arg0 aws.Context, arg1 *elasticache.DeleteSnapshotInput, arg2 ...request.Option) (*elasticache.DeleteSnapshotOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteSnapshotWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.DeleteSnapshotOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteSnapshotWithContext indicates an expected call of DeleteSnapshotWithContext
func (mr *MockElastiCacheAPIMockRecorder) DeleteSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshotWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteSnapshotWithContext), varargs...)
}

// DeleteSnapshotRequest mocks base method
func (m *MockElastiCacheAPI) DeleteSnapshotRequest(arg0 *elasticache.DeleteSnapshotInput) (*request.Request, *elasticache.DeleteSnapshotOutput) {
	ret := m.ctrl.Call(m, "DeleteSnapshotRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.DeleteSnapshotOutput)
	return ret0, ret1
}

// DeleteSnapshotRequest indicates an expected call of DeleteSnapshotRequest
func (mr *MockElastiCacheAPIMockRecorder) DeleteSnapshotRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshotRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DeleteSnapshotRequest), arg0)
}

// DescribeCacheClusters mocks base method
func (m *MockElastiCacheAPI) DescribeCacheClusters(arg0 *elasticache.DescribeCacheClustersInput) (*elasticache.DescribeCacheClustersOutput, error) {
	ret := m.ctrl.Call(m, "DescribeCacheClusters", arg0)
	ret0, _ := ret[0].(*elasticache.DescribeCacheClustersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCacheClusters indicates an expected call of DescribeCacheClusters
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheClusters(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheClusters", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheClusters), arg0)
}

// DescribeCacheClustersWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeCacheClustersWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheClustersInput, arg2 ...request.Option) (*elasticache.DescribeCacheClustersOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCacheClustersWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.DescribeCacheClustersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCacheClustersWithContext indicates an expected call of DescribeCacheClustersWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheClustersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheClustersWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheClustersWithContext), varargs...)
}

// DescribeCacheClustersRequest mocks base method
func (m *MockElastiCacheAPI) DescribeCacheClustersRequest(arg0 *elasticache.DescribeCacheClustersInput) (*request.Request, *elasticache.DescribeCacheClustersOutput) {
	ret := m.ctrl.Call(m, "DescribeCacheClustersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.DescribeCacheClustersOutput)
	return ret0, ret1
}

// DescribeCacheClustersRequest indicates an expected call of DescribeCacheClustersRequest
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheClustersRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheClustersRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheClustersRequest), arg0)
}

// DescribeCacheClustersPages mocks base method
func (m *MockElastiCacheAPI) DescribeCacheClustersPages(arg0 *elasticache.DescribeCacheClustersInput, arg1 func(*elasticache.DescribeCacheClustersOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "DescribeCacheClustersPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeCacheClustersPages indicates an expected call of DescribeCacheClustersPages
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheClustersPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheClustersPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheClustersPages), arg0, arg1)
}

// DescribeCacheClustersPagesWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeCacheClustersPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheClustersInput, arg2 func(*elasticache.DescribeCacheClustersOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCacheClustersPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeCacheClustersPagesWithContext indicates an expected call of DescribeCacheClustersPagesWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheClustersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheClustersPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheClustersPagesWithContext), varargs...)
}

// DescribeCacheEngineVersions mocks base method
func (m *MockElastiCacheAPI) DescribeCacheEngineVersions(arg0 *elasticache.DescribeCacheEngineVersionsInput) (*elasticache.DescribeCacheEngineVersionsOutput, error) {
	ret := m.ctrl.Call(m, "DescribeCacheEngineVersions", arg0)
	ret0, _ := ret[0].(*elasticache.DescribeCacheEngineVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCacheEngineVersions indicates an expected call of DescribeCacheEngineVersions
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheEngineVersions(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheEngineVersions", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheEngineVersions), arg0)
}

// DescribeCacheEngineVersionsWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeCacheEngineVersionsWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheEngineVersionsInput, arg2 ...request.Option) (*elasticache.DescribeCacheEngineVersionsOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCacheEngineVersionsWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.DescribeCacheEngineVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCacheEngineVersionsWithContext indicates an expected call of DescribeCacheEngineVersionsWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheEngineVersionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheEngineVersionsWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheEngineVersionsWithContext), varargs...)
}

// DescribeCacheEngineVersionsRequest mocks base method
func (m *MockElastiCacheAPI) DescribeCacheEngineVersionsRequest(arg0 *elasticache.DescribeCacheEngineVersionsInput) (*request.Request, *elasticache.DescribeCacheEngineVersionsOutput) {
	ret := m.ctrl.Call(m, "DescribeCacheEngineVersionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.DescribeCacheEngineVersionsOutput)
	return ret0, ret1
}

// DescribeCacheEngineVersionsRequest indicates an expected call of DescribeCacheEngineVersionsRequest
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheEngineVersionsRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheEngineVersionsRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheEngineVersionsRequest), arg0)
}

// DescribeCacheEngineVersionsPages mocks base method
func (m *MockElastiCacheAPI) DescribeCacheEngineVersionsPages(arg0 *elasticache.DescribeCacheEngineVersionsInput, arg1 func(*elasticache.DescribeCacheEngineVersionsOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "DescribeCacheEngineVersionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeCacheEngineVersionsPages indicates an expected call of DescribeCacheEngineVersionsPages
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheEngineVersionsPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheEngineVersionsPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheEngineVersionsPages), arg0, arg1)
}

// DescribeCacheEngineVersionsPagesWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeCacheEngineVersionsPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheEngineVersionsInput, arg2 func(*elasticache.DescribeCacheEngineVersionsOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCacheEngineVersionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeCacheEngineVersionsPagesWithContext indicates an expected call of DescribeCacheEngineVersionsPagesWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheEngineVersionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheEngineVersionsPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheEngineVersionsPagesWithContext), varargs...)
}

// DescribeCacheParameterGroups mocks base method
func (m *MockElastiCacheAPI) DescribeCacheParameterGroups(arg0 *elasticache.DescribeCacheParameterGroupsInput) (*elasticache.DescribeCacheParameterGroupsOutput, error) {
	ret := m.ctrl.Call(m, "DescribeCacheParameterGroups", arg0)
	ret0, _ := ret[0].(*elasticache.DescribeCacheParameterGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCacheParameterGroups indicates an expected call of DescribeCacheParameterGroups
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheParameterGroups(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheParameterGroups", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheParameterGroups), arg0)
}

// DescribeCacheParameterGroupsWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeCacheParameterGroupsWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheParameterGroupsInput, arg2 ...request.Option) (*elasticache.DescribeCacheParameterGroupsOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCacheParameterGroupsWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.DescribeCacheParameterGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCacheParameterGroupsWithContext indicates an expected call of DescribeCacheParameterGroupsWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheParameterGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheParameterGroupsWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheParameterGroupsWithContext), varargs...)
}

// DescribeCacheParameterGroupsRequest mocks base method
func (m *MockElastiCacheAPI) DescribeCacheParameterGroupsRequest(arg0 *elasticache.DescribeCacheParameterGroupsInput) (*request.Request, *elasticache.DescribeCacheParameterGroupsOutput) {
	ret := m.ctrl.Call(m, "DescribeCacheParameterGroupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.DescribeCacheParameterGroupsOutput)
	return ret0, ret1
}

// DescribeCacheParameterGroupsRequest indicates an expected call of DescribeCacheParameterGroupsRequest
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheParameterGroupsRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheParameterGroupsRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheParameterGroupsRequest), arg0)
}

// DescribeCacheParameterGroupsPages mocks base method
func (m *MockElastiCacheAPI) DescribeCacheParameterGroupsPages(arg0 *elasticache.DescribeCacheParameterGroupsInput, arg1 func(*elasticache.DescribeCacheParameterGroupsOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "DescribeCacheParameterGroupsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeCacheParameterGroupsPages indicates an expected call of DescribeCacheParameterGroupsPages
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheParameterGroupsPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheParameterGroupsPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheParameterGroupsPages), arg0, arg1)
}

// DescribeCacheParameterGroupsPagesWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeCacheParameterGroupsPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheParameterGroupsInput, arg2 func(*elasticache.DescribeCacheParameterGroupsOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCacheParameterGroupsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeCacheParameterGroupsPagesWithContext indicates an expected call of DescribeCacheParameterGroupsPagesWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheParameterGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheParameterGroupsPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheParameterGroupsPagesWithContext), varargs...)
}

// DescribeCacheParameters mocks base method
func (m *MockElastiCacheAPI) DescribeCacheParameters(arg0 *elasticache.DescribeCacheParametersInput) (*elasticache.DescribeCacheParametersOutput, error) {
	ret := m.ctrl.Call(m, "DescribeCacheParameters", arg0)
	ret0, _ := ret[0].(*elasticache.DescribeCacheParametersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCacheParameters indicates an expected call of DescribeCacheParameters
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheParameters(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheParameters", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheParameters), arg0)
}

// DescribeCacheParametersWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeCacheParametersWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheParametersInput, arg2 ...request.Option) (*elasticache.DescribeCacheParametersOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCacheParametersWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.DescribeCacheParametersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCacheParametersWithContext indicates an expected call of DescribeCacheParametersWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheParametersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheParametersWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheParametersWithContext), varargs...)
}

// DescribeCacheParametersRequest mocks base method
func (m *MockElastiCacheAPI) DescribeCacheParametersRequest(arg0 *elasticache.DescribeCacheParametersInput) (*request.Request, *elasticache.DescribeCacheParametersOutput) {
	ret := m.ctrl.Call(m, "DescribeCacheParametersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.DescribeCacheParametersOutput)
	return ret0, ret1
}

// DescribeCacheParametersRequest indicates an expected call of DescribeCacheParametersRequest
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheParametersRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheParametersRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheParametersRequest), arg0)
}

// DescribeCacheParametersPages mocks base method
func (m *MockElastiCacheAPI) DescribeCacheParametersPages(arg0 *elasticache.DescribeCacheParametersInput, arg1 func(*elasticache.DescribeCacheParametersOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "DescribeCacheParametersPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeCacheParametersPages indicates an expected call of DescribeCacheParametersPages
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheParametersPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheParametersPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheParametersPages), arg0, arg1)
}

// DescribeCacheParametersPagesWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeCacheParametersPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheParametersInput, arg2 func(*elasticache.DescribeCacheParametersOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCacheParametersPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeCacheParametersPagesWithContext indicates an expected call of DescribeCacheParametersPagesWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheParametersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheParametersPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheParametersPagesWithContext), varargs...)
}

// DescribeCacheSecurityGroups mocks base method
func (m *MockElastiCacheAPI) DescribeCacheSecurityGroups(arg0 *elasticache.DescribeCacheSecurityGroupsInput) (*elasticache.DescribeCacheSecurityGroupsOutput, error) {
	ret := m.ctrl.Call(m, "DescribeCacheSecurityGroups", arg0)
	ret0, _ := ret[0].(*elasticache.DescribeCacheSecurityGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCacheSecurityGroups indicates an expected call of DescribeCacheSecurityGroups
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheSecurityGroups(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheSecurityGroups", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheSecurityGroups), arg0)
}

// DescribeCacheSecurityGroupsWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeCacheSecurityGroupsWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheSecurityGroupsInput, arg2 ...request.Option) (*elasticache.DescribeCacheSecurityGroupsOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCacheSecurityGroupsWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.DescribeCacheSecurityGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCacheSecurityGroupsWithContext indicates an expected call of DescribeCacheSecurityGroupsWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheSecurityGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheSecurityGroupsWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheSecurityGroupsWithContext), varargs...)
}

// DescribeCacheSecurityGroupsRequest mocks base method
func (m *MockElastiCacheAPI) DescribeCacheSecurityGroupsRequest(arg0 *elasticache.DescribeCacheSecurityGroupsInput) (*request.Request, *elasticache.DescribeCacheSecurityGroupsOutput) {
	ret := m.ctrl.Call(m, "DescribeCacheSecurityGroupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.DescribeCacheSecurityGroupsOutput)
	return ret0, ret1
}

// DescribeCacheSecurityGroupsRequest indicates an expected call of DescribeCacheSecurityGroupsRequest
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheSecurityGroupsRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheSecurityGroupsRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheSecurityGroupsRequest), arg0)
}

// DescribeCacheSecurityGroupsPages mocks base method
func (m *MockElastiCacheAPI) DescribeCacheSecurityGroupsPages(arg0 *elasticache.DescribeCacheSecurityGroupsInput, arg1 func(*elasticache.DescribeCacheSecurityGroupsOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "DescribeCacheSecurityGroupsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeCacheSecurityGroupsPages indicates an expected call of DescribeCacheSecurityGroupsPages
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheSecurityGroupsPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheSecurityGroupsPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheSecurityGroupsPages), arg0, arg1)
}

// DescribeCacheSecurityGroupsPagesWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeCacheSecurityGroupsPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheSecurityGroupsInput, arg2 func(*elasticache.DescribeCacheSecurityGroupsOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCacheSecurityGroupsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeCacheSecurityGroupsPagesWithContext indicates an expected call of DescribeCacheSecurityGroupsPagesWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheSecurityGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheSecurityGroupsPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheSecurityGroupsPagesWithContext), varargs...)
}

// DescribeCacheSubnetGroups mocks base method
func (m *MockElastiCacheAPI) DescribeCacheSubnetGroups(arg0 *elasticache.DescribeCacheSubnetGroupsInput) (*elasticache.DescribeCacheSubnetGroupsOutput, error) {
	ret := m.ctrl.Call(m, "DescribeCacheSubnetGroups", arg0)
	ret0, _ := ret[0].(*elasticache.DescribeCacheSubnetGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCacheSubnetGroups indicates an expected call of DescribeCacheSubnetGroups
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheSubnetGroups(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheSubnetGroups", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheSubnetGroups), arg0)
}

// DescribeCacheSubnetGroupsWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeCacheSubnetGroupsWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheSubnetGroupsInput, arg2 ...request.Option) (*elasticache.DescribeCacheSubnetGroupsOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCacheSubnetGroupsWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.DescribeCacheSubnetGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCacheSubnetGroupsWithContext indicates an expected call of DescribeCacheSubnetGroupsWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheSubnetGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheSubnetGroupsWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheSubnetGroupsWithContext), varargs...)
}

// DescribeCacheSubnetGroupsRequest mocks base method
func (m *MockElastiCacheAPI) DescribeCacheSubnetGroupsRequest(arg0 *elasticache.DescribeCacheSubnetGroupsInput) (*request.Request, *elasticache.DescribeCacheSubnetGroupsOutput) {
	ret := m.ctrl.Call(m, "DescribeCacheSubnetGroupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.DescribeCacheSubnetGroupsOutput)
	return ret0, ret1
}

// DescribeCacheSubnetGroupsRequest indicates an expected call of DescribeCacheSubnetGroupsRequest
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheSubnetGroupsRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheSubnetGroupsRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheSubnetGroupsRequest), arg0)
}

// DescribeCacheSubnetGroupsPages mocks base method
func (m *MockElastiCacheAPI) DescribeCacheSubnetGroupsPages(arg0 *elasticache.DescribeCacheSubnetGroupsInput, arg1 func(*elasticache.DescribeCacheSubnetGroupsOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "DescribeCacheSubnetGroupsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeCacheSubnetGroupsPages indicates an expected call of DescribeCacheSubnetGroupsPages
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheSubnetGroupsPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheSubnetGroupsPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheSubnetGroupsPages), arg0, arg1)
}

// DescribeCacheSubnetGroupsPagesWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeCacheSubnetGroupsPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheSubnetGroupsInput, arg2 func(*elasticache.DescribeCacheSubnetGroupsOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCacheSubnetGroupsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeCacheSubnetGroupsPagesWithContext indicates an expected call of DescribeCacheSubnetGroupsPagesWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeCacheSubnetGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCacheSubnetGroupsPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeCacheSubnetGroupsPagesWithContext), varargs...)
}

// DescribeEngineDefaultParameters mocks base method
func (m *MockElastiCacheAPI) DescribeEngineDefaultParameters(arg0 *elasticache.DescribeEngineDefaultParametersInput) (*elasticache.DescribeEngineDefaultParametersOutput, error) {
	ret := m.ctrl.Call(m, "DescribeEngineDefaultParameters", arg0)
	ret0, _ := ret[0].(*elasticache.DescribeEngineDefaultParametersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeEngineDefaultParameters indicates an expected call of DescribeEngineDefaultParameters
func (mr *MockElastiCacheAPIMockRecorder) DescribeEngineDefaultParameters(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEngineDefaultParameters", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeEngineDefaultParameters), arg0)
}

// DescribeEngineDefaultParametersWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeEngineDefaultParametersWithContext(arg0 aws.Context, arg1 *elasticache.DescribeEngineDefaultParametersInput, arg2 ...request.Option) (*elasticache.DescribeEngineDefaultParametersOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeEngineDefaultParametersWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.DescribeEngineDefaultParametersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeEngineDefaultParametersWithContext indicates an expected call of DescribeEngineDefaultParametersWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeEngineDefaultParametersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEngineDefaultParametersWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeEngineDefaultParametersWithContext), varargs...)
}

// DescribeEngineDefaultParametersRequest mocks base method
func (m *MockElastiCacheAPI) DescribeEngineDefaultParametersRequest(arg0 *elasticache.DescribeEngineDefaultParametersInput) (*request.Request, *elasticache.DescribeEngineDefaultParametersOutput) {
	ret := m.ctrl.Call(m, "DescribeEngineDefaultParametersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.DescribeEngineDefaultParametersOutput)
	return ret0, ret1
}

// DescribeEngineDefaultParametersRequest indicates an expected call of DescribeEngineDefaultParametersRequest
func (mr *MockElastiCacheAPIMockRecorder) DescribeEngineDefaultParametersRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEngineDefaultParametersRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeEngineDefaultParametersRequest), arg0)
}

// DescribeEngineDefaultParametersPages mocks base method
func (m *MockElastiCacheAPI) DescribeEngineDefaultParametersPages(arg0 *elasticache.DescribeEngineDefaultParametersInput, arg1 func(*elasticache.DescribeEngineDefaultParametersOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "DescribeEngineDefaultParametersPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeEngineDefaultParametersPages indicates an expected call of DescribeEngineDefaultParametersPages
func (mr *MockElastiCacheAPIMockRecorder) DescribeEngineDefaultParametersPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEngineDefaultParametersPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeEngineDefaultParametersPages), arg0, arg1)
}

// DescribeEngineDefaultParametersPagesWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeEngineDefaultParametersPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeEngineDefaultParametersInput, arg2 func(*elasticache.DescribeEngineDefaultParametersOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeEngineDefaultParametersPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeEngineDefaultParametersPagesWithContext indicates an expected call of DescribeEngineDefaultParametersPagesWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeEngineDefaultParametersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEngineDefaultParametersPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeEngineDefaultParametersPagesWithContext), varargs...)
}

// DescribeEvents mocks base method
func (m *MockElastiCacheAPI) DescribeEvents(arg0 *elasticache.DescribeEventsInput) (*elasticache.DescribeEventsOutput, error) {
	ret := m.ctrl.Call(m, "DescribeEvents", arg0)
	ret0, _ := ret[0].(*elasticache.DescribeEventsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeEvents indicates an expected call of DescribeEvents
func (mr *MockElastiCacheAPIMockRecorder) DescribeEvents(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEvents", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeEvents), arg0)
}

// DescribeEventsWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeEventsWithContext(arg0 aws.Context, arg1 *elasticache.DescribeEventsInput, arg2 ...request.Option) (*elasticache.DescribeEventsOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeEventsWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.DescribeEventsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeEventsWithContext indicates an expected call of DescribeEventsWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeEventsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeEventsWithContext), varargs...)
}

// DescribeEventsRequest mocks base method
func (m *MockElastiCacheAPI) DescribeEventsRequest(arg0 *elasticache.DescribeEventsInput) (*request.Request, *elasticache.DescribeEventsOutput) {
	ret := m.ctrl.Call(m, "DescribeEventsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.DescribeEventsOutput)
	return ret0, ret1
}

// DescribeEventsRequest indicates an expected call of DescribeEventsRequest
func (mr *MockElastiCacheAPIMockRecorder) DescribeEventsRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeEventsRequest), arg0)
}

// DescribeEventsPages mocks base method
func (m *MockElastiCacheAPI) DescribeEventsPages(arg0 *elasticache.DescribeEventsInput, arg1 func(*elasticache.DescribeEventsOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "DescribeEventsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeEventsPages indicates an expected call of DescribeEventsPages
func (mr *MockElastiCacheAPIMockRecorder) DescribeEventsPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeEventsPages), arg0, arg1)
}

// DescribeEventsPagesWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeEventsPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeEventsInput, arg2 func(*elasticache.DescribeEventsOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeEventsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeEventsPagesWithContext indicates an expected call of DescribeEventsPagesWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeEventsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEventsPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeEventsPagesWithContext), varargs...)
}

// DescribeReplicationGroups mocks base method
func (m *MockElastiCacheAPI) DescribeReplicationGroups(arg0 *elasticache.DescribeReplicationGroupsInput) (*elasticache.DescribeReplicationGroupsOutput, error) {
	ret := m.ctrl.Call(m, "DescribeReplicationGroups", arg0)
	ret0, _ := ret[0].(*elasticache.DescribeReplicationGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeReplicationGroups indicates an expected call of DescribeReplicationGroups
func (mr *MockElastiCacheAPIMockRecorder) DescribeReplicationGroups(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplicationGroups", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReplicationGroups), arg0)
}

// DescribeReplicationGroupsWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeReplicationGroupsWithContext(arg0 aws.Context, arg1 *elasticache.DescribeReplicationGroupsInput, arg2 ...request.Option) (*elasticache.DescribeReplicationGroupsOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeReplicationGroupsWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.DescribeReplicationGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeReplicationGroupsWithContext indicates an expected call of DescribeReplicationGroupsWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeReplicationGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplicationGroupsWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReplicationGroupsWithContext), varargs...)
}

// DescribeReplicationGroupsRequest mocks base method
func (m *MockElastiCacheAPI) DescribeReplicationGroupsRequest(arg0 *elasticache.DescribeReplicationGroupsInput) (*request.Request, *elasticache.DescribeReplicationGroupsOutput) {
	ret := m.ctrl.Call(m, "DescribeReplicationGroupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.DescribeReplicationGroupsOutput)
	return ret0, ret1
}

// DescribeReplicationGroupsRequest indicates an expected call of DescribeReplicationGroupsRequest
func (mr *MockElastiCacheAPIMockRecorder) DescribeReplicationGroupsRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplicationGroupsRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReplicationGroupsRequest), arg0)
}

// DescribeReplicationGroupsPages mocks base method
func (m *MockElastiCacheAPI) DescribeReplicationGroupsPages(arg0 *elasticache.DescribeReplicationGroupsInput, arg1 func(*elasticache.DescribeReplicationGroupsOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "DescribeReplicationGroupsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeReplicationGroupsPages indicates an expected call of DescribeReplicationGroupsPages
func (mr *MockElastiCacheAPIMockRecorder) DescribeReplicationGroupsPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplicationGroupsPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReplicationGroupsPages), arg0, arg1)
}

// DescribeReplicationGroupsPagesWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeReplicationGroupsPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeReplicationGroupsInput, arg2 func(*elasticache.DescribeReplicationGroupsOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeReplicationGroupsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeReplicationGroupsPagesWithContext indicates an expected call of DescribeReplicationGroupsPagesWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeReplicationGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplicationGroupsPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReplicationGroupsPagesWithContext), varargs...)
}

// DescribeReservedCacheNodes mocks base method
func (m *MockElastiCacheAPI) DescribeReservedCacheNodes(arg0 *elasticache.DescribeReservedCacheNodesInput) (*elasticache.DescribeReservedCacheNodesOutput, error) {
	ret := m.ctrl.Call(m, "DescribeReservedCacheNodes", arg0)
	ret0, _ := ret[0].(*elasticache.DescribeReservedCacheNodesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeReservedCacheNodes indicates an expected call of DescribeReservedCacheNodes
func (mr *MockElastiCacheAPIMockRecorder) DescribeReservedCacheNodes(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedCacheNodes", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReservedCacheNodes), arg0)
}

// DescribeReservedCacheNodesWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeReservedCacheNodesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeReservedCacheNodesInput, arg2 ...request.Option) (*elasticache.DescribeReservedCacheNodesOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeReservedCacheNodesWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.DescribeReservedCacheNodesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeReservedCacheNodesWithContext indicates an expected call of DescribeReservedCacheNodesWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeReservedCacheNodesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedCacheNodesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReservedCacheNodesWithContext), varargs...)
}

// DescribeReservedCacheNodesRequest mocks base method
func (m *MockElastiCacheAPI) DescribeReservedCacheNodesRequest(arg0 *elasticache.DescribeReservedCacheNodesInput) (*request.Request, *elasticache.DescribeReservedCacheNodesOutput) {
	ret := m.ctrl.Call(m, "DescribeReservedCacheNodesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.DescribeReservedCacheNodesOutput)
	return ret0, ret1
}

// DescribeReservedCacheNodesRequest indicates an expected call of DescribeReservedCacheNodesRequest
func (mr *MockElastiCacheAPIMockRecorder) DescribeReservedCacheNodesRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedCacheNodesRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReservedCacheNodesRequest), arg0)
}

// DescribeReservedCacheNodesPages mocks base method
func (m *MockElastiCacheAPI) DescribeReservedCacheNodesPages(arg0 *elasticache.DescribeReservedCacheNodesInput, arg1 func(*elasticache.DescribeReservedCacheNodesOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "DescribeReservedCacheNodesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeReservedCacheNodesPages indicates an expected call of DescribeReservedCacheNodesPages
func (mr *MockElastiCacheAPIMockRecorder) DescribeReservedCacheNodesPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedCacheNodesPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReservedCacheNodesPages), arg0, arg1)
}

// DescribeReservedCacheNodesPagesWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeReservedCacheNodesPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeReservedCacheNodesInput, arg2 func(*elasticache.DescribeReservedCacheNodesOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeReservedCacheNodesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeReservedCacheNodesPagesWithContext indicates an expected call of DescribeReservedCacheNodesPagesWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeReservedCacheNodesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedCacheNodesPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReservedCacheNodesPagesWithContext), varargs...)
}

// DescribeReservedCacheNodesOfferings mocks base method
func (m *MockElastiCacheAPI) DescribeReservedCacheNodesOfferings(arg0 *elasticache.DescribeReservedCacheNodesOfferingsInput) (*elasticache.DescribeReservedCacheNodesOfferingsOutput, error) {
	ret := m.ctrl.Call(m, "DescribeReservedCacheNodesOfferings", arg0)
	ret0, _ := ret[0].(*elasticache.DescribeReservedCacheNodesOfferingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeReservedCacheNodesOfferings indicates an expected call of DescribeReservedCacheNodesOfferings
func (mr *MockElastiCacheAPIMockRecorder) DescribeReservedCacheNodesOfferings(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedCacheNodesOfferings", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReservedCacheNodesOfferings), arg0)
}

// DescribeReservedCacheNodesOfferingsWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeReservedCacheNodesOfferingsWithContext(arg0 aws.Context, arg1 *elasticache.DescribeReservedCacheNodesOfferingsInput, arg2 ...request.Option) (*elasticache.DescribeReservedCacheNodesOfferingsOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeReservedCacheNodesOfferingsWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.DescribeReservedCacheNodesOfferingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeReservedCacheNodesOfferingsWithContext indicates an expected call of DescribeReservedCacheNodesOfferingsWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeReservedCacheNodesOfferingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedCacheNodesOfferingsWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReservedCacheNodesOfferingsWithContext), varargs...)
}

// DescribeReservedCacheNodesOfferingsRequest mocks base method
func (m *MockElastiCacheAPI) DescribeReservedCacheNodesOfferingsRequest(arg0 *elasticache.DescribeReservedCacheNodesOfferingsInput) (*request.Request, *elasticache.DescribeReservedCacheNodesOfferingsOutput) {
	ret := m.ctrl.Call(m, "DescribeReservedCacheNodesOfferingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.DescribeReservedCacheNodesOfferingsOutput)
	return ret0, ret1
}

// DescribeReservedCacheNodesOfferingsRequest indicates an expected call of DescribeReservedCacheNodesOfferingsRequest
func (mr *MockElastiCacheAPIMockRecorder) DescribeReservedCacheNodesOfferingsRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedCacheNodesOfferingsRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReservedCacheNodesOfferingsRequest), arg0)
}

// DescribeReservedCacheNodesOfferingsPages mocks base method
func (m *MockElastiCacheAPI) DescribeReservedCacheNodesOfferingsPages(arg0 *elasticache.DescribeReservedCacheNodesOfferingsInput, arg1 func(*elasticache.DescribeReservedCacheNodesOfferingsOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "DescribeReservedCacheNodesOfferingsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeReservedCacheNodesOfferingsPages indicates an expected call of DescribeReservedCacheNodesOfferingsPages
func (mr *MockElastiCacheAPIMockRecorder) DescribeReservedCacheNodesOfferingsPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedCacheNodesOfferingsPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReservedCacheNodesOfferingsPages), arg0, arg1)
}

// DescribeReservedCacheNodesOfferingsPagesWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeReservedCacheNodesOfferingsPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeReservedCacheNodesOfferingsInput, arg2 func(*elasticache.DescribeReservedCacheNodesOfferingsOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeReservedCacheNodesOfferingsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeReservedCacheNodesOfferingsPagesWithContext indicates an expected call of DescribeReservedCacheNodesOfferingsPagesWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeReservedCacheNodesOfferingsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedCacheNodesOfferingsPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeReservedCacheNodesOfferingsPagesWithContext), varargs...)
}

// DescribeSnapshots mocks base method
func (m *MockElastiCacheAPI) DescribeSnapshots(arg0 *elasticache.DescribeSnapshotsInput) (*elasticache.DescribeSnapshotsOutput, error) {
	ret := m.ctrl.Call(m, "DescribeSnapshots", arg0)
	ret0, _ := ret[0].(*elasticache.DescribeSnapshotsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeSnapshots indicates an expected call of DescribeSnapshots
func (mr *MockElastiCacheAPIMockRecorder) DescribeSnapshots(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshots", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeSnapshots), arg0)
}

// DescribeSnapshotsWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeSnapshotsWithContext(arg0 aws.Context, arg1 *elasticache.DescribeSnapshotsInput, arg2 ...request.Option) (*elasticache.DescribeSnapshotsOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSnapshotsWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.DescribeSnapshotsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeSnapshotsWithContext indicates an expected call of DescribeSnapshotsWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeSnapshotsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeSnapshotsWithContext), varargs...)
}

// DescribeSnapshotsRequest mocks base method
func (m *MockElastiCacheAPI) DescribeSnapshotsRequest(arg0 *elasticache.DescribeSnapshotsInput) (*request.Request, *elasticache.DescribeSnapshotsOutput) {
	ret := m.ctrl.Call(m, "DescribeSnapshotsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.DescribeSnapshotsOutput)
	return ret0, ret1
}

// DescribeSnapshotsRequest indicates an expected call of DescribeSnapshotsRequest
func (mr *MockElastiCacheAPIMockRecorder) DescribeSnapshotsRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeSnapshotsRequest), arg0)
}

// DescribeSnapshotsPages mocks base method
func (m *MockElastiCacheAPI) DescribeSnapshotsPages(arg0 *elasticache.DescribeSnapshotsInput, arg1 func(*elasticache.DescribeSnapshotsOutput, bool) bool) error {
	ret := m.ctrl.Call(m, "DescribeSnapshotsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeSnapshotsPages indicates an expected call of DescribeSnapshotsPages
func (mr *MockElastiCacheAPIMockRecorder) DescribeSnapshotsPages(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsPages", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeSnapshotsPages), arg0, arg1)
}

// DescribeSnapshotsPagesWithContext mocks base method
func (m *MockElastiCacheAPI) DescribeSnapshotsPagesWithContext(arg0 aws.Context, arg1 *elasticache.DescribeSnapshotsInput, arg2 func(*elasticache.DescribeSnapshotsOutput, bool) bool, arg3 ...request.Option) error {
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSnapshotsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DescribeSnapshotsPagesWithContext indicates an expected call of DescribeSnapshotsPagesWithContext
func (mr *MockElastiCacheAPIMockRecorder) DescribeSnapshotsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsPagesWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).DescribeSnapshotsPagesWithContext), varargs...)
}

// ListAllowedNodeTypeModifications mocks base method
func (m *MockElastiCacheAPI) ListAllowedNodeTypeModifications(arg0 *elasticache.ListAllowedNodeTypeModificationsInput) (*elasticache.ListAllowedNodeTypeModificationsOutput, error) {
	ret := m.ctrl.Call(m, "ListAllowedNodeTypeModifications", arg0)
	ret0, _ := ret[0].(*elasticache.ListAllowedNodeTypeModificationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAllowedNodeTypeModifications indicates an expected call of ListAllowedNodeTypeModifications
func (mr *MockElastiCacheAPIMockRecorder) ListAllowedNodeTypeModifications(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllowedNodeTypeModifications", reflect.TypeOf((*MockElastiCacheAPI)(nil).ListAllowedNodeTypeModifications), arg0)
}

// ListAllowedNodeTypeModificationsWithContext mocks base method
func (m *MockElastiCacheAPI) ListAllowedNodeTypeModificationsWithContext(arg0 aws.Context, arg1 *elasticache.ListAllowedNodeTypeModificationsInput, arg2 ...request.Option) (*elasticache.ListAllowedNodeTypeModificationsOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAllowedNodeTypeModificationsWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.ListAllowedNodeTypeModificationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAllowedNodeTypeModificationsWithContext indicates an expected call of ListAllowedNodeTypeModificationsWithContext
func (mr *MockElastiCacheAPIMockRecorder) ListAllowedNodeTypeModificationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllowedNodeTypeModificationsWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).ListAllowedNodeTypeModificationsWithContext), varargs...)
}

// ListAllowedNodeTypeModificationsRequest mocks base method
func (m *MockElastiCacheAPI) ListAllowedNodeTypeModificationsRequest(arg0 *elasticache.ListAllowedNodeTypeModificationsInput) (*request.Request, *elasticache.ListAllowedNodeTypeModificationsOutput) {
	ret := m.ctrl.Call(m, "ListAllowedNodeTypeModificationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.ListAllowedNodeTypeModificationsOutput)
	return ret0, ret1
}

// ListAllowedNodeTypeModificationsRequest indicates an expected call of ListAllowedNodeTypeModificationsRequest
func (mr *MockElastiCacheAPIMockRecorder) ListAllowedNodeTypeModificationsRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllowedNodeTypeModificationsRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).ListAllowedNodeTypeModificationsRequest), arg0)
}

// ListTagsForResource mocks base method
func (m *MockElastiCacheAPI) ListTagsForResource(arg0 *elasticache.ListTagsForResourceInput) (*elasticache.TagListMessage, error) {
	ret := m.ctrl.Call(m, "ListTagsForResource", arg0)
	ret0, _ := ret[0].(*elasticache.TagListMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTagsForResource indicates an expected call of ListTagsForResource
func (mr *MockElastiCacheAPIMockRecorder) ListTagsForResource(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResource", reflect.TypeOf((*MockElastiCacheAPI)(nil).ListTagsForResource), arg0)
}

// ListTagsForResourceWithContext mocks base method
func (m *MockElastiCacheAPI) ListTagsForResourceWithContext(arg0 aws.Context, arg1 *elasticache.ListTagsForResourceInput, arg2 ...request.Option) (*elasticache.TagListMessage, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTagsForResourceWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.TagListMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext
func (mr *MockElastiCacheAPIMockRecorder) ListTagsForResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).ListTagsForResourceWithContext), varargs...)
}

// ListTagsForResourceRequest mocks base method
func (m *MockElastiCacheAPI) ListTagsForResourceRequest(arg0 *elasticache.ListTagsForResourceInput) (*request.Request, *elasticache.TagListMessage) {
	ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.TagListMessage)
	return ret0, ret1
}

// ListTagsForResourceRequest indicates an expected call of ListTagsForResourceRequest
func (mr *MockElastiCacheAPIMockRecorder) ListTagsForResourceRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).ListTagsForResourceRequest), arg0)
}

// ModifyCacheCluster mocks base method
func (m *MockElastiCacheAPI) ModifyCacheCluster(arg0 *elasticache.ModifyCacheClusterInput) (*elasticache.ModifyCacheClusterOutput, error) {
	ret := m.ctrl.Call(m, "ModifyCacheCluster", arg0)
	ret0, _ := ret[0].(*elasticache.ModifyCacheClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyCacheCluster indicates an expected call of ModifyCacheCluster
func (mr *MockElastiCacheAPIMockRecorder) ModifyCacheCluster(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCacheCluster", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyCacheCluster), arg0)
}

// ModifyCacheClusterWithContext mocks base method
func (m *MockElastiCacheAPI) ModifyCacheClusterWithContext(arg0 aws.Context, arg1 *elasticache.ModifyCacheClusterInput, arg2 ...request.Option) (*elasticache.ModifyCacheClusterOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyCacheClusterWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.ModifyCacheClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyCacheClusterWithContext indicates an expected call of ModifyCacheClusterWithContext
func (mr *MockElastiCacheAPIMockRecorder) ModifyCacheClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCacheClusterWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyCacheClusterWithContext), varargs...)
}

// ModifyCacheClusterRequest mocks base method
func (m *MockElastiCacheAPI) ModifyCacheClusterRequest(arg0 *elasticache.ModifyCacheClusterInput) (*request.Request, *elasticache.ModifyCacheClusterOutput) {
	ret := m.ctrl.Call(m, "ModifyCacheClusterRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.ModifyCacheClusterOutput)
	return ret0, ret1
}

// ModifyCacheClusterRequest indicates an expected call of ModifyCacheClusterRequest
func (mr *MockElastiCacheAPIMockRecorder) ModifyCacheClusterRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCacheClusterRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyCacheClusterRequest), arg0)
}

// ModifyCacheParameterGroup mocks base method
func (m *MockElastiCacheAPI) ModifyCacheParameterGroup(arg0 *elasticache.ModifyCacheParameterGroupInput) (*elasticache.CacheParameterGroupNameMessage, error) {
	ret := m.ctrl.Call(m, "ModifyCacheParameterGroup", arg0)
	ret0, _ := ret[0].(*elasticache.CacheParameterGroupNameMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyCacheParameterGroup indicates an expected call of ModifyCacheParameterGroup
func (mr *MockElastiCacheAPIMockRecorder) ModifyCacheParameterGroup(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCacheParameterGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyCacheParameterGroup), arg0)
}

// ModifyCacheParameterGroupWithContext mocks base method
func (m *MockElastiCacheAPI) ModifyCacheParameterGroupWithContext(arg0 aws.Context, arg1 *elasticache.ModifyCacheParameterGroupInput, arg2 ...request.Option) (*elasticache.CacheParameterGroupNameMessage, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyCacheParameterGroupWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.CacheParameterGroupNameMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyCacheParameterGroupWithContext indicates an expected call of ModifyCacheParameterGroupWithContext
func (mr *MockElastiCacheAPIMockRecorder) ModifyCacheParameterGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCacheParameterGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyCacheParameterGroupWithContext), varargs...)
}

// ModifyCacheParameterGroupRequest mocks base method
func (m *MockElastiCacheAPI) ModifyCacheParameterGroupRequest(arg0 *elasticache.ModifyCacheParameterGroupInput) (*request.Request, *elasticache.CacheParameterGroupNameMessage) {
	ret := m.ctrl.Call(m, "ModifyCacheParameterGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.CacheParameterGroupNameMessage)
	return ret0, ret1
}

// ModifyCacheParameterGroupRequest indicates an expected call of ModifyCacheParameterGroupRequest
func (mr *MockElastiCacheAPIMockRecorder) ModifyCacheParameterGroupRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCacheParameterGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyCacheParameterGroupRequest), arg0)
}

// ModifyCacheSubnetGroup mocks base method
func (m *MockElastiCacheAPI) ModifyCacheSubnetGroup(arg0 *elasticache.ModifyCacheSubnetGroupInput) (*elasticache.ModifyCacheSubnetGroupOutput, error) {
	ret := m.ctrl.Call(m, "ModifyCacheSubnetGroup", arg0)
	ret0, _ := ret[0].(*elasticache.ModifyCacheSubnetGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyCacheSubnetGroup indicates an expected call of ModifyCacheSubnetGroup
func (mr *MockElastiCacheAPIMockRecorder) ModifyCacheSubnetGroup(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCacheSubnetGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyCacheSubnetGroup), arg0)
}

// ModifyCacheSubnetGroupWithContext mocks base method
func (m *MockElastiCacheAPI) ModifyCacheSubnetGroupWithContext(arg0 aws.Context, arg1 *elasticache.ModifyCacheSubnetGroupInput, arg2 ...request.Option) (*elasticache.ModifyCacheSubnetGroupOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyCacheSubnetGroupWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.ModifyCacheSubnetGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyCacheSubnetGroupWithContext indicates an expected call of ModifyCacheSubnetGroupWithContext
func (mr *MockElastiCacheAPIMockRecorder) ModifyCacheSubnetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCacheSubnetGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyCacheSubnetGroupWithContext), varargs...)
}

// ModifyCacheSubnetGroupRequest mocks base method
func (m *MockElastiCacheAPI) ModifyCacheSubnetGroupRequest(arg0 *elasticache.ModifyCacheSubnetGroupInput) (*request.Request, *elasticache.ModifyCacheSubnetGroupOutput) {
	ret := m.ctrl.Call(m, "ModifyCacheSubnetGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.ModifyCacheSubnetGroupOutput)
	return ret0, ret1
}

// ModifyCacheSubnetGroupRequest indicates an expected call of ModifyCacheSubnetGroupRequest
func (mr *MockElastiCacheAPIMockRecorder) ModifyCacheSubnetGroupRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCacheSubnetGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyCacheSubnetGroupRequest), arg0)
}

// ModifyReplicationGroup mocks base method
func (m *MockElastiCacheAPI) ModifyReplicationGroup(arg0 *elasticache.ModifyReplicationGroupInput) (*elasticache.ModifyReplicationGroupOutput, error) {
	ret := m.ctrl.Call(m, "ModifyReplicationGroup", arg0)
	ret0, _ := ret[0].(*elasticache.ModifyReplicationGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyReplicationGroup indicates an expected call of ModifyReplicationGroup
func (mr *MockElastiCacheAPIMockRecorder) ModifyReplicationGroup(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReplicationGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyReplicationGroup), arg0)
}

// ModifyReplicationGroupWithContext mocks base method
func (m *MockElastiCacheAPI) ModifyReplicationGroupWithContext(arg0 aws.Context, arg1 *elasticache.ModifyReplicationGroupInput, arg2 ...request.Option) (*elasticache.ModifyReplicationGroupOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyReplicationGroupWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.ModifyReplicationGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyReplicationGroupWithContext indicates an expected call of ModifyReplicationGroupWithContext
func (mr *MockElastiCacheAPIMockRecorder) ModifyReplicationGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReplicationGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyReplicationGroupWithContext), varargs...)
}

// ModifyReplicationGroupRequest mocks base method
func (m *MockElastiCacheAPI) ModifyReplicationGroupRequest(arg0 *elasticache.ModifyReplicationGroupInput) (*request.Request, *elasticache.ModifyReplicationGroupOutput) {
	ret := m.ctrl.Call(m, "ModifyReplicationGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.ModifyReplicationGroupOutput)
	return ret0, ret1
}

// ModifyReplicationGroupRequest indicates an expected call of ModifyReplicationGroupRequest
func (mr *MockElastiCacheAPIMockRecorder) ModifyReplicationGroupRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReplicationGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyReplicationGroupRequest), arg0)
}

// ModifyReplicationGroupShardConfiguration mocks base method
func (m *MockElastiCacheAPI) ModifyReplicationGroupShardConfiguration(arg0 *elasticache.ModifyReplicationGroupShardConfigurationInput) (*elasticache.ModifyReplicationGroupShardConfigurationOutput, error) {
	ret := m.ctrl.Call(m, "ModifyReplicationGroupShardConfiguration", arg0)
	ret0, _ := ret[0].(*elasticache.ModifyReplicationGroupShardConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyReplicationGroupShardConfiguration indicates an expected call of ModifyReplicationGroupShardConfiguration
func (mr *MockElastiCacheAPIMockRecorder) ModifyReplicationGroupShardConfiguration(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReplicationGroupShardConfiguration", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyReplicationGroupShardConfiguration), arg0)
}

// ModifyReplicationGroupShardConfigurationWithContext mocks base method
func (m *MockElastiCacheAPI) ModifyReplicationGroupShardConfigurationWithContext(arg0 aws.Context, arg1 *elasticache.ModifyReplicationGroupShardConfigurationInput, arg2 ...request.Option) (*elasticache.ModifyReplicationGroupShardConfigurationOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ModifyReplicationGroupShardConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.ModifyReplicationGroupShardConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyReplicationGroupShardConfigurationWithContext indicates an expected call of ModifyReplicationGroupShardConfigurationWithContext
func (mr *MockElastiCacheAPIMockRecorder) ModifyReplicationGroupShardConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReplicationGroupShardConfigurationWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyReplicationGroupShardConfigurationWithContext), varargs...)
}

// ModifyReplicationGroupShardConfigurationRequest mocks base method
func (m *MockElastiCacheAPI) ModifyReplicationGroupShardConfigurationRequest(arg0 *elasticache.ModifyReplicationGroupShardConfigurationInput) (*request.Request, *elasticache.ModifyReplicationGroupShardConfigurationOutput) {
	ret := m.ctrl.Call(m, "ModifyReplicationGroupShardConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.ModifyReplicationGroupShardConfigurationOutput)
	return ret0, ret1
}

// ModifyReplicationGroupShardConfigurationRequest indicates an expected call of ModifyReplicationGroupShardConfigurationRequest
func (mr *MockElastiCacheAPIMockRecorder) ModifyReplicationGroupShardConfigurationRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReplicationGroupShardConfigurationRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).ModifyReplicationGroupShardConfigurationRequest), arg0)
}

// PurchaseReservedCacheNodesOffering mocks base method
func (m *MockElastiCacheAPI) PurchaseReservedCacheNodesOffering(arg0 *elasticache.PurchaseReservedCacheNodesOfferingInput) (*elasticache.PurchaseReservedCacheNodesOfferingOutput, error) {
	ret := m.ctrl.Call(m, "PurchaseReservedCacheNodesOffering", arg0)
	ret0, _ := ret[0].(*elasticache.PurchaseReservedCacheNodesOfferingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PurchaseReservedCacheNodesOffering indicates an expected call of PurchaseReservedCacheNodesOffering
func (mr *MockElastiCacheAPIMockRecorder) PurchaseReservedCacheNodesOffering(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedCacheNodesOffering", reflect.TypeOf((*MockElastiCacheAPI)(nil).PurchaseReservedCacheNodesOffering), arg0)
}

// PurchaseReservedCacheNodesOfferingWithContext mocks base method
func (m *MockElastiCacheAPI) PurchaseReservedCacheNodesOfferingWithContext(arg0 aws.Context, arg1 *elasticache.PurchaseReservedCacheNodesOfferingInput, arg2 ...request.Option) (*elasticache.PurchaseReservedCacheNodesOfferingOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PurchaseReservedCacheNodesOfferingWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.PurchaseReservedCacheNodesOfferingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PurchaseReservedCacheNodesOfferingWithContext indicates an expected call of PurchaseReservedCacheNodesOfferingWithContext
func (mr *MockElastiCacheAPIMockRecorder) PurchaseReservedCacheNodesOfferingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedCacheNodesOfferingWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).PurchaseReservedCacheNodesOfferingWithContext), varargs...)
}

// PurchaseReservedCacheNodesOfferingRequest mocks base method
func (m *MockElastiCacheAPI) PurchaseReservedCacheNodesOfferingRequest(arg0 *elasticache.PurchaseReservedCacheNodesOfferingInput) (*request.Request, *elasticache.PurchaseReservedCacheNodesOfferingOutput) {
	ret := m.ctrl.Call(m, "PurchaseReservedCacheNodesOfferingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.PurchaseReservedCacheNodesOfferingOutput)
	return ret0, ret1
}

// PurchaseReservedCacheNodesOfferingRequest indicates an expected call of PurchaseReservedCacheNodesOfferingRequest
func (mr *MockElastiCacheAPIMockRecorder) PurchaseReservedCacheNodesOfferingRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedCacheNodesOfferingRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).PurchaseReservedCacheNodesOfferingRequest), arg0)
}

// RebootCacheCluster mocks base method
func (m *MockElastiCacheAPI) RebootCacheCluster(arg0 *elasticache.RebootCacheClusterInput) (*elasticache.RebootCacheClusterOutput, error) {
	ret := m.ctrl.Call(m, "RebootCacheCluster", arg0)
	ret0, _ := ret[0].(*elasticache.RebootCacheClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RebootCacheCluster indicates an expected call of RebootCacheCluster
func (mr *MockElastiCacheAPIMockRecorder) RebootCacheCluster(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootCacheCluster", reflect.TypeOf((*MockElastiCacheAPI)(nil).RebootCacheCluster), arg0)
}

// RebootCacheClusterWithContext mocks base method
func (m *MockElastiCacheAPI) RebootCacheClusterWithContext(arg0 aws.Context, arg1 *elasticache.RebootCacheClusterInput, arg2 ...request.Option) (*elasticache.RebootCacheClusterOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RebootCacheClusterWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.RebootCacheClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RebootCacheClusterWithContext indicates an expected call of RebootCacheClusterWithContext
func (mr *MockElastiCacheAPIMockRecorder) RebootCacheClusterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootCacheClusterWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).RebootCacheClusterWithContext), varargs...)
}

// RebootCacheClusterRequest mocks base method
func (m *MockElastiCacheAPI) RebootCacheClusterRequest(arg0 *elasticache.RebootCacheClusterInput) (*request.Request, *elasticache.RebootCacheClusterOutput) {
	ret := m.ctrl.Call(m, "RebootCacheClusterRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.RebootCacheClusterOutput)
	return ret0, ret1
}

// RebootCacheClusterRequest indicates an expected call of RebootCacheClusterRequest
func (mr *MockElastiCacheAPIMockRecorder) RebootCacheClusterRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootCacheClusterRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).RebootCacheClusterRequest), arg0)
}

// RemoveTagsFromResource mocks base method
func (m *MockElastiCacheAPI) RemoveTagsFromResource(arg0 *elasticache.RemoveTagsFromResourceInput) (*elasticache.TagListMessage, error) {
	ret := m.ctrl.Call(m, "RemoveTagsFromResource", arg0)
	ret0, _ := ret[0].(*elasticache.TagListMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveTagsFromResource indicates an expected call of RemoveTagsFromResource
func (mr *MockElastiCacheAPIMockRecorder) RemoveTagsFromResource(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromResource", reflect.TypeOf((*MockElastiCacheAPI)(nil).RemoveTagsFromResource), arg0)
}

// RemoveTagsFromResourceWithContext mocks base method
func (m *MockElastiCacheAPI) RemoveTagsFromResourceWithContext(arg0 aws.Context, arg1 *elasticache.RemoveTagsFromResourceInput, arg2 ...request.Option) (*elasticache.TagListMessage, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemoveTagsFromResourceWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.TagListMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveTagsFromResourceWithContext indicates an expected call of RemoveTagsFromResourceWithContext
func (mr *MockElastiCacheAPIMockRecorder) RemoveTagsFromResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromResourceWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).RemoveTagsFromResourceWithContext), varargs...)
}

// RemoveTagsFromResourceRequest mocks base method
func (m *MockElastiCacheAPI) RemoveTagsFromResourceRequest(arg0 *elasticache.RemoveTagsFromResourceInput) (*request.Request, *elasticache.TagListMessage) {
	ret := m.ctrl.Call(m, "RemoveTagsFromResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.TagListMessage)
	return ret0, ret1
}

// RemoveTagsFromResourceRequest indicates an expected call of RemoveTagsFromResourceRequest
func (mr *MockElastiCacheAPIMockRecorder) RemoveTagsFromResourceRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromResourceRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).RemoveTagsFromResourceRequest), arg0)
}

// ResetCacheParameterGroup mocks base method
func (m *MockElastiCacheAPI) ResetCacheParameterGroup(arg0 *elasticache.ResetCacheParameterGroupInput) (*elasticache.CacheParameterGroupNameMessage, error) {
	ret := m.ctrl.Call(m, "ResetCacheParameterGroup", arg0)
	ret0, _ := ret[0].(*elasticache.CacheParameterGroupNameMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResetCacheParameterGroup indicates an expected call of ResetCacheParameterGroup
func (mr *MockElastiCacheAPIMockRecorder) ResetCacheParameterGroup(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetCacheParameterGroup", reflect.TypeOf((*MockElastiCacheAPI)(nil).ResetCacheParameterGroup), arg0)
}

// ResetCacheParameterGroupWithContext mocks base method
func (m *MockElastiCacheAPI) ResetCacheParameterGroupWithContext(arg0 aws.Context, arg1 *elasticache.ResetCacheParameterGroupInput, arg2 ...request.Option) (*elasticache.CacheParameterGroupNameMessage, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResetCacheParameterGroupWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.CacheParameterGroupNameMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResetCacheParameterGroupWithContext indicates an expected call of ResetCacheParameterGroupWithContext
func (mr *MockElastiCacheAPIMockRecorder) ResetCacheParameterGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetCacheParameterGroupWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).ResetCacheParameterGroupWithContext), varargs...)
}

// ResetCacheParameterGroupRequest mocks base method
func (m *MockElastiCacheAPI) ResetCacheParameterGroupRequest(arg0 *elasticache.ResetCacheParameterGroupInput) (*request.Request, *elasticache.CacheParameterGroupNameMessage) {
	ret := m.ctrl.Call(m, "ResetCacheParameterGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.CacheParameterGroupNameMessage)
	return ret0, ret1
}

// ResetCacheParameterGroupRequest indicates an expected call of ResetCacheParameterGroupRequest
func (mr *MockElastiCacheAPIMockRecorder) ResetCacheParameterGroupRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetCacheParameterGroupRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).ResetCacheParameterGroupRequest), arg0)
}

// RevokeCacheSecurityGroupIngress mocks base method
func (m *MockElastiCacheAPI) RevokeCacheSecurityGroupIngress(arg0 *elasticache.RevokeCacheSecurityGroupIngressInput) (*elasticache.RevokeCacheSecurityGroupIngressOutput, error) {
	ret := m.ctrl.Call(m, "RevokeCacheSecurityGroupIngress", arg0)
	ret0, _ := ret[0].(*elasticache.RevokeCacheSecurityGroupIngressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RevokeCacheSecurityGroupIngress indicates an expected call of RevokeCacheSecurityGroupIngress
func (mr *MockElastiCacheAPIMockRecorder) RevokeCacheSecurityGroupIngress(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeCacheSecurityGroupIngress", reflect.TypeOf((*MockElastiCacheAPI)(nil).RevokeCacheSecurityGroupIngress), arg0)
}

// RevokeCacheSecurityGroupIngressWithContext mocks base method
func (m *MockElastiCacheAPI) RevokeCacheSecurityGroupIngressWithContext(arg0 aws.Context, arg1 *elasticache.RevokeCacheSecurityGroupIngressInput, arg2 ...request.Option) (*elasticache.RevokeCacheSecurityGroupIngressOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RevokeCacheSecurityGroupIngressWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.RevokeCacheSecurityGroupIngressOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RevokeCacheSecurityGroupIngressWithContext indicates an expected call of RevokeCacheSecurityGroupIngressWithContext
func (mr *MockElastiCacheAPIMockRecorder) RevokeCacheSecurityGroupIngressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeCacheSecurityGroupIngressWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).RevokeCacheSecurityGroupIngressWithContext), varargs...)
}

// RevokeCacheSecurityGroupIngressRequest mocks base method
func (m *MockElastiCacheAPI) RevokeCacheSecurityGroupIngressRequest(arg0 *elasticache.RevokeCacheSecurityGroupIngressInput) (*request.Request, *elasticache.RevokeCacheSecurityGroupIngressOutput) {
	ret := m.ctrl.Call(m, "RevokeCacheSecurityGroupIngressRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.RevokeCacheSecurityGroupIngressOutput)
	return ret0, ret1
}

// RevokeCacheSecurityGroupIngressRequest indicates an expected call of RevokeCacheSecurityGroupIngressRequest
func (mr *MockElastiCacheAPIMockRecorder) RevokeCacheSecurityGroupIngressRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeCacheSecurityGroupIngressRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).RevokeCacheSecurityGroupIngressRequest), arg0)
}

// TestFailover mocks base method
func (m *MockElastiCacheAPI) TestFailover(arg0 *elasticache.TestFailoverInput) (*elasticache.TestFailoverOutput, error) {
	ret := m.ctrl.Call(m, "TestFailover", arg0)
	ret0, _ := ret[0].(*elasticache.TestFailoverOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TestFailover indicates an expected call of TestFailover
func (mr *MockElastiCacheAPIMockRecorder) TestFailover(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestFailover", reflect.TypeOf((*MockElastiCacheAPI)(nil).TestFailover), arg0)
}

// TestFailoverWithContext mocks base method
func (m *MockElastiCacheAPI) TestFailoverWithContext(arg0 aws.Context, arg1 *elasticache.TestFailoverInput, arg2 ...request.Option) (*elasticache.TestFailoverOutput, error) {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TestFailoverWithContext", varargs...)
	ret0, _ := ret[0].(*elasticache.TestFailoverOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TestFailoverWithContext indicates an expected call of TestFailoverWithContext
func (mr *MockElastiCacheAPIMockRecorder) TestFailoverWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestFailoverWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).TestFailoverWithContext), varargs...)
}

// TestFailoverRequest mocks base method
func (m *MockElastiCacheAPI) TestFailoverRequest(arg0 *elasticache.TestFailoverInput) (*request.Request, *elasticache.TestFailoverOutput) {
	ret := m.ctrl.Call(m, "TestFailoverRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*elasticache.TestFailoverOutput)
	return ret0, ret1
}

// TestFailoverRequest indicates an expected call of TestFailoverRequest
func (mr *MockElastiCacheAPIMockRecorder) TestFailoverRequest(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestFailoverRequest", reflect.TypeOf((*MockElastiCacheAPI)(nil).TestFailoverRequest), arg0)
}

// WaitUntilCacheClusterAvailable mocks base method
func (m *MockElastiCacheAPI) WaitUntilCacheClusterAvailable(arg0 *elasticache.DescribeCacheClustersInput) error {
	ret := m.ctrl.Call(m, "WaitUntilCacheClusterAvailable", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilCacheClusterAvailable indicates an expected call of WaitUntilCacheClusterAvailable
func (mr *MockElastiCacheAPIMockRecorder) WaitUntilCacheClusterAvailable(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilCacheClusterAvailable", reflect.TypeOf((*MockElastiCacheAPI)(nil).WaitUntilCacheClusterAvailable), arg0)
}

// WaitUntilCacheClusterAvailableWithContext mocks base method
func (m *MockElastiCacheAPI) WaitUntilCacheClusterAvailableWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheClustersInput, arg2 ...request.WaiterOption) error {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilCacheClusterAvailableWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilCacheClusterAvailableWithContext indicates an expected call of WaitUntilCacheClusterAvailableWithContext
func (mr *MockElastiCacheAPIMockRecorder) WaitUntilCacheClusterAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilCacheClusterAvailableWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).WaitUntilCacheClusterAvailableWithContext), varargs...)
}

// WaitUntilCacheClusterDeleted mocks base method
func (m *MockElastiCacheAPI) WaitUntilCacheClusterDeleted(arg0 *elasticache.DescribeCacheClustersInput) error {
	ret := m.ctrl.Call(m, "WaitUntilCacheClusterDeleted", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilCacheClusterDeleted indicates an expected call of WaitUntilCacheClusterDeleted
func (mr *MockElastiCacheAPIMockRecorder) WaitUntilCacheClusterDeleted(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilCacheClusterDeleted", reflect.TypeOf((*MockElastiCacheAPI)(nil).WaitUntilCacheClusterDeleted), arg0)
}

// WaitUntilCacheClusterDeletedWithContext mocks base method
func (m *MockElastiCacheAPI) WaitUntilCacheClusterDeletedWithContext(arg0 aws.Context, arg1 *elasticache.DescribeCacheClustersInput, arg2 ...request.WaiterOption) error {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilCacheClusterDeletedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilCacheClusterDeletedWithContext indicates an expected call of WaitUntilCacheClusterDeletedWithContext
func (mr *MockElastiCacheAPIMockRecorder) WaitUntilCacheClusterDeletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilCacheClusterDeletedWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).WaitUntilCacheClusterDeletedWithContext), varargs...)
}

// WaitUntilReplicationGroupAvailable mocks base method
func (m *MockElastiCacheAPI) WaitUntilReplicationGroupAvailable(arg0 *elasticache.DescribeReplicationGroupsInput) error {
	ret := m.ctrl.Call(m, "WaitUntilReplicationGroupAvailable", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilReplicationGroupAvailable indicates an expected call of WaitUntilReplicationGroupAvailable
func (mr *MockElastiCacheAPIMockRecorder) WaitUntilReplicationGroupAvailable(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilReplicationGroupAvailable", reflect.TypeOf((*MockElastiCacheAPI)(nil).WaitUntilReplicationGroupAvailable), arg0)
}

// WaitUntilReplicationGroupAvailableWithContext mocks base method
func (m *MockElastiCacheAPI) WaitUntilReplicationGroupAvailableWithContext(arg0 aws.Context, arg1 *elasticache.DescribeReplicationGroupsInput, arg2 ...request.WaiterOption) error {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilReplicationGroupAvailableWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilReplicationGroupAvailableWithContext indicates an expected call of WaitUntilReplicationGroupAvailableWithContext
func (mr *MockElastiCacheAPIMockRecorder) WaitUntilReplicationGroupAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilReplicationGroupAvailableWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).WaitUntilReplicationGroupAvailableWithContext), varargs...)
}

// WaitUntilReplicationGroupDeleted mocks base method
func (m *MockElastiCacheAPI) WaitUntilReplicationGroupDeleted(arg0 *elasticache.DescribeReplicationGroupsInput) error {
	ret := m.ctrl.Call(m, "WaitUntilReplicationGroupDeleted", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilReplicationGroupDeleted indicates an expected call of WaitUntilReplicationGroupDeleted
func (mr *MockElastiCacheAPIMockRecorder) WaitUntilReplicationGroupDeleted(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilReplicationGroupDeleted", reflect.TypeOf((*MockElastiCacheAPI)(nil).WaitUntilReplicationGroupDeleted), arg0)
}

// WaitUntilReplicationGroupDeletedWithContext mocks base method
func (m *MockElastiCacheAPI) WaitUntilReplicationGroupDeletedWithContext(arg0 aws.Context, arg1 *elasticache.DescribeReplicationGroupsInput, arg2 ...request.WaiterOption) error {
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilReplicationGroupDeletedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilReplicationGroupDeletedWithContext indicates an expected call of WaitUntilReplicationGroupDeletedWithContext
func (mr *MockElastiCacheAPIMockRecorder) WaitUntilReplicationGroupDeletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilReplicationGroupDeletedWithContext", reflect.TypeOf((*MockElastiCacheAPI)(nil).WaitUntilReplicationGroupDeletedWithContext), varargs...)
}