ElastiCacheAPI.go

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

package mocks

import (
	context "context"

	elasticache "github.com/aws/aws-sdk-go/service/elasticache"

	mock "github.com/stretchr/testify/mock"

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

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

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.AuthorizeCacheSecurityGroupIngressOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.AuthorizeCacheSecurityGroupIngressInput, ...request.Option) (*elasticache.AuthorizeCacheSecurityGroupIngressOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.AuthorizeCacheSecurityGroupIngressInput, ...request.Option) *elasticache.AuthorizeCacheSecurityGroupIngressOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.AuthorizeCacheSecurityGroupIngressOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.BatchApplyUpdateActionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.BatchApplyUpdateActionInput, ...request.Option) (*elasticache.BatchApplyUpdateActionOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.BatchApplyUpdateActionInput, ...request.Option) *elasticache.BatchApplyUpdateActionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.BatchApplyUpdateActionOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.BatchStopUpdateActionOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.BatchStopUpdateActionInput, ...request.Option) (*elasticache.BatchStopUpdateActionOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.BatchStopUpdateActionInput, ...request.Option) *elasticache.BatchStopUpdateActionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.BatchStopUpdateActionOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.CompleteMigrationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CompleteMigrationInput, ...request.Option) (*elasticache.CompleteMigrationOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CompleteMigrationInput, ...request.Option) *elasticache.CompleteMigrationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CompleteMigrationOutput)
		}
	}

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

	return r0, r1
}

// CopyServerlessCacheSnapshot provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) CopyServerlessCacheSnapshot(_a0 *elasticache.CopyServerlessCacheSnapshotInput) (*elasticache.CopyServerlessCacheSnapshotOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.CopyServerlessCacheSnapshotOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*elasticache.CopyServerlessCacheSnapshotInput) (*elasticache.CopyServerlessCacheSnapshotOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*elasticache.CopyServerlessCacheSnapshotInput) *elasticache.CopyServerlessCacheSnapshotOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CopyServerlessCacheSnapshotOutput)
		}
	}

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

	return r0, r1
}

// CopyServerlessCacheSnapshotRequest provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) CopyServerlessCacheSnapshotRequest(_a0 *elasticache.CopyServerlessCacheSnapshotInput) (*request.Request, *elasticache.CopyServerlessCacheSnapshotOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

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

	var r0 *elasticache.CopyServerlessCacheSnapshotOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CopyServerlessCacheSnapshotInput, ...request.Option) (*elasticache.CopyServerlessCacheSnapshotOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CopyServerlessCacheSnapshotInput, ...request.Option) *elasticache.CopyServerlessCacheSnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CopyServerlessCacheSnapshotOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.CopySnapshotOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CopySnapshotInput, ...request.Option) (*elasticache.CopySnapshotOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CopySnapshotInput, ...request.Option) *elasticache.CopySnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CopySnapshotOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.CreateCacheClusterOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateCacheClusterInput, ...request.Option) (*elasticache.CreateCacheClusterOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateCacheClusterInput, ...request.Option) *elasticache.CreateCacheClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateCacheClusterOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.CreateCacheParameterGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateCacheParameterGroupInput, ...request.Option) (*elasticache.CreateCacheParameterGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateCacheParameterGroupInput, ...request.Option) *elasticache.CreateCacheParameterGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateCacheParameterGroupOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.CreateCacheSecurityGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateCacheSecurityGroupInput, ...request.Option) (*elasticache.CreateCacheSecurityGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateCacheSecurityGroupInput, ...request.Option) *elasticache.CreateCacheSecurityGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateCacheSecurityGroupOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.CreateCacheSubnetGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateCacheSubnetGroupInput, ...request.Option) (*elasticache.CreateCacheSubnetGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateCacheSubnetGroupInput, ...request.Option) *elasticache.CreateCacheSubnetGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateCacheSubnetGroupOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.CreateGlobalReplicationGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateGlobalReplicationGroupInput, ...request.Option) (*elasticache.CreateGlobalReplicationGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateGlobalReplicationGroupInput, ...request.Option) *elasticache.CreateGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.CreateReplicationGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateReplicationGroupInput, ...request.Option) (*elasticache.CreateReplicationGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateReplicationGroupInput, ...request.Option) *elasticache.CreateReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// CreateServerlessCache provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) CreateServerlessCache(_a0 *elasticache.CreateServerlessCacheInput) (*elasticache.CreateServerlessCacheOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.CreateServerlessCacheOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*elasticache.CreateServerlessCacheInput) (*elasticache.CreateServerlessCacheOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*elasticache.CreateServerlessCacheInput) *elasticache.CreateServerlessCacheOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateServerlessCacheOutput)
		}
	}

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

	return r0, r1
}

