// Code generated by MockGen. DO NOT EDIT.
// Source: cache.go
//
// Generated by this command:
//
//	mockgen -source=cache.go -package=mock -destination=./mock/cache.go
//

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

import (
	reflect "reflect"
	time "time"

	gomock "go.uber.org/mock/gomock"

	v3 "github.com/bucketeer-io/bucketeer/v2/pkg/redis/v3"
)

// MockCache is a mock of Cache interface.
type MockCache struct {
	ctrl     *gomock.Controller
	recorder *MockCacheMockRecorder
}

// MockCacheMockRecorder is the mock recorder for MockCache.
type MockCacheMockRecorder struct {
	mock *MockCache
}

// NewMockCache creates a new mock instance.
func NewMockCache(ctrl *gomock.Controller) *MockCache {
	mock := &MockCache{ctrl: ctrl}
	mock.recorder = &MockCacheMockRecorder{mock}
	return mock
}

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

// Get mocks base method.
func (m *MockCache) Get(key any) (any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", key)
	ret0, _ := ret[0].(any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockCacheMockRecorder) Get(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockCache)(nil).Get), key)
}

// Put mocks base method.
func (m *MockCache) Put(key, value any, expiration time.Duration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Put", key, value, expiration)
	ret0, _ := ret[0].(error)
	return ret0
}

// Put indicates an expected call of Put.
func (mr *MockCacheMockRecorder) Put(key, value, expiration any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockCache)(nil).Put), key, value, expiration)
}

// MockMultiGetCache is a mock of MultiGetCache interface.
type MockMultiGetCache struct {
	ctrl     *gomock.Controller
	recorder *MockMultiGetCacheMockRecorder
}

// MockMultiGetCacheMockRecorder is the mock recorder for MockMultiGetCache.
type MockMultiGetCacheMockRecorder struct {
	mock *MockMultiGetCache
}

// NewMockMultiGetCache creates a new mock instance.
func NewMockMultiGetCache(ctrl *gomock.Controller) *MockMultiGetCache {
	mock := &MockMultiGetCache{ctrl: ctrl}
	mock.recorder = &MockMultiGetCacheMockRecorder{mock}
	return mock
}

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

// Get mocks base method.
func (m *MockMultiGetCache) Get(key any) (any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", key)
	ret0, _ := ret[0].(any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockMultiGetCacheMockRecorder) Get(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockMultiGetCache)(nil).Get), key)
}

// GetMulti mocks base method.
func (m *MockMultiGetCache) GetMulti(keys any, ignoreNotFound bool) ([]any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMulti", keys, ignoreNotFound)
	ret0, _ := ret[0].([]any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMulti indicates an expected call of GetMulti.
func (mr *MockMultiGetCacheMockRecorder) GetMulti(keys, ignoreNotFound any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMulti", reflect.TypeOf((*MockMultiGetCache)(nil).GetMulti), keys, ignoreNotFound)
}

// Put mocks base method.
func (m *MockMultiGetCache) Put(key, value any, expiration time.Duration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Put", key, value, expiration)
	ret0, _ := ret[0].(error)
	return ret0
}

// Put indicates an expected call of Put.
func (mr *MockMultiGetCacheMockRecorder) Put(key, value, expiration any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockMultiGetCache)(nil).Put), key, value, expiration)
}

// SMembers mocks base method.
func (m *MockMultiGetCache) SMembers(key string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SMembers", key)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SMembers indicates an expected call of SMembers.
func (mr *MockMultiGetCacheMockRecorder) SMembers(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembers", reflect.TypeOf((*MockMultiGetCache)(nil).SMembers), key)
}

// Scan mocks base method.
func (m *MockMultiGetCache) Scan(cursor, key, count any) (uint64, []string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Scan", cursor, key, count)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].([]string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Scan indicates an expected call of Scan.
func (mr *MockMultiGetCacheMockRecorder) Scan(cursor, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockMultiGetCache)(nil).Scan), cursor, key, count)
}