// CreateServerlessCacheRequest provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) CreateServerlessCacheRequest(_a0 *elasticache.CreateServerlessCacheInput) (*request.Request, *elasticache.CreateServerlessCacheOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// CreateServerlessCacheSnapshot provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) CreateServerlessCacheSnapshot(_a0 *elasticache.CreateServerlessCacheSnapshotInput) (*elasticache.CreateServerlessCacheSnapshotOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.CreateServerlessCacheSnapshotOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*elasticache.CreateServerlessCacheSnapshotInput) (*elasticache.CreateServerlessCacheSnapshotOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*elasticache.CreateServerlessCacheSnapshotInput) *elasticache.CreateServerlessCacheSnapshotOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateServerlessCacheSnapshotOutput)
		}
	}

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

	return r0, r1
}

// CreateServerlessCacheSnapshotRequest provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) CreateServerlessCacheSnapshotRequest(_a0 *elasticache.CreateServerlessCacheSnapshotInput) (*request.Request, *elasticache.CreateServerlessCacheSnapshotOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

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

	var r0 *elasticache.CreateServerlessCacheSnapshotOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateServerlessCacheSnapshotInput, ...request.Option) (*elasticache.CreateServerlessCacheSnapshotOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateServerlessCacheSnapshotInput, ...request.Option) *elasticache.CreateServerlessCacheSnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateServerlessCacheSnapshotOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *elasticache.CreateServerlessCacheOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateServerlessCacheInput, ...request.Option) (*elasticache.CreateServerlessCacheOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateServerlessCacheInput, ...request.Option) *elasticache.CreateServerlessCacheOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateServerlessCacheOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.CreateSnapshotOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateSnapshotInput, ...request.Option) (*elasticache.CreateSnapshotOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateSnapshotInput, ...request.Option) *elasticache.CreateSnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateSnapshotOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.CreateUserGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateUserGroupInput, ...request.Option) (*elasticache.CreateUserGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateUserGroupInput, ...request.Option) *elasticache.CreateUserGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateUserGroupOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.CreateUserOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateUserInput, ...request.Option) (*elasticache.CreateUserOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.CreateUserInput, ...request.Option) *elasticache.CreateUserOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CreateUserOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DecreaseNodeGroupsInGlobalReplicationGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DecreaseNodeGroupsInGlobalReplicationGroupInput, ...request.Option) (*elasticache.DecreaseNodeGroupsInGlobalReplicationGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DecreaseNodeGroupsInGlobalReplicationGroupInput, ...request.Option) *elasticache.DecreaseNodeGroupsInGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DecreaseNodeGroupsInGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DecreaseReplicaCountOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DecreaseReplicaCountInput, ...request.Option) (*elasticache.DecreaseReplicaCountOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DecreaseReplicaCountInput, ...request.Option) *elasticache.DecreaseReplicaCountOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DecreaseReplicaCountOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DeleteCacheClusterOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteCacheClusterInput, ...request.Option) (*elasticache.DeleteCacheClusterOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteCacheClusterInput, ...request.Option) *elasticache.DeleteCacheClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteCacheClusterOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DeleteCacheParameterGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteCacheParameterGroupInput, ...request.Option) (*elasticache.DeleteCacheParameterGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteCacheParameterGroupInput, ...request.Option) *elasticache.DeleteCacheParameterGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteCacheParameterGroupOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DeleteCacheSecurityGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteCacheSecurityGroupInput, ...request.Option) (*elasticache.DeleteCacheSecurityGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteCacheSecurityGroupInput, ...request.Option) *elasticache.DeleteCacheSecurityGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteCacheSecurityGroupOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DeleteCacheSubnetGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteCacheSubnetGroupInput, ...request.Option) (*elasticache.DeleteCacheSubnetGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteCacheSubnetGroupInput, ...request.Option) *elasticache.DeleteCacheSubnetGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteCacheSubnetGroupOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DeleteGlobalReplicationGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteGlobalReplicationGroupInput, ...request.Option) (*elasticache.DeleteGlobalReplicationGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteGlobalReplicationGroupInput, ...request.Option) *elasticache.DeleteGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DeleteReplicationGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteReplicationGroupInput, ...request.Option) (*elasticache.DeleteReplicationGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteReplicationGroupInput, ...request.Option) *elasticache.DeleteReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// DeleteServerlessCache provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) DeleteServerlessCache(_a0 *elasticache.DeleteServerlessCacheInput) (*elasticache.DeleteServerlessCacheOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DeleteServerlessCacheOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*elasticache.DeleteServerlessCacheInput) (*elasticache.DeleteServerlessCacheOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*elasticache.DeleteServerlessCacheInput) *elasticache.DeleteServerlessCacheOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteServerlessCacheOutput)
		}
	}

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

	return r0, r1
}

// DeleteServerlessCacheRequest provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) DeleteServerlessCacheRequest(_a0 *elasticache.DeleteServerlessCacheInput) (*request.Request, *elasticache.DeleteServerlessCacheOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

// DeleteServerlessCacheSnapshot provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) DeleteServerlessCacheSnapshot(_a0 *elasticache.DeleteServerlessCacheSnapshotInput) (*elasticache.DeleteServerlessCacheSnapshotOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DeleteServerlessCacheSnapshotOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*elasticache.DeleteServerlessCacheSnapshotInput) (*elasticache.DeleteServerlessCacheSnapshotOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*elasticache.DeleteServerlessCacheSnapshotInput) *elasticache.DeleteServerlessCacheSnapshotOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteServerlessCacheSnapshotOutput)
		}
	}

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

	return r0, r1
}

// DeleteServerlessCacheSnapshotRequest provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) DeleteServerlessCacheSnapshotRequest(_a0 *elasticache.DeleteServerlessCacheSnapshotInput) (*request.Request, *elasticache.DeleteServerlessCacheSnapshotOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

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

	var r0 *elasticache.DeleteServerlessCacheSnapshotOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteServerlessCacheSnapshotInput, ...request.Option) (*elasticache.DeleteServerlessCacheSnapshotOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteServerlessCacheSnapshotInput, ...request.Option) *elasticache.DeleteServerlessCacheSnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteServerlessCacheSnapshotOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *elasticache.DeleteServerlessCacheOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteServerlessCacheInput, ...request.Option) (*elasticache.DeleteServerlessCacheOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteServerlessCacheInput, ...request.Option) *elasticache.DeleteServerlessCacheOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteServerlessCacheOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DeleteSnapshotOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteSnapshotInput, ...request.Option) (*elasticache.DeleteSnapshotOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteSnapshotInput, ...request.Option) *elasticache.DeleteSnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteSnapshotOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DeleteUserGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteUserGroupInput, ...request.Option) (*elasticache.DeleteUserGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteUserGroupInput, ...request.Option) *elasticache.DeleteUserGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteUserGroupOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DeleteUserOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteUserInput, ...request.Option) (*elasticache.DeleteUserOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DeleteUserInput, ...request.Option) *elasticache.DeleteUserOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DeleteUserOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DescribeCacheClustersOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeCacheClustersInput, ...request.Option) (*elasticache.DescribeCacheClustersOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeCacheClustersInput, ...request.Option) *elasticache.DescribeCacheClustersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeCacheClustersOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DescribeCacheEngineVersionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeCacheEngineVersionsInput, ...request.Option) (*elasticache.DescribeCacheEngineVersionsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeCacheEngineVersionsInput, ...request.Option) *elasticache.DescribeCacheEngineVersionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeCacheEngineVersionsOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DescribeCacheParameterGroupsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeCacheParameterGroupsInput, ...request.Option) (*elasticache.DescribeCacheParameterGroupsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeCacheParameterGroupsInput, ...request.Option) *elasticache.DescribeCacheParameterGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeCacheParameterGroupsOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DescribeCacheParametersOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeCacheParametersInput, ...request.Option) (*elasticache.DescribeCacheParametersOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeCacheParametersInput, ...request.Option) *elasticache.DescribeCacheParametersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeCacheParametersOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DescribeCacheSecurityGroupsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeCacheSecurityGroupsInput, ...request.Option) (*elasticache.DescribeCacheSecurityGroupsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeCacheSecurityGroupsInput, ...request.Option) *elasticache.DescribeCacheSecurityGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeCacheSecurityGroupsOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DescribeCacheSubnetGroupsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeCacheSubnetGroupsInput, ...request.Option) (*elasticache.DescribeCacheSubnetGroupsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeCacheSubnetGroupsInput, ...request.Option) *elasticache.DescribeCacheSubnetGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeCacheSubnetGroupsOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DescribeGlobalReplicationGroupsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeGlobalReplicationGroupsInput, ...request.Option) (*elasticache.DescribeGlobalReplicationGroupsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeGlobalReplicationGroupsInput, ...request.Option) *elasticache.DescribeGlobalReplicationGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeGlobalReplicationGroupsOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DescribeReplicationGroupsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeReplicationGroupsInput, ...request.Option) (*elasticache.DescribeReplicationGroupsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeReplicationGroupsInput, ...request.Option) *elasticache.DescribeReplicationGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeReplicationGroupsOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DescribeReservedCacheNodesOfferingsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeReservedCacheNodesOfferingsInput, ...request.Option) (*elasticache.DescribeReservedCacheNodesOfferingsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeReservedCacheNodesOfferingsInput, ...request.Option) *elasticache.DescribeReservedCacheNodesOfferingsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeReservedCacheNodesOfferingsOutput)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DescribeReservedCacheNodesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeReservedCacheNodesInput, ...request.Option) (*elasticache.DescribeReservedCacheNodesOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeReservedCacheNodesInput, ...request.Option) *elasticache.DescribeReservedCacheNodesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeReservedCacheNodesOutput)
		}
	}

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

	return r0, r1
}