// MockMultiGetDeleteCountCache is a mock of MultiGetDeleteCountCache interface.
type MockMultiGetDeleteCountCache struct {
	ctrl     *gomock.Controller
	recorder *MockMultiGetDeleteCountCacheMockRecorder
}

// MockMultiGetDeleteCountCacheMockRecorder is the mock recorder for MockMultiGetDeleteCountCache.
type MockMultiGetDeleteCountCacheMockRecorder struct {
	mock *MockMultiGetDeleteCountCache
}

// NewMockMultiGetDeleteCountCache creates a new mock instance.
func NewMockMultiGetDeleteCountCache(ctrl *gomock.Controller) *MockMultiGetDeleteCountCache {
	mock := &MockMultiGetDeleteCountCache{ctrl: ctrl}
	mock.recorder = &MockMultiGetDeleteCountCacheMockRecorder{mock}
	return mock
}

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

// Delete mocks base method.
func (m *MockMultiGetDeleteCountCache) Delete(key string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", key)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockMultiGetDeleteCountCacheMockRecorder) Delete(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockMultiGetDeleteCountCache)(nil).Delete), key)
}

// Expire mocks base method.
func (m *MockMultiGetDeleteCountCache) Expire(key string, expiration time.Duration) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Expire", key, expiration)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Expire indicates an expected call of Expire.
func (mr *MockMultiGetDeleteCountCacheMockRecorder) Expire(key, expiration any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expire", reflect.TypeOf((*MockMultiGetDeleteCountCache)(nil).Expire), key, expiration)
}

// Get mocks base method.
func (m *MockMultiGetDeleteCountCache) Get(key any) (any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", key)
	ret0, _ := ret[0].(any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockMultiGetDeleteCountCacheMockRecorder) Get(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockMultiGetDeleteCountCache)(nil).Get), key)
}

// GetMulti mocks base method.
func (m *MockMultiGetDeleteCountCache) GetMulti(keys any, ignoreNotFound bool) ([]any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMulti", keys, ignoreNotFound)
	ret0, _ := ret[0].([]any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMulti indicates an expected call of GetMulti.
func (mr *MockMultiGetDeleteCountCacheMockRecorder) GetMulti(keys, ignoreNotFound any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMulti", reflect.TypeOf((*MockMultiGetDeleteCountCache)(nil).GetMulti), keys, ignoreNotFound)
}

// Increment mocks base method.
func (m *MockMultiGetDeleteCountCache) Increment(key string) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Increment", key)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Increment indicates an expected call of Increment.
func (mr *MockMultiGetDeleteCountCacheMockRecorder) Increment(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Increment", reflect.TypeOf((*MockMultiGetDeleteCountCache)(nil).Increment), key)
}

// PFAdd mocks base method.
func (m *MockMultiGetDeleteCountCache) PFAdd(key string, els ...string) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{key}
	for _, a := range els {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PFAdd", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PFAdd indicates an expected call of PFAdd.
func (mr *MockMultiGetDeleteCountCacheMockRecorder) PFAdd(key any, els ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{key}, els...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFAdd", reflect.TypeOf((*MockMultiGetDeleteCountCache)(nil).PFAdd), varargs...)
}

// PFCount mocks base method.
func (m *MockMultiGetDeleteCountCache) PFCount(keys ...string) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PFCount", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PFCount indicates an expected call of PFCount.
func (mr *MockMultiGetDeleteCountCacheMockRecorder) PFCount(keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFCount", reflect.TypeOf((*MockMultiGetDeleteCountCache)(nil).PFCount), keys...)
}

// PFMerge mocks base method.
func (m *MockMultiGetDeleteCountCache) PFMerge(dest string, expiration time.Duration, keys ...string) error {
	m.ctrl.T.Helper()
	varargs := []any{dest, expiration}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PFMerge", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// PFMerge indicates an expected call of PFMerge.
func (mr *MockMultiGetDeleteCountCacheMockRecorder) PFMerge(dest, expiration any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{dest, expiration}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFMerge", reflect.TypeOf((*MockMultiGetDeleteCountCache)(nil).PFMerge), varargs...)
}

// Pipeline mocks base method.
func (m *MockMultiGetDeleteCountCache) Pipeline(tx bool) v3.PipeClient {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Pipeline", tx)
	ret0, _ := ret[0].(v3.PipeClient)
	return ret0
}

// Pipeline indicates an expected call of Pipeline.
func (mr *MockMultiGetDeleteCountCacheMockRecorder) Pipeline(tx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipeline", reflect.TypeOf((*MockMultiGetDeleteCountCache)(nil).Pipeline), tx)
}

// Put mocks base method.
func (m *MockMultiGetDeleteCountCache) Put(key, value any, expiration time.Duration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Put", key, value, expiration)
	ret0, _ := ret[0].(error)
	return ret0
}

// Put indicates an expected call of Put.
func (mr *MockMultiGetDeleteCountCacheMockRecorder) Put(key, value, expiration any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockMultiGetDeleteCountCache)(nil).Put), key, value, expiration)
}

// SMembers mocks base method.
func (m *MockMultiGetDeleteCountCache) SMembers(key string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SMembers", key)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SMembers indicates an expected call of SMembers.
func (mr *MockMultiGetDeleteCountCacheMockRecorder) SMembers(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembers", reflect.TypeOf((*MockMultiGetDeleteCountCache)(nil).SMembers), key)
}

// Scan mocks base method.
func (m *MockMultiGetDeleteCountCache) Scan(cursor, key, count any) (uint64, []string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Scan", cursor, key, count)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].([]string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Scan indicates an expected call of Scan.
func (mr *MockMultiGetDeleteCountCacheMockRecorder) Scan(cursor, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockMultiGetDeleteCountCache)(nil).Scan), cursor, key, count)
}