// DescribeServerlessCacheSnapshots provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) DescribeServerlessCacheSnapshots(_a0 *elasticache.DescribeServerlessCacheSnapshotsInput) (*elasticache.DescribeServerlessCacheSnapshotsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DescribeServerlessCacheSnapshotsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeServerlessCacheSnapshotsInput) (*elasticache.DescribeServerlessCacheSnapshotsOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeServerlessCacheSnapshotsInput) *elasticache.DescribeServerlessCacheSnapshotsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeServerlessCacheSnapshotsOutput)
		}
	}

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

	return r0, r1
}

// DescribeServerlessCacheSnapshotsPages provides a mock function with given fields: _a0, _a1
func (_m *ElastiCacheAPI) DescribeServerlessCacheSnapshotsPages(_a0 *elasticache.DescribeServerlessCacheSnapshotsInput, _a1 func(*elasticache.DescribeServerlessCacheSnapshotsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

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

	return r0
}

// DescribeServerlessCacheSnapshotsRequest provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) DescribeServerlessCacheSnapshotsRequest(_a0 *elasticache.DescribeServerlessCacheSnapshotsInput) (*request.Request, *elasticache.DescribeServerlessCacheSnapshotsOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

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

	var r0 *elasticache.DescribeServerlessCacheSnapshotsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeServerlessCacheSnapshotsInput, ...request.Option) (*elasticache.DescribeServerlessCacheSnapshotsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeServerlessCacheSnapshotsInput, ...request.Option) *elasticache.DescribeServerlessCacheSnapshotsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeServerlessCacheSnapshotsOutput)
		}
	}

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

	return r0, r1
}

// DescribeServerlessCaches provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) DescribeServerlessCaches(_a0 *elasticache.DescribeServerlessCachesInput) (*elasticache.DescribeServerlessCachesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.DescribeServerlessCachesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeServerlessCachesInput) (*elasticache.DescribeServerlessCachesOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*elasticache.DescribeServerlessCachesInput) *elasticache.DescribeServerlessCachesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeServerlessCachesOutput)
		}
	}

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

	return r0, r1
}

// DescribeServerlessCachesPages provides a mock function with given fields: _a0, _a1
func (_m *ElastiCacheAPI) DescribeServerlessCachesPages(_a0 *elasticache.DescribeServerlessCachesInput, _a1 func(*elasticache.DescribeServerlessCachesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

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

	return r0
}

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

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

	return r0
}