// MockGetter is a mock of Getter interface.
type MockGetter struct {
	ctrl     *gomock.Controller
	recorder *MockGetterMockRecorder
}

// MockGetterMockRecorder is the mock recorder for MockGetter.
type MockGetterMockRecorder struct {
	mock *MockGetter
}

// NewMockGetter creates a new mock instance.
func NewMockGetter(ctrl *gomock.Controller) *MockGetter {
	mock := &MockGetter{ctrl: ctrl}
	mock.recorder = &MockGetterMockRecorder{mock}
	return mock
}

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

// Get mocks base method.
func (m *MockGetter) Get(key any) (any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", key)
	ret0, _ := ret[0].(any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockGetterMockRecorder) Get(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockGetter)(nil).Get), key)
}

// MockPFGetter is a mock of PFGetter interface.
type MockPFGetter struct {
	ctrl     *gomock.Controller
	recorder *MockPFGetterMockRecorder
}

// MockPFGetterMockRecorder is the mock recorder for MockPFGetter.
type MockPFGetterMockRecorder struct {
	mock *MockPFGetter
}

// NewMockPFGetter creates a new mock instance.
func NewMockPFGetter(ctrl *gomock.Controller) *MockPFGetter {
	mock := &MockPFGetter{ctrl: ctrl}
	mock.recorder = &MockPFGetterMockRecorder{mock}
	return mock
}

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

// PFCount mocks base method.
func (m *MockPFGetter) PFCount(keys ...string) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PFCount", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PFCount indicates an expected call of PFCount.
func (mr *MockPFGetterMockRecorder) PFCount(keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFCount", reflect.TypeOf((*MockPFGetter)(nil).PFCount), keys...)
}

// MockMultiGetter is a mock of MultiGetter interface.
type MockMultiGetter struct {
	ctrl     *gomock.Controller
	recorder *MockMultiGetterMockRecorder
}

// MockMultiGetterMockRecorder is the mock recorder for MockMultiGetter.
type MockMultiGetterMockRecorder struct {
	mock *MockMultiGetter
}

// NewMockMultiGetter creates a new mock instance.
func NewMockMultiGetter(ctrl *gomock.Controller) *MockMultiGetter {
	mock := &MockMultiGetter{ctrl: ctrl}
	mock.recorder = &MockMultiGetterMockRecorder{mock}
	return mock
}

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