// DescribeServerlessCachesRequest provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) DescribeServerlessCachesRequest(_a0 *elasticache.DescribeServerlessCachesInput) (*request.Request, *elasticache.DescribeServerlessCachesOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

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

	var r0 *elasticache.DescribeServerlessCachesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeServerlessCachesInput, ...request.Option) (*elasticache.DescribeServerlessCachesOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeServerlessCachesInput, ...request.Option) *elasticache.DescribeServerlessCachesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeServerlessCachesOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DescribeServiceUpdatesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeServiceUpdatesInput, ...request.Option) (*elasticache.DescribeServiceUpdatesOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeServiceUpdatesInput, ...request.Option) *elasticache.DescribeServiceUpdatesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeServiceUpdatesOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DescribeSnapshotsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeSnapshotsInput, ...request.Option) (*elasticache.DescribeSnapshotsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeSnapshotsInput, ...request.Option) *elasticache.DescribeSnapshotsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeSnapshotsOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DescribeUpdateActionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeUpdateActionsInput, ...request.Option) (*elasticache.DescribeUpdateActionsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeUpdateActionsInput, ...request.Option) *elasticache.DescribeUpdateActionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeUpdateActionsOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DescribeUserGroupsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeUserGroupsInput, ...request.Option) (*elasticache.DescribeUserGroupsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeUserGroupsInput, ...request.Option) *elasticache.DescribeUserGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeUserGroupsOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

	return r0
}

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

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

	return r0
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DescribeUsersOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeUsersInput, ...request.Option) (*elasticache.DescribeUsersOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DescribeUsersInput, ...request.Option) *elasticache.DescribeUsersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DescribeUsersOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.DisassociateGlobalReplicationGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DisassociateGlobalReplicationGroupInput, ...request.Option) (*elasticache.DisassociateGlobalReplicationGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.DisassociateGlobalReplicationGroupInput, ...request.Option) *elasticache.DisassociateGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.DisassociateGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// ExportServerlessCacheSnapshot provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) ExportServerlessCacheSnapshot(_a0 *elasticache.ExportServerlessCacheSnapshotInput) (*elasticache.ExportServerlessCacheSnapshotOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.ExportServerlessCacheSnapshotOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*elasticache.ExportServerlessCacheSnapshotInput) (*elasticache.ExportServerlessCacheSnapshotOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*elasticache.ExportServerlessCacheSnapshotInput) *elasticache.ExportServerlessCacheSnapshotOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ExportServerlessCacheSnapshotOutput)
		}
	}

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

	return r0, r1
}