// GetMulti mocks base method.
func (m *MockMultiGetter) GetMulti(keys any, ignoreNotFound bool) ([]any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMulti", keys, ignoreNotFound)
	ret0, _ := ret[0].([]any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMulti indicates an expected call of GetMulti.
func (mr *MockMultiGetterMockRecorder) GetMulti(keys, ignoreNotFound any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMulti", reflect.TypeOf((*MockMultiGetter)(nil).GetMulti), keys, ignoreNotFound)
}

// SMembers mocks base method.
func (m *MockMultiGetter) SMembers(key string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SMembers", key)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SMembers indicates an expected call of SMembers.
func (mr *MockMultiGetterMockRecorder) SMembers(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembers", reflect.TypeOf((*MockMultiGetter)(nil).SMembers), key)
}

// Scan mocks base method.
func (m *MockMultiGetter) Scan(cursor, key, count any) (uint64, []string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Scan", cursor, key, count)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].([]string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Scan indicates an expected call of Scan.
func (mr *MockMultiGetterMockRecorder) Scan(cursor, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockMultiGetter)(nil).Scan), cursor, key, count)
}

// MockPutter is a mock of Putter interface.
type MockPutter struct {
	ctrl     *gomock.Controller
	recorder *MockPutterMockRecorder
}

// MockPutterMockRecorder is the mock recorder for MockPutter.
type MockPutterMockRecorder struct {
	mock *MockPutter
}

// NewMockPutter creates a new mock instance.
func NewMockPutter(ctrl *gomock.Controller) *MockPutter {
	mock := &MockPutter{ctrl: ctrl}
	mock.recorder = &MockPutterMockRecorder{mock}
	return mock
}

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

// Put mocks base method.
func (m *MockPutter) Put(key, value any, expiration time.Duration) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Put", key, value, expiration)
	ret0, _ := ret[0].(error)
	return ret0
}

// Put indicates an expected call of Put.
func (mr *MockPutterMockRecorder) Put(key, value, expiration any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockPutter)(nil).Put), key, value, expiration)
}

// MockDeleter is a mock of Deleter interface.
type MockDeleter struct {
	ctrl     *gomock.Controller
	recorder *MockDeleterMockRecorder
}

// MockDeleterMockRecorder is the mock recorder for MockDeleter.
type MockDeleterMockRecorder struct {
	mock *MockDeleter
}

// NewMockDeleter creates a new mock instance.
func NewMockDeleter(ctrl *gomock.Controller) *MockDeleter {
	mock := &MockDeleter{ctrl: ctrl}
	mock.recorder = &MockDeleterMockRecorder{mock}
	return mock
}

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

// Delete mocks base method.
func (m *MockDeleter) Delete(key string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", key)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockDeleterMockRecorder) Delete(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockDeleter)(nil).Delete), key)
}

// MockCounter is a mock of Counter interface.
type MockCounter struct {
	ctrl     *gomock.Controller
	recorder *MockCounterMockRecorder
}

// MockCounterMockRecorder is the mock recorder for MockCounter.
type MockCounterMockRecorder struct {
	mock *MockCounter
}

// NewMockCounter creates a new mock instance.
func NewMockCounter(ctrl *gomock.Controller) *MockCounter {
	mock := &MockCounter{ctrl: ctrl}
	mock.recorder = &MockCounterMockRecorder{mock}
	return mock
}

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

// Increment mocks base method.
func (m *MockCounter) Increment(key string) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Increment", key)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Increment indicates an expected call of Increment.
func (mr *MockCounterMockRecorder) Increment(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Increment", reflect.TypeOf((*MockCounter)(nil).Increment), key)
}