// ExportServerlessCacheSnapshotRequest provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) ExportServerlessCacheSnapshotRequest(_a0 *elasticache.ExportServerlessCacheSnapshotInput) (*request.Request, *elasticache.ExportServerlessCacheSnapshotOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

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

	var r0 *elasticache.ExportServerlessCacheSnapshotOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ExportServerlessCacheSnapshotInput, ...request.Option) (*elasticache.ExportServerlessCacheSnapshotOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ExportServerlessCacheSnapshotInput, ...request.Option) *elasticache.ExportServerlessCacheSnapshotOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ExportServerlessCacheSnapshotOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.FailoverGlobalReplicationGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.FailoverGlobalReplicationGroupInput, ...request.Option) (*elasticache.FailoverGlobalReplicationGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.FailoverGlobalReplicationGroupInput, ...request.Option) *elasticache.FailoverGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.FailoverGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.IncreaseNodeGroupsInGlobalReplicationGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.IncreaseNodeGroupsInGlobalReplicationGroupInput, ...request.Option) (*elasticache.IncreaseNodeGroupsInGlobalReplicationGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.IncreaseNodeGroupsInGlobalReplicationGroupInput, ...request.Option) *elasticache.IncreaseNodeGroupsInGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.IncreaseNodeGroupsInGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.IncreaseReplicaCountOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.IncreaseReplicaCountInput, ...request.Option) (*elasticache.IncreaseReplicaCountOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.IncreaseReplicaCountInput, ...request.Option) *elasticache.IncreaseReplicaCountOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.IncreaseReplicaCountOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.ListAllowedNodeTypeModificationsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ListAllowedNodeTypeModificationsInput, ...request.Option) (*elasticache.ListAllowedNodeTypeModificationsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ListAllowedNodeTypeModificationsInput, ...request.Option) *elasticache.ListAllowedNodeTypeModificationsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ListAllowedNodeTypeModificationsOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// ListTagsForResourceRequest provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) ListTagsForResourceRequest(_a0 *elasticache.ListTagsForResourceInput) (*request.Request, *elasticache.TagListMessage) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

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

	var r0 *elasticache.TagListMessage
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ListTagsForResourceInput, ...request.Option) (*elasticache.TagListMessage, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ListTagsForResourceInput, ...request.Option) *elasticache.TagListMessage); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.TagListMessage)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.ModifyCacheClusterOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyCacheClusterInput, ...request.Option) (*elasticache.ModifyCacheClusterOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyCacheClusterInput, ...request.Option) *elasticache.ModifyCacheClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyCacheClusterOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.CacheParameterGroupNameMessage
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyCacheParameterGroupInput, ...request.Option) (*elasticache.CacheParameterGroupNameMessage, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyCacheParameterGroupInput, ...request.Option) *elasticache.CacheParameterGroupNameMessage); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CacheParameterGroupNameMessage)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.ModifyCacheSubnetGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyCacheSubnetGroupInput, ...request.Option) (*elasticache.ModifyCacheSubnetGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyCacheSubnetGroupInput, ...request.Option) *elasticache.ModifyCacheSubnetGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyCacheSubnetGroupOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.ModifyGlobalReplicationGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyGlobalReplicationGroupInput, ...request.Option) (*elasticache.ModifyGlobalReplicationGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyGlobalReplicationGroupInput, ...request.Option) *elasticache.ModifyGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.ModifyReplicationGroupShardConfigurationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyReplicationGroupShardConfigurationInput, ...request.Option) (*elasticache.ModifyReplicationGroupShardConfigurationOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyReplicationGroupShardConfigurationInput, ...request.Option) *elasticache.ModifyReplicationGroupShardConfigurationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyReplicationGroupShardConfigurationOutput)
		}
	}

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

	return r0, r1
}

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

	var r0 *elasticache.ModifyReplicationGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyReplicationGroupInput, ...request.Option) (*elasticache.ModifyReplicationGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyReplicationGroupInput, ...request.Option) *elasticache.ModifyReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

// ModifyServerlessCache provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) ModifyServerlessCache(_a0 *elasticache.ModifyServerlessCacheInput) (*elasticache.ModifyServerlessCacheOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.ModifyServerlessCacheOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*elasticache.ModifyServerlessCacheInput) (*elasticache.ModifyServerlessCacheOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*elasticache.ModifyServerlessCacheInput) *elasticache.ModifyServerlessCacheOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyServerlessCacheOutput)
		}
	}

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

	return r0, r1
}

// ModifyServerlessCacheRequest provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) ModifyServerlessCacheRequest(_a0 *elasticache.ModifyServerlessCacheInput) (*request.Request, *elasticache.ModifyServerlessCacheOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

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

	var r0 *elasticache.ModifyServerlessCacheOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyServerlessCacheInput, ...request.Option) (*elasticache.ModifyServerlessCacheOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyServerlessCacheInput, ...request.Option) *elasticache.ModifyServerlessCacheOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyServerlessCacheOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.ModifyUserGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyUserGroupInput, ...request.Option) (*elasticache.ModifyUserGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyUserGroupInput, ...request.Option) *elasticache.ModifyUserGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyUserGroupOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.ModifyUserOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyUserInput, ...request.Option) (*elasticache.ModifyUserOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ModifyUserInput, ...request.Option) *elasticache.ModifyUserOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.ModifyUserOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.PurchaseReservedCacheNodesOfferingOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.PurchaseReservedCacheNodesOfferingInput, ...request.Option) (*elasticache.PurchaseReservedCacheNodesOfferingOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.PurchaseReservedCacheNodesOfferingInput, ...request.Option) *elasticache.PurchaseReservedCacheNodesOfferingOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.PurchaseReservedCacheNodesOfferingOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.RebalanceSlotsInGlobalReplicationGroupOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.RebalanceSlotsInGlobalReplicationGroupInput, ...request.Option) (*elasticache.RebalanceSlotsInGlobalReplicationGroupOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.RebalanceSlotsInGlobalReplicationGroupInput, ...request.Option) *elasticache.RebalanceSlotsInGlobalReplicationGroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.RebalanceSlotsInGlobalReplicationGroupOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.RebootCacheClusterOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.RebootCacheClusterInput, ...request.Option) (*elasticache.RebootCacheClusterOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.RebootCacheClusterInput, ...request.Option) *elasticache.RebootCacheClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.RebootCacheClusterOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