// PFAdd mocks base method.
func (m *MockCounter) PFAdd(key string, els ...string) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{key}
	for _, a := range els {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PFAdd", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PFAdd indicates an expected call of PFAdd.
func (mr *MockCounterMockRecorder) PFAdd(key any, els ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{key}, els...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFAdd", reflect.TypeOf((*MockCounter)(nil).PFAdd), varargs...)
}

// MockPipeLiner is a mock of PipeLiner interface.
type MockPipeLiner struct {
	ctrl     *gomock.Controller
	recorder *MockPipeLinerMockRecorder
}

// MockPipeLinerMockRecorder is the mock recorder for MockPipeLiner.
type MockPipeLinerMockRecorder struct {
	mock *MockPipeLiner
}

// NewMockPipeLiner creates a new mock instance.
func NewMockPipeLiner(ctrl *gomock.Controller) *MockPipeLiner {
	mock := &MockPipeLiner{ctrl: ctrl}
	mock.recorder = &MockPipeLinerMockRecorder{mock}
	return mock
}

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

// Pipeline mocks base method.
func (m *MockPipeLiner) Pipeline(tx bool) v3.PipeClient {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Pipeline", tx)
	ret0, _ := ret[0].(v3.PipeClient)
	return ret0
}

// Pipeline indicates an expected call of Pipeline.
func (mr *MockPipeLinerMockRecorder) Pipeline(tx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipeline", reflect.TypeOf((*MockPipeLiner)(nil).Pipeline), tx)
}

// MockExpirer is a mock of Expirer interface.
type MockExpirer struct {
	ctrl     *gomock.Controller
	recorder *MockExpirerMockRecorder
}

// MockExpirerMockRecorder is the mock recorder for MockExpirer.
type MockExpirerMockRecorder struct {
	mock *MockExpirer
}

// NewMockExpirer creates a new mock instance.
func NewMockExpirer(ctrl *gomock.Controller) *MockExpirer {
	mock := &MockExpirer{ctrl: ctrl}
	mock.recorder = &MockExpirerMockRecorder{mock}
	return mock
}

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

// Expire mocks base method.
func (m *MockExpirer) Expire(key string, expiration time.Duration) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Expire", key, expiration)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Expire indicates an expected call of Expire.
func (mr *MockExpirerMockRecorder) Expire(key, expiration any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expire", reflect.TypeOf((*MockExpirer)(nil).Expire), key, expiration)
}

// MockPFMerger is a mock of PFMerger interface.
type MockPFMerger struct {
	ctrl     *gomock.Controller
	recorder *MockPFMergerMockRecorder
}

// MockPFMergerMockRecorder is the mock recorder for MockPFMerger.
type MockPFMergerMockRecorder struct {
	mock *MockPFMerger
}

// NewMockPFMerger creates a new mock instance.
func NewMockPFMerger(ctrl *gomock.Controller) *MockPFMerger {
	mock := &MockPFMerger{ctrl: ctrl}
	mock.recorder = &MockPFMergerMockRecorder{mock}
	return mock
}

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

// PFMerge mocks base method.
func (m *MockPFMerger) PFMerge(dest string, expiration time.Duration, keys ...string) error {
	m.ctrl.T.Helper()
	varargs := []any{dest, expiration}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PFMerge", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// PFMerge indicates an expected call of PFMerge.
func (mr *MockPFMergerMockRecorder) PFMerge(dest, expiration any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{dest, expiration}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFMerge", reflect.TypeOf((*MockPFMerger)(nil).PFMerge), varargs...)
}

// MockLister is a mock of Lister interface.
type MockLister struct {
	ctrl     *gomock.Controller
	recorder *MockListerMockRecorder
}

// MockListerMockRecorder is the mock recorder for MockLister.
type MockListerMockRecorder struct {
	mock *MockLister
}

// NewMockLister creates a new mock instance.
func NewMockLister(ctrl *gomock.Controller) *MockLister {
	mock := &MockLister{ctrl: ctrl}
	mock.recorder = &MockListerMockRecorder{mock}
	return mock
}

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

// Keys mocks base method.
func (m *MockLister) Keys(pattern string, maxSize int) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Keys", pattern, maxSize)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Keys indicates an expected call of Keys.
func (mr *MockListerMockRecorder) Keys(pattern, maxSize any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Keys", reflect.TypeOf((*MockLister)(nil).Keys), pattern, maxSize)
}