// RemoveTagsFromResourceRequest provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) RemoveTagsFromResourceRequest(_a0 *elasticache.RemoveTagsFromResourceInput) (*request.Request, *elasticache.TagListMessage) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

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

	var r0 *elasticache.TagListMessage
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.RemoveTagsFromResourceInput, ...request.Option) (*elasticache.TagListMessage, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.RemoveTagsFromResourceInput, ...request.Option) *elasticache.TagListMessage); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.TagListMessage)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.CacheParameterGroupNameMessage
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ResetCacheParameterGroupInput, ...request.Option) (*elasticache.CacheParameterGroupNameMessage, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.ResetCacheParameterGroupInput, ...request.Option) *elasticache.CacheParameterGroupNameMessage); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.CacheParameterGroupNameMessage)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.RevokeCacheSecurityGroupIngressOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.RevokeCacheSecurityGroupIngressInput, ...request.Option) (*elasticache.RevokeCacheSecurityGroupIngressOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.RevokeCacheSecurityGroupIngressInput, ...request.Option) *elasticache.RevokeCacheSecurityGroupIngressOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.RevokeCacheSecurityGroupIngressOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.StartMigrationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.StartMigrationInput, ...request.Option) (*elasticache.StartMigrationOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.StartMigrationInput, ...request.Option) *elasticache.StartMigrationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.StartMigrationOutput)
		}
	}

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

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

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

	return r0, r1
}

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

	var r0 *elasticache.TestFailoverOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.TestFailoverInput, ...request.Option) (*elasticache.TestFailoverOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.TestFailoverInput, ...request.Option) *elasticache.TestFailoverOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.TestFailoverOutput)
		}
	}

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

	return r0, r1
}

// TestMigration provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) TestMigration(_a0 *elasticache.TestMigrationInput) (*elasticache.TestMigrationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *elasticache.TestMigrationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(*elasticache.TestMigrationInput) (*elasticache.TestMigrationOutput, error)); ok {
		return rf(_a0)
	}
	if rf, ok := ret.Get(0).(func(*elasticache.TestMigrationInput) *elasticache.TestMigrationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.TestMigrationOutput)
		}
	}

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

	return r0, r1
}

// TestMigrationRequest provides a mock function with given fields: _a0
func (_m *ElastiCacheAPI) TestMigrationRequest(_a0 *elasticache.TestMigrationInput) (*request.Request, *elasticache.TestMigrationOutput) {
	ret := _m.Called(_a0)

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

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

	return r0, r1
}

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

	var r0 *elasticache.TestMigrationOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.TestMigrationInput, ...request.Option) (*elasticache.TestMigrationOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *elasticache.TestMigrationInput, ...request.Option) *elasticache.TestMigrationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*elasticache.TestMigrationOutput)
		}
	}

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

	return r0, r1
}

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

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

	return r0
}

// WaitUntilCacheClusterAvailableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ElastiCacheAPI) WaitUntilCacheClusterAvailableWithContext(_a0 context.Context, _a1 *elasticache.DescribeCacheClustersInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	return r0
}

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

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

	return r0
}

// WaitUntilCacheClusterDeletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ElastiCacheAPI) WaitUntilCacheClusterDeletedWithContext(_a0 context.Context, _a1 *elasticache.DescribeCacheClustersInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	return r0
}

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

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

	return r0
}

// WaitUntilReplicationGroupAvailableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ElastiCacheAPI) WaitUntilReplicationGroupAvailableWithContext(_a0 context.Context, _a1 *elasticache.DescribeReplicationGroupsInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	return r0
}

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

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

	return r0
}

// WaitUntilReplicationGroupDeletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *ElastiCacheAPI) WaitUntilReplicationGroupDeletedWithContext(_a0 context.Context, _a1 *elasticache.DescribeReplicationGroupsInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	return r0
}

// NewElastiCacheAPI creates a new instance of ElastiCacheAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewElastiCacheAPI(t interface {
	mock.TestingT
	Cleanup(func())
}) *ElastiCacheAPI {
	mock := &ElastiCacheAPI{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}